1. Introduction
Bonfire is a modular, extensible, privacy-focused federated platform built on top of ActivityPub and ActivityStreams. It aims to provide a flexible foundation for building social, collaborative, and community-oriented applications that can interoperate with the wider Fediverse.
Unlike monolithic platforms, Bonfire is designed built as a framework that powers multiple apps (flavours) with features provided by optional extensions, allowing instances to enable only the features they need. This modularity also makes it easier to experiment with new protocols, object types, and interaction patterns.
Bonfire strives for maximum interoperability with other ActivityPub-based software such as Mastodon, Pixelfed, Mobilizon, GoToSocial 8, Peertube, and others, while also supporting advanced privacy controls, custom boundaries, and experimental FEPs.
This guide documents how Bonfire federates, how it handles ActivityPub objects and activities, and what to expect when integrating with or building on top of Bonfire.
- Protocols: ActivityPub, WebFinger
- Syntax: ActivityStreams Core
- Vocabulary: ActivityStreams Vocabulary, ValueFlows13
- Extensions: ActivityPub FEPs, Bonfire extensions
See the Glossary for definitions of key terms.
2. Protocol Support & Endpoints
Bonfire supports the core ActivityPub server-to-server (S2S) protocol for federation, as well as WebFinger for user and resource discovery. This enables Bonfire instances to interoperate with a wide range of other Fediverse software, including Mastodon, Akkoma 5, Pixelfed, Mobilizon, Wordpress, GoToSocial 8, and many more.
ActivityPub Endpoints
Bonfire exposes the standard ActivityPub endpoints for each actor:
- Inbox: Receives incoming activities from remote servers.
Example:https://your.bonfire.instance/pub/actors/{username}/inbox - Outbox: Lists activities published by the actor.
Example:https://your.bonfire.instance/pub/actors/{username}/outbox - Followers / Following: Collections of followers and followed actors.
- Shared Inbox: (Optional) For batching deliveries to multiple actors on the same instance.
HTTP requests should use the correct Accept header (application/activity+json or application/ld+json; profile="https://www.w3.org/ns/activitystreams").
See ActivityPub Spec and ActivityStreams Core for details on endpoint structure and payloads.
WebFinger Endpoint
Bonfire implements the WebFinger protocol for resource discovery:
- Endpoint:
https://your.bonfire.instance/.well-known/webfinger - Query parameter:
resource=acct:username@domain
WebFinger is essential for interoperability with most ActivityPub implementations, as it allows translating @user@domain identifiers into canonical ActivityPub actor URIs. Bonfire ensures that the rel=self link and subject fields are correct, and supports both application/activity+json and application/ld+json; profile="https://www.w3.org/ns/activitystreams" content types for maximum compatibility.
WebFinger responses include links to the actor's ActivityPub profile and HTML profile page. See WebFinger RFC for details.
Supported Verbs and Objects
Bonfire supports all major ActivityPub activity types (verbs), including:
Create,Update,Delete,Follow,Accept,Reject,Undo,Like,Announce,Flag,Block,Move, and more.
Supported object types include Note, Article, and others as defined in ActivityStreams Vocabulary. Any object types not specifically implemented (in a Bonfire extension) are still stored as JSON objects, with a fallback preview UI component attempting to display them in feeds (tip: use the preview property to attach another object such as a Note to be used as a preview for unimplemented objects).
Compatibility
Bonfire aims for broad compatibility with major ActivityPub implementations. It supports and regularly tests against:
- Mastodon 3, Akomma, GoToSocial 8
- Misskey and derivatives
- Pixelfed
- Peertube
- Mobilizon
- WriteFreely, Wordpress, and Ghost
- Lemmy, kbin, and PieFed
- Castopod, and Funkwhale
- BookWyrm
- And more
FEPs and Extensions
Bonfire implements and/or experiments with several Fediverse Enhancement Proposals (FEPs), including:
- FEP-044f - Quote posts
- FEP-e232 - Object links: used for the
Linktag of a quote. - FEP-1b12 - Group federation: see Groups and topics.
- FEP-9b2b - Concept relationships for federated classification: a draft. Topics use its
broaderandinScheme. - FEP-844e - Capability discovery
- FEP-8b32 - Object integrity proofs: see Object integrity proofs.
- FEP-521a - Representing actor's public keys
- FEP-fe34 - Origin-based security model
- FEP-5feb - Search indexing consent for actors: through
indexableanddiscoverable. - FEP-2677 - Identifying the application actor
- FEP-d556 - Server-level actor discovery using WebFinger
- FEP-8a8e - A common approach to using the Event object type
- FEP-8967 - Generating link previews for attached links: incoming only.
- FEP-07d7 - Handling
web+apURLs - FEP-67ff - FEDERATION.md: this file.
Partial support (incoming only, or only some of the proposal):
- FEP-171b - Conversation containers: Bonfire reads an
Addof an activity into a conversation, as Hubzilla and Streams send, but sends none. - FEP-400e - Publicly appendable collections:
Add/Removeto our collections are accepted from their owner and fanned out to followers. From remote groups,Add/Removeon the moderators,narrowerandfeaturedcollections are applied, others such as Smithereen walls not handled yet. - FEP-ae97 - Client-side activity signing: Bonfire accepts client keys listed in an actor's
assertionMethod. - FEP-9967 - Polls:
Questionobjects are handled, but conformity to the FEP is not confirmed.
Partial support or conformity to-be-confirmed (help needed!):
- FEP-f1d5, FEP-eb22 and/or FEP-0151 - NodeInfo
- FEP-2277 - ActivityPub core types
- FEP-4adb - Dereferencing identifiers through WebFinger
- FEP-268d - Search consent signals for objects
- FEP-d8c2 - OAuth 2.0 profile for the ActivityPub API
- FEP-7628, FEP-73cd and/or FEP-e965 - Move actor
- FEP-c0e0 - Emoji reactions: incoming only.
- FEP-9098 - Custom emojis
- FEP-f228 - Backfilling conversations
- FEP-a974 - All actor types should be followable
- FEP-1311 - Media attachments
- FEP-b2b8 - Long-form text
- FEP-76ea - Conversation threads
- FEP-7458 - Using the replies collection
- FEP-c16b - Formatting MFM functions
- FEP-eb48 - Hashtags
Work-in-progress, planned, or exploring (suggestions/feedback welcome!):
- FEP-efda - Followable objects
- FEP-0499 - Delivering to multiple inboxes with a multibox endpoint
- FEP-6fcd - Account export container format
- FEP-3264 - Federated work coordination
- FEP-c5a1 - Todos
Support for additional FEPs and experimental features not listed here may be implemented and enabled by extensions.
Other specifications and RFCs
Bonfire also implements these RFCs and extensions from other projects:
- RFC 9421 - HTTP Message Signatures: both ways, including its
Accept-Signatureheader. See HTTP Signatures. - draft-cavage HTTP Signatures: both ways.
- RFC 3230 -
Digestand RFC 9530 -Content-Digest: checked on incoming requests. - RFC 7033 - WebFinger: both ways.
- RFC 8288 - Web Linking: when a fetch returns HTML, Bonfire follows an
application/activity+jsonalternate in theLinkheader or the page, and its Mastodon-compatible API paginates withLinkheaders. Bonfire's own HTML pages don't offer an ActivityPub alternate yet. - RFC 8414 - OAuth authorization server metadata: served at
/.well-known/oauth-authorization-server. - RFC 8785 - JSON Canonicalization Scheme and RFC 8032 - Ed25519: for object integrity proofs.
- RFC 3339 - Dates: outgoing dates always carry a timezone.
- GoToSocial interaction policies:
interactionPolicy, both ways. See Interaction Policies. - Group extensions from Lemmy (
postingRestrictedToMods,Lock), Mobilizon (openness), Smithereen and litepub (capabilities.acceptsJoins): see Groups and topics. - Quote conventions of Misskey (
_misskey_quote), Fedibird (quoteUri) and Akkoma (quoteUrl): read on incoming posts. - PeerTube's
commentsEnabled: both ways. - Mastodon's
featured,discoverable,indexableandalsoKnownAs: both ways. - MLS over ActivityPub (
keyPackages,mls:messages): advertised on actors.
For more on Bonfire's federation rules and extension points, see the Bonfire documentation.
3. Actor & Object Model
Bonfire uses the ActivityStreams data model for representing actors and objects, along with the ActivityPub specification and ActivityStreams Vocabulary. This section describes how Bonfire maps its internal data to ActivityPub actors and objects, and how it interprets incoming data from remote instances.
Actor Types
Bonfire supports the following ActivityStreams actor types:
- Person: Represents a user account or individual.
- Group: Represents a group, category, or collective identity (see Groups and topics).
- Service: Used for bots or automated accounts.
- (Other types may be supported by extensions.)
Bonfire maps its internal "character" abstraction (users, groups, categories, etc.) to the appropriate ActivityStreams actor type. See Canonical URI for how actor IDs are constructed.
Object Types
Bonfire supports a wide range of ActivityStreams object types, including:
- Note: Short-form post or status update.
- Article: Long-form post or article.
- Question: Poll or question (if enabled by extension).
- Image, Video, Audio, Event, etc. (as defined in ActivityStreams Vocabulary and supported by extensions).
Objects not explicitly supported by Bonfire are still stored and can be previewed in the UI, with a fallback display.
Addressing and Audience
Bonfire uses the standard ActivityPub addressing fields to determine the audience for activities and objects:
to: Primary recipients (can include actors, collections, or the Public URI).cc: Secondary recipients (e.g., followers).bto,bcc: Blind recipients (not visible to all, used for addressing activities with custom circles or boundaries).audience: Additional audience specification (rarely used).
Addressing and Visibility Mapping
| Addressing Fields Example | Visibility Level | Notes |
|---|---|---|
to: Public | Public | Visible to everyone, delivered to all followers and public timelines. |
to: followers | Followers-only | Only followers can see/interact. |
to: [actor1, actor2] | Direct (DM) | Only addressed actors can see/interact. |
bto/bcc | Blind recipients | Recipients not visible to others (used to apply circles/boundaries in outgoing activities). |
Bonfire interprets these fields according to the ActivityPub spec and enforces boundaries and privacy accordingly.
Canonical URIs and ID Formats
All Bonfire actors and objects have globally unique, canonical URIs (typically HTTPS URLs) that serve as their ActivityPub id. These URIs are stable and dereferenceable, allowing remote instances to fetch the ActivityStreams representation of the resource.
- Example actor URI:
https://a.bonfire.instance/pub/actors/alice - Example object URI:
https://a.bonfire.instance/pub/objects/01H8ZK2YXP9QCT5BE1JWQSAM3B6
Bonfire uses ULIDs for object IDs, ensuring uniqueness and sortability.
For more details on actor and object mapping, see Bonfire ActivityPub Implementation Docs and ActivityStreams Vocabulary.
4. Content Types & Extensions
Bonfire supports a broad range of ActivityStreams object types, as defined in the ActivityStreams Vocabulary. The most common types are:
- Note: Short-form post or status update.
- Article: Long-form post or article.
- Image, Video, Audio, Link: Media attachments.
- Event, Question, etc: Supported if a relevant Bonfire extension is enabled.
- Any other types: Any object (whether defined in ActivityStreams or not) type will be stored and displayed, even if not natively supported by any enabled Bonfire extension. For unknown types, Bonfire attempts to render a preview using the
previewproperty if present, otherwise using fallbacks to generate a preview using some common object properties such asname,summary, orimage.
Extensions and Custom Types or Properties
Bonfire supports AP extensions such as:
- Hashtag: For topic tags, using the
Hashtagobject type. - Emoji: For custom emoji, using the
Emojiobject type. - PropertyValue: For profile metadata fields, using the [schema.org PropertyValue][propertyvalue] extension.
As of this writing there is no Bonfire extension currently defining new object types or properties, but extensions can add support for new types or properties. Some extensions are using types and properties defined by specs or FEPs outside of ActivityStreams though, for example enabling the ValueFlows extension adds support for economic objects and activities as defined by the ValueFlows vocabulary. This should be documented in each extension's docs or right here:
FEPs, Experimental Features, and Handling of Unknown and Custom Types
Bonfire stores and attempts to render any ActivityStreams object type, even if not natively supported. For unknown types, Bonfire uses the preview property if present, or falls back to common properties like name, summary, or image. Mastodon, GoToSocial, and Akkoma-specific extensions and properties are generally ignored unless mapped by a Bonfire extension.
Extensions from Other Platforms
Bonfire will always store, and depending on what extensions are implemented and enabled, may ignore or use/render Mastodon/GoToSocial/Akkoma-specific extensions such as toot:Emoji, toot:blurhash, and others. See AP Extensions for more.
Profile Metadata and Attachments
Bonfire represents profile fields using PropertyValue objects in the attachment array, following the schema.org extension used by Mastodon and GoToSocial. Note that Mastodon uses the context http://schema.org# (incorrect), while Bonfire uses the correct https://schema.org/. Bonfire will parse both for compatibility.
Hashtags, Mentions, and Emojis
Bonfire encodes hashtags, mentions, and custom emojis in the tag array, using the Hashtag, Mention, and Emoji types as defined in ActivityStreams and Mastodon extensions. These are rendered in the UI and federated as appropriate.
Blurhash
Bonfire creates and displays blurhashes (blurhash) for image attachments, as defined by Mastodon and GoToSocial. These properties are used to improve media display and previews in the UI.
Providing Source Markdown
Bonfire includes the original source (markdown) of posts in the source property of ActivityPub objects, in addition to the rendered HTML in content. This allows remote servers and clients to display or edit the original markdown if desired, improving fidelity and interoperability.
Example: Outgoing Note with Markdown Source
{
"@context": [
"https://www.w3.org/ns/activitystreams",
{
"@language": "en",
"Hashtag": "as:Hashtag",
"ValueFlows": "https://w3id.org/valueflows#",
"_misskey_quote": "https://misskey-hub.net/ns/#_misskey_quote",
"om2": "http://www.ontology-of-units-of-measure.org/resource/om-2/",
"quote": {"@id": "https://w3id.org/fep/044f#quote", "@type": "@id"},
"quoteAuthorization": {"@id": "https://w3id.org/fep/044f#quoteAuthorization", "@type": "@id"},
"sensitive": "as:sensitive"
}
],
"attachment": [],
"attributedTo": "https://bonfire.cafe/pub/actors/example",
"cc": [],
"content": "<p>“To oppose something is to maintain it... You must go somewhere else; you must have another goal; then you walk a different road.” <br/> ― Ursula K. Le Guin</p>",
"id": "https://bonfire.cafe/pub/objects/01K5EX3HRWJEY51JYK40JFT0MD",
"indexable": true,
"interactionPolicy": {
"canAnnounce": {"automaticApproval": ["https://www.w3.org/ns/activitystreams#Public"]},
"canLike": {"automaticApproval": ["https://www.w3.org/ns/activitystreams#Public"]},
"canQuote": {
"automaticApproval": ["https://bonfire.cafe/pub/actors/example"],
"manualApproval": ["https://www.w3.org/ns/activitystreams#Public"]
},
"canReply": {"automaticApproval": ["https://www.w3.org/ns/activitystreams#Public"]}
},
"published": "2025-09-18T17:14:13.148Z",
"sensitive": false,
"source": {
"content": "“To oppose something is to maintain it... You must go somewhere else; you must have another goal; then you walk a different road.” \n ― Ursula K. Le Guin",
"mediaType": "text/markdown"
},
"tag": [],
"to": ["https://www.w3.org/ns/activitystreams#Public"],
"type": "Note"
}Example: Outgoing Actor with Profile Fields
{
"@context": [
"https://www.w3.org/ns/activitystreams",
{
"@language": "en",
"alsoKnownAs": {"@id": "as:alsoKnownAs", "@type": "@id"},
"manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
"movedTo": "as:movedTo",
"sensitive": "as:sensitive"
}
],
"alsoKnownAs": ["https://sunbeam.city/users/example"],
"attachment": [
{
"name": "website",
"type": "PropertyValue",
"value": "<a rel=\"me\" href=\"https://bonfirenetworks.org\">https://bonfirenetworks.org</a>"
},
{
"name": "liberapay",
"type": "PropertyValue",
"value": "<a rel=\"me\" href=\"https://bonfire.cafe/pub/objects/01K1D97DXFJJ91BYP1WBR71V1A\">https://bonfire.cafe/pub/objects/01K1D97DXFJJ91BYP1WBR71V1A</a>"
},
{
"name": "link",
"type": "PropertyValue",
"value": "<a rel=\"me\" href=\"https://bonfire.cafe/pub/objects/01K1D967YP3G7FACGAPF61Z80Q\">https://bonfire.cafe/pub/objects/01K1D967YP3G7FACGAPF61Z80Q</a>"
}
],
"discoverable": true,
"endpoints": {
"oauthAuthorizationEndpoint": "https://bonfire.cafe/oauth/authorize",
"oauthRegistrationEndpoint": "https://bonfire.cafe/api/v1/apps",
"oauthTokenEndpoint": "https://bonfire.cafe/oauth/token",
"sharedInbox": "https://bonfire.cafe/pub/shared_inbox"
},
"followers": "https://bonfire.cafe/pub/actors/example/followers",
"following": "https://bonfire.cafe/pub/actors/example/following",
"icon": {
"type": "Image",
"url": "https://bonfire.cafe/files/redir/local/data/uploads/01JSC2WAV3P752DW3W0H3847DP/icons/01JSHVHQ5ZNHM95QEKXRW6BN46.png"
},
"id": "https://bonfire.cafe/pub/actors/example",
"image": {
"type": "Image",
"url": "https://bonfire.cafe/images/bonfires.png"
},
"inbox": "https://bonfire.cafe/pub/actors/example/inbox",
"indexable": true,
"name": "Example User",
"outbox": "https://bonfire.cafe/pub/actors/example/outbox",
"preferredUsername": "example",
"publicKey": {
"id": "https://bonfire.cafe/pub/actors/example#main-key",
"owner": "https://bonfire.cafe/pub/actors/example",
"publicKeyPem": "-----BEGIN PUBLIC KEY-----\n...snip...\n-----END PUBLIC KEY-----\n"
},
"summary": "<p>Tending to @bonfire@bonfire.cafe 🔥</p>",
"type": "Person",
"updated": "2025-09-25T10:09:52.379596",
"url": "https://bonfire.cafe/pub/actors/example"
}5. Federation Flows
Bonfire federates content and activities using the ActivityPub protocol, following the same general flows as other major Fediverse platforms.
Outgoing Federation
When a user or app extension triggers an action (such as creating, updating, or deleting content), Bonfire:
- Checks boundaries and federation settings to determine if the content should be federated (see Access Control).
- Serializes the object/activity into ActivityStreams JSON, including all required addressing fields (
to,bto, etc. taking circles, follow status, boundaries and blocks into account). - Queues the activity for delivery to remote recipients' inboxes, batching deliveries to the same instance when possible (sending them to the shared inbox if one declared is declared in recipients'
Actorobject, in which case the addressing fields should be used by recipient instances to determine who to deliver it to). - Signs all outgoing requests with HTTP signatures (HTTP Signature).
Common outgoing activities include:
Create(new posts, replies, etc.)Update(edits to posts or profiles)Delete(removal of posts or profiles)Follow,Accept,Reject,Undo,Like,Announce,Flag,Block,Move, and others as supported by extensions.
Incoming Federation
When Bonfire receives an activity from a remote instance:
- Validates the HTTP signature and checks the sender's domain and actor (see Access Control). If no valid signature is verified, it attempts to re-fetch the canonical object and processes that instead.
- Parses, validates and transforms the activity data against a standardized version of the ActivityStreams vocabulary and any supported extensions, and saves the activity/object JSON in the database.
- Passed the activity to active Bonfire extensions for processing: e.g., creates or updates a local objects, adds to feeds, triggers notifications, applies moderation or boundaries.
- Handles errors gracefully, logging and rejecting invalid or unauthorized activities.
Bonfire supports all standard ActivityPub flows, including:
- Receiving posts, replies, likes, boosts, follows, blocks, reports, and more.
- Handling incoming
Flagactivities as moderation reports. - Processing
Moveactivities for account migration.
Inbox forwarding
Bonfire forwards some activities it receives (ActivityPub §7.1.2), so that our users' followers on other servers see the conversations under their posts, and not only the posts.
What is forwarded:
- A reply (a
Createwhose object hasinReplyTo) with a post by one of our users anywhere up its reply chain, and anUpdateorDeleteof such a reply. - Only when it is public or unlisted, is not ours, and was accepted by us.
- Only when it is signed by its author with an LD signature or an FEP-8b32 proof, and that signature verifies. A receiver cannot tell a forward from a forgery by our word alone, so an unsigned reply is not forwarded, even though a receiver could refetch it.
- Not when a group we host relays it already (FEP-1b12, see Groups and topics): its followers get it through the group's
Announce. - An activity we have already seen is not forwarded again.
To whom:
The remote followers of our users involved in that thread, i.e. the authors of the post replied to and of the posts above it, and those who boosted or quoted the post replied to. Delivered to each inbox (shared inbox where there is one) once. Never to the sender's own inbox, nor an inbox of actors the author directly addressed (eg. in to/cc).
What you receive:
- The activity exactly as it reached us. Nothing is added or removed, so the author's signature or proof still verifies.
- A request signed with a HTTP signature by one of our users in the thread, not by the activity's
actor. So you have to rely on the author's own LD signature or object proof instead.
Profile Discovery and Following
To follow a remote user or resource, Bonfire:
- Performs a WebFinger lookup to resolve
@username@domainto an ActivityPub actor URI (see WebFinger Integration section for details). - Fetches and validates the actor's profile using a signed GET request.
- Sends a
Followactivity to the remote actor's inbox. - Handles
AcceptorRejectresponses to update the local following state.
Example Flows
- Status federation: A user creates a post, which is serialized as a
Createactivity with aNoteobject and delivered to the appropriate remote inboxes. - Profile federation: Profile updates, follows, and blocks are federated as
Update,Follow,Block, etc., activities.
For more details on the federation pipeline and extension points, see Bonfire ActivityPub Implementation Docs.
Groups and topics (FEP-1b12)
Bonfire groups federate as Group actors following FEP-1b12. Authors address posts to the group, and the group relays them to its followers with an Announce. Topics federate as groups inside a group. Bonfire federates only the groups whose visibility lets the fediverse see them.
Group actor
Besides the usual actor fields, a group declares:
attributedTo: the moderators collection (as Lemmy does). Left out when the group's visibility shows its moderators only to members.members: the members collection, andmemberCount. A group where anyone may join and outsiders may read lists its members to anyone. Any other group lists them only to its own members and moderators, and gives everyone else the count.postingRestrictedToMods:truewhen only moderators may post.manuallyApprovesFollowers:truewhen joins are reviewed.discoverable:falsefor an unlisted group.sensitive:truewhen the whole group (and possibly its contents) should be hidden behind a content warning.opennesswithopen,moderated(joins reviewed) orinvite_only(as Mobilizon does) andcapabilities.acceptsJoins: true(as Smithereen does). They describe joining, wheremanuallyApprovesFollowerstechnically describes following.preferredUsernameas the bare name, with no!or&prefix.narrower: the collection of the topics and subgroups of the group that the fediverse may see.broader: for a subgroup, the group it is in (FEP-9b2b).featured: the collection of posts pinned in the group.discoverableandindexable: whether the group may be listed and searched (FEP-5feb).generator: the instance's service actor, withimplementslisting ActivityPub, RFC 9421 and FEP-8b32 (FEP-844e).assertionMethod: an Ed25519Multikeythat others use to check the group's proofs (FEP-521a).
The context of the group defines the extra terms under the namespaces of the projects they come from: lemmy: (postingRestrictedToMods), mz: (openness), litepub: (capabilities, acceptsJoins) and SKOS (broader, narrower, inScheme).
An instance that requires HTTP signatures from other servers serves the group actor to anyone, but answers an unsigned fetch of its members, narrower, featured and moderators collections and of its outbox with 401. A server must sign its fetches to read them.
A topic declares inScheme: "https://w3id.org/fep/9b2b#Topic", broader set to its parent group, and its parent group's members collection, since that group's members are the ones who may take part. It has no openness or acceptsJoins, because people follow a topic and don't join it (membership depends on the parent group). It keeps type: "Group", so Lemmy and other FEP-1b12 software can follow it, where FEP-9b2b asks for Category.
The Bonfire Networks group on bonfire.cafe, without its @context, keys and endpoints:
{
"type": "Group",
"id": "https://bonfire.cafe/pub/group/01M6H0RX5SGPA9Q41FD34MZPRE",
"preferredUsername": "Bonfire_Networks",
"name": "Bonfire Networks",
"inbox": "https://bonfire.cafe/pub/group/01M6H0RX5SGPA9Q41FD34MZPRE/inbox",
"outbox": "https://bonfire.cafe/pub/group/01M6H0RX5SGPA9Q41FD34MZPRE/outbox",
"followers": "https://bonfire.cafe/pub/group/01M6H0RX5SGPA9Q41FD34MZPRE/followers",
"attributedTo": "https://bonfire.cafe/pub/collections/moderators/01M6H0RX5SGPA9Q41FD34MZPRE",
"members": "https://bonfire.cafe/pub/collections/members/01M6H0RX5SGPA9Q41FD34MZPRE",
"memberCount": 33,
"narrower": "https://bonfire.cafe/pub/collections/narrower/01M6H0RX5SGPA9Q41FD34MZPRE",
"featured": "https://bonfire.cafe/pub/collections/featured/01M6H0RX5SGPA9Q41FD34MZPRE",
"openness": "open",
"capabilities": { "acceptsJoins": true },
"manuallyApprovesFollowers": false,
"postingRestrictedToMods": false,
"discoverable": true,
"indexable": true,
"sensitive": false
}Membership
- A
Followfrom someone who neither follows nor belongs to a group that anyone may join makes them a follower and a member (since Lemmy, Mastodon and others sendFollowto join). From an existing member it only adds the follow. From an existing follower it changes nothing. A group that reviews joins files a join request instead, and aninvite_onlygroup, such as an announcement channel, only gains a follower. - A
Joinmakes someone a member (as Mobilizon does). Bonfire also treats them as a group follower, so a member who joined withJoinalso gets sent the group's posts. It sends noAccept(Follow)for this, since the member never sent aFollow. Leaveends membership, but Bonfire keeps them as a follower if they previously also sent aFollow, so they can keep following without being a member.Undo(Follow)removes what thatFollowcreated. If theFollowmade them a member (as a join from Lemmy or a follow from Mastodon does) theUndoends the membership too. If they were already a member, it only removes the follow (Bonfire links eachFollowto what it created, so it doesn't have to guess). For an older follow with no link, theUndoremoves the follow and keeps the membership.- A group that reviews joins manually answers with
Acceptonce a moderator approves. Aninvite_onlygroup answers nothing. - Joining a remote group from Bonfire sends both
FollowandJoin(but leaving and unfollowing are then two separate user actions).
Posting into a group
A post in a group carries an audience set to the group's ID, on both the activity and the object (Lemmy reads it on the object, and Friendica puts it only on the activity). audience is a single string, never an array (since Lemmy rejects an array). Bonfire also puts the group in cc (because Lemmy files posts by their addressing).
Bonfire sends a post to a group hosted elsewhere only when the post's visibility matches the group's, meaning a public post to a public group, or a non-public post to a group whose content isn't public, meaning one that declares openness: "invite_only" and doesn't declare manuallyApprovesFollowers: false (because PieFed re-announces anything addressed to a community as public, and Lemmy refuses mismatches). A post that doesn't match carries no audience and doesn't put the group in cc.
A titled post that starts a thread in a group goes out as a Page with its title as name. A reply or untitled post (and a titled post outside a group) go out as a Note. Incoming, a Page becomes a titled post, or a media item when it is a link or carries an image flagged as the cover.
When a post arrives from another server, Bonfire checks audience, to and cc on both the activity and the object, and if they list any groups hosted on this instance, it adds the post to each one it finds (if the author is allowed to post there). If none is named and the post is a reply, it goes in the group of the post it replies to.
Relaying
When a group relays a post, it sends two Announce activities (each with a distinct ID):
Announce{Create{Note}}(orAnnounce{Create{Page}}etc) with theCreateembedded and its object embedded as well,to: [Public],cc: [<group>/followers](this is the FEP-1b12 shape that Lemmy, PieFed and NodeBB send, and the only one Lemmy accepts).Announce{<object id>}withto: [Public, <group>/followers](Akkoma, the Misskey family and GoToSocial take this one, and Lemmy refuses it, while Mastodon handles either by refetching.)
A top-level group's boost has no cc, so it only goes to the group's followers, as Lemmy's does. A topic or subgroup, meaning an actor with broader, also addresses the post's author in cc. Without that, a member on another server who follows the group but not the topic would never get the post back filed under the topic.
A group also sends and Announce for Update, Delete, Like, Lock and Block activities about posts in it, and the Undo of the last three.
A group signs its own Announce with an object integrity proof (FEP-8b32) and passes on the author's activity exactly as it arrived, so the author's proof or signature still verifies for whoever receives it (see Object integrity proofs).
Incoming, Bonfire accepts both styles, as well as a bare object ID inside the Announce. A post whose audience names the announcing group is filed in Bonfire's copy of that group (if the author is allowed to post there). A relayed activity counts as the member's only when the member's proof or signature holds, and a proof whose domain names the relaying group is accepted.
Some software relays by adding the activity to a conversation or wall collection instead of announcing it. Bonfire reads an Add of an activity into a conversation (FEP-171b, sent by Hubzilla and Streams), and files the post in the group. It sends none. For FEP-400e (sent by Smithereen), Bonfire applies an Add or Remove only to collections it owns, and for a remote group it applies the collections it understands to its own data: moderators, topics, members and pins. It keeps no copy of other remote collections yet, such as a Smithereen wall.
Posts in a group carry an interactionPolicy (GoToSocial interaction policies) derived from the post's boundary, like any other post. The group actor doesn't declare a policy of its own yet. It will soon, following Permissions within a group in the SWICG groups draft: an interactionPolicy on the group actor that covers the group itself and what it announces, with a post's own policy taking precedence. A quote of a group's post uses the FEP-044f request and QuoteAuthorization flow described in Interaction Policies.
Topics
A group lists its sub-groups/topics in its narrower collection. When Bonfire discovers a remote group or receives an Update, and when someone follows or joins it, Bonfire reads that collection (at most once an hour by default) and creates the topics it finds under the group. A new topic also arrives as an Add to the narrower collection.
Moderation
- A moderator removing a post sends a
Deletewith the reason assummaryandaudienceset to the group (as Lemmy does). Bonfire reads thesummaryon incoming removals too. - Locking a thread sends
Lock, and unlocking sendsUndo(Lock). - Bonfire accepts a moderation activity from a moderator listed in the group's
attributedTo, or from an actor on the group's own server (FEP-fe34 origin rules). - A ban sends
Blockwithtargetset to the group, plusaudienceand asummary. A moderator's ban on a group hosted elsewhere stays pending until that group announces it back, unless the moderator chooses to apply it at once. - A group hosted by Bonfire sends an
AddorRemoveon its moderators collection when it promotes or demotes a moderator, and announces it. IncomingAddandRemoveon a remote group's moderators collection update Bonfire's copy. Bonfire doesn't send these to a group hosted elsewhere yet, so only that group's own server can change its moderators or name. - Archiving a group sends a
Deleteof the group's actor to its followers on other servers, and restoring it sends anUndoof thatDelete. Deleting a group for good sends aDeletetoo.
What federates, by visibility
| Group visibility | Actor served | Posts federate |
|---|---|---|
| Public (federated) | yes | public posts |
| Unlisted (federated) | yes with discoverable: false | public posts |
| Local / instance only | no, a fetch is refused | no |
| Members only | no | no |
Switching federation on for a group changes both its visibility and the default visibility of its new posts. Otherwise peers would see the group but none of its posts. Posts made before the switch keep the visibility they had, so they don't federate.
Known gaps
- A person's account can
Moveto another server, but a group can't yet, so members/followers of a group have to join/follow its new actor themselves for now. - Lemmy 1.0 (not yet released) reads
manuallyApprovesFollowers: trueas a private community and refuses public posts in it, so it may refuse public posts coming from Bonfire into a Lemmy group that reviews joins.
6. WebFinger Integration
Bonfire implements the WebFinger protocol for user and resource discovery, enabling remote servers to resolve @username@domain identifiers to canonical ActivityPub actor URIs. This is a key part of profile discovery and following.
- Endpoint:
https://your.bonfire.instance/.well-known/webfinger - Query parameter:
resource=acct:username@domain
A typical WebFinger response includes:
- The
subjectfield set to the queried account (e.g.,acct:alice@your.bonfire.instance) - A
selflink pointing to the actor's ActivityPub URI - Optionally, a link to the user's HTML profile
Example request:
GET /.well-known/webfinger?resource=acct:alice@your.bonfire.instance
Accept: application/jrd+jsonExample response:
{
"subject": "acct:alice@your.bonfire.instance",
"links": [
{
"rel": "self",
"type": "application/activity+json",
"href": "https://your.bonfire.instance/pub/actors/alice"
},
{
"rel": "http://webfinger.net/rel/profile-page",
"type": "text/html",
"href": "https://your.bonfire.instance/@alice"
}
]
}Interop requirements:
- The
rel=selflink must point to the canonical ActivityPub actor URI. - The
subjectmust match the queried account. - The endpoint must respond with the correct content type (
application/jrd+json).
Common pitfalls:
- Incorrect or missing
rel=selflink. - Mismatched
subjectfield. - Not supporting both
application/jrd+jsonandapplication/jsonAccept headers.
For more on how Bonfire uses WebFinger for profile discovery and following, see Federation Flows.
7. HTTP Signatures & Secure Fetch
Bonfire implements comprehensive HTTP signature support for authenticating ActivityPub server-to-server (S2S) requests, supporting both the widely-deployed draft-cavage HTTP Signatures and the newer RFC 9421 HTTP Message Signatures. This section documents the implementation in detail, including design choices, interop considerations, and upgrade guidance.
Supported signature formats
Bonfire supports two HTTP signature formats:
| Format | Spec | Headers | Status |
|---|---|---|---|
| Draft-cavage | draft-cavage-http-signatures | Signature, Digest | Default outbound + verified inbound |
| RFC 9421 | RFC 9421 | Signature + Signature-Input, Content-Digest | Adaptive outbound + verified inbound |
Both formats are verified on inbound requests. The format used for outbound requests is determined adaptively per remote host (see Format Discovery below).
Outbound signing
POST requests (Activity delivery)
All outgoing POST requests to remote inboxes are signed. The signed headers depend on the detected format for the target host:
Draft-cavage POST (default):
- Signed headers:
(request-target),host,content-length,content-type,digest,date - Algorithm:
rsa-sha256 Digestheader:SHA-256=<base64>
RFC 9421 POST (when remote is known to support it, see below):
- Signed components:
@method,@target-uri,content-digest Content-Digestheader:sha-256=:<base64>:- Both
SignatureandSignature-Inputheaders are included
Both formats also include date, digest/content-digest, and content-type headers on the actual request for maximum compatibility.
GET requests (object fetches)
Bonfire signs outgoing GET requests for fetching remote actors and objects (enabled by default via the sign_object_fetches config).
Draft-cavage GET: Signs (request-target), host, date
RFC 9421 GET: Signs @method, @target-uri
Inbound verification
When Bonfire receives a signed request, the signature plug automatically detects the format:
- If
signature-inputheader is present → RFC 9421 verification - If
signatureheader is present → draft-cavage verification - If neither is present → treated as unsigned (for POST requests this optionally means Bonfire will attempt re-fetching the activity/object from the origin, see below)
Verification uses the sender's public key, fetched from the keyId URI in the signature.
Date header staleness check
After cryptographic verification succeeds, Bonfire checks the Date header freshness. Signatures with a Date header older than ~1 hour are treated as invalid and sent through the verification cascade. This mitigates replay attacks. If the Date header is missing or unparseable, verification is not rejected on date alone (to avoid breaking implementations that don't send Date).
Derived components (eg. behind reverse proxies)
For RFC 9421, the @scheme and @authority derived components are taken from the instance's configured base_url, not from conn.scheme/conn.host. This avoids mismatches when Bonfire runs behind a reverse proxy (eg. where internal connections use HTTP but the public URL is HTTPS) or where multiple domains are aliased to one instance.
Verification cascade
When an HTTP signature is missing, invalid, or stale, the activity is not rejected outright (meaning the server will get a 200 response and not a 401). Instead, it enters a background processing queue which later runs verification cascade:
- HTTP signature re-fetch: Re-fetch the sender's public key and retry verification
- Linked Data Signature: Check for an embedded RsaSignature2017 LD signature in the activity body
- Source re-fetch: Fetch the activity/object from its canonical
idURL and verify containment - Reject oraccept unsigned: If
ACCEPT_UNSIGNED_ACTIVITIES=1is set by instance admins we still accept, otherwise the activity is rejected
This cascade ensures maximum interop — activities can be accepted via any valid authentication method, not just HTTP signatures.
Key management
Public key format
Bonfire publishes each actor's RSA public key in the standard publicKey property:
{
"publicKey": {
"id": "https://instance/pub/actors/alice#main-key",
"owner": "https://instance/pub/actors/alice",
"publicKeyPem": "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----\n"
}
}The keyId used in signatures matches the publicKey.id field, using the #main-key fragment convention (compatible with Mastodon, Akkoma, GoToSocial, and others).
Multiple keys (publicKey as list)
Bonfire supports publicKey as either a single object or a list of key objects (as permitted by the ActivityPub spec). When multiple keys are present, Bonfire matches by keyId to select the correct key, falling back to attempting verification with the first key if no match is found.
Signature format discovery
Bonfire uses adaptive signing, it discovers which signature format a remote host supports and then uses that format for outbound requests. Discovery methods (in priority order):
- Inbound signature caching: When a remote server sends us a signed request, we cache which format they used (cavage or RFC 9421)
- Accept-Signature header: When we receive an
Accept-Signatureresponse header from a remote server (on any response — WebFinger, object fetch, inbox POST), we cache RFC 9421 support for that host - FEP-844e generator detection: Check remote actors'
generator.implementsor the instance service actor'simplementsproperty for RFC 9421 support URIs (see below) - NodeInfo software version: Look up the remote's software name and version against a known-support map (e.g., Mastodon ≥ 4.5.0, Fedify ≥ 1.6.0, Hollo, Mitra)
- Default: Fall back to draft-cavage
Format preferences are cached per-host and persist for up to 2 weeks by default.
Accept-Signature advertisement
Bonfire advertises our support for RFC 9421 by including the Accept-Signature: sig1=() response header on:
- WebFinger responses
- All ActivityPub GET responses (actors, objects, etc)
- ActivityPub inbox POST responses
- 401/403 error responses (to hint that signing is expected)
This header is omitted when the client already sent an RFC 9421 signature (detected via the signature-input request header), since they clearly already know.
FEP-844e Support
Bonfire advertises its signature capabilities via FEP-844e:
- User actors include a
generatorproperty referencing the service actor:
{
"@context": [
"https://www.w3.org/ns/activitystreams",
{
"implements": {
"@id": "https://w3id.org/fep/844e#implements",
"@type": "@id",
"@container": "@set"
}
}
],
"id": "https://social.example/actors/1",
"type": "Person",
"generator": {
"type": "Application",
"id": "https://social.example/actors/service_actor",
"implements": [
{"href": "https://www.w3.org/TR/activitypub/"},
{"href": "https://datatracker.ietf.org/doc/html/rfc9421"},
{"href": "https://w3id.org/fep/8b32"}
]
}
}- Service actors include an
implementsproperty listing supported specs (including RFC 9421):
{
"@context": [
"https://www.w3.org/ns/activitystreams",
{
"implements": {
"@id": "https://w3id.org/fep/844e#implements",
"@type": "@id",
"@container": "@set"
}
}
],
"type": "Application",
"id": "https://social.example/actors/service_actor",
"implements": [
{"href": "https://www.w3.org/TR/activitypub/"},
{"href": "https://datatracker.ietf.org/doc/html/rfc9421"},
{"href": "https://w3id.org/fep/8b32"}
]
}When discovering remote instances, Bonfire checks these same properties to infer RFC 9421 support.
Secure fetch
By default, Bonfire requires signed GET requests for fetching actor and object JSON from ActivityPub endpoints, even for public resources. Unsigned requests to these endpoints may be rejected with HTTP 401. This is equivalent to Mastodon's "secure mode" and helps prevent abuse and scraping by blocked or defederated instances.
This behavior can be changed by admins in an instance's configuration, if they want unsigned GETs (to public resources) to be allowed.
Design choices impacting signature interop
No double-knock
Bonfire does not use the "double-knock" technique (send a request, get a 401, retry with a different format). Instead, we discover the format proactively via Accept-Signature headers, FEP-844e, and NodeInfo. This avoids:
- Extra round-trips on first contact
- Wasted bandwidth and latency
- Complexity in retry logic
The tradeoff is that we may use cavage for a host that supports RFC 9421 until we discover their preference, but this works since it seems all ActivityPub implementations that support RFC 9421 also accept cavage.
No dual signing
Bonfire sends a single signature format per request (not both cavage and RFC 9421 simultaneously). Since we discover the preferred format adaptively, dual signing would add overhead (and possibly reduce compatibility) without improving delivery success.
No hs2019 algorithm identifier
Bonfire always uses algorithm="rsa-sha256" for draft-cavage signatures, not the hs2019 placeholder from later cavage drafts, because:
rsa-sha256is universally accepted across fediverse implementationshs2019was a transitional identifier that the ecosystem largely skipped- The real upgrade path seems to be cavage → RFC 9421, not
rsa-sha256→hs2019 - Our verification does accept both algorithm identifiers on inbound (the algorithm field is not used for verification, we always verify with the key's algorithm)
Query parameters
Bonfire signs requests including query parameters in the signature string, but will attempt validation both with and without query parameters for compatibility with other implementations (such as Mastodon and GoToSocial).
keyId format
Bonfire uses the fragment format for keyId (e.g., https://your.bonfire.instance/pub/actors/alice#main-key), matching Mastodon and most other platforms.
Public key endpoint
The keyId in the signature header should match the id of the publicKey object in the actor's JSON.
Object integrity proofs (FEP-8b32)
Bonfire signs the activities it sends, and checks the proofs on the ones it receives, following FEP-8b32 with the eddsa-jcs-2022 cryptosuite (JSON canonicalised per RFC 8785, signed with Ed25519). Bonfire signs only with eddsa-jcs-2022. It also checks proofs made with mldsa44-jcs-2024 (ML-DSA-44) when the Erlang/OpenSSL build of the instance supports it, and treats such a proof as unverifiable otherwise.
Outgoing:
- A
CreateorUpdategets a proof on its object and another on the activity around it. The object's proof lasts when the object is fetched by id or embedded in a boost. The activity's is the one Mastodon reads, on a top-level activity from someone other than the HTTP signer. Any other activity gets a proof on the activity. - The Ed25519 key is derived from the actor's RSA key (HKDF-SHA256), so nothing new is stored. It is published on the actor as an
assertionMethodentry of typeMultikey(FEP-521a), with a#ed25519-keyfragment on the actor's id. - Documents that are sent identically for several inboxes share one proof, but can otherwise have different proofs.
- A group relaying a remote author's activities signs its own
Announceonly. The proof on the activity and/or object inside is the author's, passed on as provided by the remote if any. - If signing fails, the activity goes out unsigned, with a warning in the log.
- Admins can set
sign_object_integrity_proofs: falsein the:activity_pubconfig to turn it off.object_integrity_cryptosuitepicks the suite, andobject_integrity_domain_check(:relay,:strictor:off) sets how a proof'sdomainis checked on incoming documents. - Bonfire lists
https://w3id.org/fep/8b32in theimplementsof its service actor (FEP-844e).
Incoming:
- A proof that verifies should match who made the document: the actor that owns the key which signed it. We read a proof when the HTTP signature of the delivery cannot be relied on, for example a copy forwarded by a group or another server.
- A proof that does not verify, or that was made by someone other than the document's actor, counts as evidence against the document.
- A proof that cannot be checked (unknown suite, key that cannot be fetched) is ignored, and other ways of authenticating are tried instead.
- Bonfire forwards replies in its users' threads only when they carry their author's signature or proof (see Inbox forwarding).
- How a document was authenticated is stored with it, in the
authenticatedfield:integrity_proof,http_signature,ld_signature,embedded(inside a document its actor signed, but naming no owner itself),fetched(we fetched it from its origin) orunverified. A copy that someone vouched for replaces an older stored copy of the same object unless it is provably older.
References
For more details, see RFC 9421, draft-cavage HTTP Signatures, and SWICG ActivityPub HTTP Signature spec.
8. Rate Limiting
Bonfire applies rate limiting to all federation endpoints, including both incoming and outgoing ActivityPub and WebFinger requests.
Incoming Federation Endpoints
Federation endpoints are rate limited per IP address. If the rate limit is exceeded, Bonfire responds with HTTP status 429 Too Many Requests and a Retry-After header indicating when to retry. The default rate limits can be configured by the instance admin. Rate limited endpoints include:
- Inbox / Shared Inbox: Incoming POST requests to inbox endpoints
- GET requests for Actor and Object endpoints (e.g.
/pub/actors/{username}and/pub/objects/{id}) - WebFinger: Incoming GET requests to the WebFinger endpoint
Outgoing Federation Requests
- Outgoing HTTP requests (to remote servers) also support rate limiting and include retry logic. If a remote server responds with
429 Too Many Requestsor503 Service Unavailable, Bonfire will respect theRetry-Afterheader and automatically retry after the indicated delay.
HTTP Status Codes and Headers
429 Too Many Requests: Returned when the rate limit is exceeded.503 Service Unavailable: May be returned by remote servers; Bonfire will retry as appropriate.Retry-After: Indicates how many seconds to wait before retrying.
Interop Notes
- Remote servers should respect
Retry-Afterheaders and avoid retrying requests too quickly. - If you receive a
429from Bonfire, wait the indicated time before retrying. - Rate limits are applied per IP and per endpoint.
For more details, see the Bonfire ActivityPub Implementation Docs.
9. Moderation, Flagging, and Blocking
Bonfire provides robust moderation tools and supports federated moderation activities to help maintain healthy communities and enforce local policies.
Blocking
Bonfire supports several types of blocks, each with distinct effects:
Ghost block: The blocked user is prevented from seeing or interacting with you or your content on your instance:
- Private posts and activities are never delivered to ghosted users.
- Public posts may still be visible to ghosted users on remote instance or via public instance web views.
- Ghosted users cannot follow, mention, or message you, and you cannot mention or message them.
- Undoing a ghost block is possible, but missed activities are not retroactively delivered.
- Instance admins can enforce ghost blocks globally, preventing a user from seeing or interacting with any local users.
Silence: You stop seeing content from the silenced user:
- Their posts and activities are filtered from your feeds and notifications.
- You can still view their profile or posts via direct links.
- You won't see mentions or messages from them, and you cannot follow them.
- Undoing a silence is possible, but missed activities are not retroactively restored.
- Instance admins can silence a user for all local users, hiding their content from all local feeds.
Full block: All of the above.
Instance-level blocks (defederation): Admins can block entire domains, preventing all federation with those instances.
All block types are enforced at the boundaries level and affect both incoming and outgoing federation as appropriate.
Flagging (Reporting)
- Flag activities:
- Bonfire supports the ActivityStreams
Flagactivity for reporting users, posts, or other objects for moderation. - Incoming
Flagactivities from remote instances are processed as moderation reports and routed to moderators. - Outgoing
Flagactivities are federated to remote instances' shared inbox when a user reports content originating elsewhere.
- Bonfire supports the ActivityStreams
- Moderation workflow:
- Reports can be reviewed, actioned, or dismissed by moderators. Actions may include warning, silencing, blocking, labeling, editing, or deleting content or accounts.
Moderation Activities
Bonfire sends a Block in two cases:
- A Bonfire block has two parts: ghosting stops the blocked person seeing the user, and silencing stops the user seeing them. When a user ghosts a remote person and chooses to "tell other instances too", the ghost goes out as a
Block. A silence stays local, like a mute on Mastodon. - A group moderator banning someone sends a
Blockwith the group astarget(see Moderation under groups). It applies incoming blocks as appropriate. Moderation is mostly handled through Bonfire's boundaries functionality, and theFlagactivity for reporting, which are processed as moderation reports and placed in instance moderators' queue.
Account Migration
Bonfire supports account migration using the Move activity, and the alsoKnownAs and movedTo properties on actors. Migration is only considered valid if both accounts reference each other via alsoKnownAs. On receiving a valid Move, Bonfire will redirect followers to the new account and update local state accordingly.
Interop Notes
- Remote instances can expect Bonfire to process incoming
Flagactivities according to local moderation policy. - Bonfire federates moderation actions as appropriate, including
Flag,Update, andDeleteactivities. - Bonfire follows the ActivityPub and ActivityStreams conventions for moderation activities, ensuring compatibility with major implementations.
For more details, see Bonfire ActivityPub Implementation Docs and the ActivityStreams Spec for
Flagactivities.
10. Circles, Boundaries & Interaction Policies
Bonfire provides advanced privacy and interaction controls, supporting both standard ActivityPub audience fields and the interactionPolicy vocabulary of GoToSocial, plus FEP-044f for quote posts.
Circles and Boundaries
- Circles in Bonfire are flexible audience groups (similar to "circles" or "lists" in other platforms), used to define custom sharing boundaries for posts and activities.
- Boundaries are Bonfire's mechanism for enforcing privacy, collaboration permission, and blocks. They determine who can see, interact with, or receive a given activity.
- When federating, Bonfire always maps circles and boundaries to ActivityPub addressing fields (in
btoorbcc) as appropriate. Circles are not federated as named groups; only the resolved list of recipients is included in the addressing fields. - Remote instances will only see the addressing fields, not the internal circle names or membership. Circle membership is not exposed to other users or to remote servers by default.
Interaction Policies
- Bonfire supports the
interactionPolicyvocabulary defined by GoToSocial (not an FEP) for fine-grained interaction control. FEP-044f covers only quote posts. - Posts and objects can include an
interactionPolicyproperty, specifying who can like, reply, announce, or quote. - Incoming policies become per-verb grants and denials on the object's boundary. Outgoing policies are read from the post's boundary. Posts in groups work the same way (but the group actor declares no policy of its own just yet).
- Sub-policies include
canLike,canReply,canAnnounce, andcanQuote, each withautomaticApprovaland optionallymanualApprovalfields. - Bonfire includes
interactionPolicy15 on outgoing posts when appropriate. This property is intended as an FYI for remote instances, so they can disable or hide actions in their UI (and avoid users enacting interactions that will not be properly federated to their intended recipients but could still seen by users of their own instance). - Bonfire will always enforce these policies, e.g. if a remote instance does not support or respect
interactionPolicy, Bonfire will still reject any incoming interaction (reply, like, announce, etc) that violates the policy.
Approval Flows
- Only quoting has an approval flow, following FEP-044f. A quote request is a
QuoteRequestactivity. The author answers withAccept(which carries aQuoteAuthorizationthe quoting post links to) orReject, for local and remote users. - Likes, replies and boosts have no request and approval flow. Bonfire checks them against the post's policy when they arrive, and rejects the ones the policy doesn't allow. It doesn't yet send or read approval objects for them (such as GoToSocial's
approvedBy).
Interop Notes
- Remote servers that do not support
interactionPolicywill fall back to default ActivityPub behavior (anyone who can see a post can interact with it), but Bonfire will still enforce its policies and reject unauthorized interactions. - Bonfire will respect incoming
interactionPolicyproperties from remote posts, enforcing restrictions locally. - Audience enforcement is always based on both addressing fields and interaction policies.
For more details, see the Bonfire documentation and the GoToSocial interaction policies.
11. Testing & Debugging
Testing and debugging federation with Bonfire requires understanding ActivityPub S2S flows, HTTP signatures, and proper request formatting.
Required Headers
Accept: Useapplication/activity+jsonorapplication/ld+json; profile="https://www.w3.org/ns/activitystreams"for ActivityPub endpoints.Signature: All S2S requests should be signed (see HTTP Signatures), unless the instance accepts non-signed requests for public objects.Date: Required for signature validation.Digest: Required for signed POST requests.
Note: All example curl commands below assume you will include the required headers if needed, including a valid Signature header.
Example curl commands
Fetch a remote actor (signed GET):
curl -H "Accept: application/activity+json" \
-H "Date: $(date -u +'%a, %d %b %Y %H:%M:%S GMT')" \
https://a.bonfire.instance/pub/actors/alice
Fetch a remote object (signed GET):
curl -H "Accept: application/activity+json" \
-H "Date: $(date -u +'%a, %d %b %Y %H:%M:%S GMT')" \
https://a.bonfire.instance/pub/objects/01H8ZK2YXP9QCT5BE1JWQSAM3B6
Send an activity to an inbox (signed POST):
curl -X POST \
-H "Accept: application/activity+json" \
-H "Content-Type: application/activity+json" \
-H "Date: $(date -u +'%a, %d %b %Y %H:%M:%S GMT')" \
-H "Digest: SHA-256=..." \
--data-binary @activity.json \
https://a.bonfire.instance/pub/actors/alice/inbox
WebFinger lookup (no signature required):
curl -H "Accept: application/jrd+json" \
"https://a.bonfire.instance/.well-known/webfinger?resource=acct:alice@your.bonfire.instance"
Debugging Tips
- Check for required headers (eg
Signature) and correct content types. - Use verbose curl output (
-v) to inspect HTTP status codes and headers. - Check logs for signature validation errors, rate limiting (
429), or access control (403). - Inspect the job queues for stuck or failed federation jobs. Bonfire users can view their federation queue at
/settings/user/federation_status.
Troubleshooting Common Issues
- 401 Unauthorized: Missing or invalid HTTP signature.
- 403 Forbidden: Blocked by boundaries, blocks, or instance defederation.
- 429 Too Many Requests: Rate limit exceeded; check
Retry-Afterheader. - 406 Not Acceptable: Incorrect
AcceptorContent-Typeheader. - 422 Unprocessable Entity: Malformed activity or object.
- 503 Service Unavailable: Remote server is down or overloaded.
For more details, see Bonfire ActivityPub Implementation Docs and the ActivityPub Spec.
15. Glossary
ActivityPub
A decentralized social networking protocol based on the ActivityStreams data format. 1
ActivityStreams
A model/data format for representing potential and completed activities using JSON. 11
Actor
An ActivityStreams object capable of performing activities (e.g., Person, Group, Service). 12
Dereference
To fetch the ActivityStreams representation of a resource (e.g., actor or object) by making an HTTP request to its canonical URI.
WebFinger
A protocol for resolving user identifiers (e.g., @user@domain) to canonical profile URIs. 2
FEP
Fediverse Enhancement Proposal, a community process for proposing and documenting protocol extensions. 4
HTTP Signature
A cryptographic signature for HTTP requests, used to authenticate and authorize ActivityPub S2S messages. 10
Inbox
Endpoint on an actor for receiving activities.
Outbox
Endpoint on an actor for publishing activities.
Public URI
The special URI https://www.w3.org/ns/activitystreams#Public used to indicate public addressing.
MRF
Message Rewrite Facility, a policy system for filtering or modifying federated activities.
Boundary
Bonfire’s mechanism for enforcing privacy, blocks, and audience restrictions.
Peered
A mapping between a local object and its canonical URI.
Canonical URI
An activty, object or actor's id: an authoritative, globally unique URI.
Flag
The ActivityStreams activity type for reporting moderation issues.
Interaction Policy
A set of rules (e.g., canLike, canReply) governing who can interact with a post. 15
Instance
A single deployment of a federated server (e.g., a Bonfire, Mastodon, or GtS server).
Shared Inbox
An endpoint for batching delivery of activities to multiple actors on the same instance. 14
Tombstone
An object indicating that a resource (e.g., a post or actor) has been deleted.
Hashtag
An ActivityStreams extension representing a topic tag.
Emoji
An ActivityStreams extension representing a custom emoji.
PropertyValue
A schema.org extension for profile metadata fields.
Create
The ActivityStreams activity type for creating an object. 12
Update
The ActivityStreams activity type for updating an object. 12
Delete
The ActivityStreams activity type for deleting an object. 12
Accept
The ActivityStreams activity type for accepting an activity. 12
Reject
The ActivityStreams activity type for rejecting an activity. 12
Note
An ActivityStreams object type representing a short-form post. 12
Article
An ActivityStreams object type representing a long-form post. 12