Bonfire Federation Interoperability Guide

Copy Markdown View Source

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.

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:

Partial support (incoming only, or only some of the proposal):

Partial support or conformity to-be-confirmed (help needed!):

Work-in-progress, planned, or exploring (suggestions/feedback welcome!):

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:

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 ExampleVisibility LevelNotes
to: PublicPublicVisible to everyone, delivered to all followers and public timelines.
to: followersFollowers-onlyOnly followers can see/interact.
to: [actor1, actor2]Direct (DM)Only addressed actors can see/interact.
bto/bccBlind recipientsRecipients 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 preview property if present, otherwise using fallbacks to generate a preview using some common object properties such as name, summary, or image.

Extensions and Custom Types or Properties

Bonfire supports AP extensions such as:

  • Hashtag: For topic tags, using the Hashtag object type.
  • Emoji: For custom emoji, using the Emoji object 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' Actor object, 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 Flag activities as moderation reports.
  • Processing Move activities 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 Create whose object has inReplyTo) with a post by one of our users anywhere up its reply chain, and an Update or Delete of 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@domain to an ActivityPub actor URI (see WebFinger Integration section for details).
  • Fetches and validates the actor's profile using a signed GET request.
  • Sends a Follow activity to the remote actor's inbox.
  • Handles Accept or Reject responses to update the local following state.

Example Flows

  • Status federation: A user creates a post, which is serialized as a Create activity with a Note object 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, and memberCount. 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: true when only moderators may post.
  • manuallyApprovesFollowers: true when joins are reviewed.
  • discoverable: false for an unlisted group.
  • sensitive: true when the whole group (and possibly its contents) should be hidden behind a content warning.
  • openness with open, moderated (joins reviewed) or invite_only (as Mobilizon does) and capabilities.acceptsJoins: true (as Smithereen does). They describe joining, where manuallyApprovesFollowers technically describes following.
  • preferredUsername as 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.
  • discoverable and indexable: whether the group may be listed and searched (FEP-5feb).
  • generator: the instance's service actor, with implements listing ActivityPub, RFC 9421 and FEP-8b32 (FEP-844e).
  • assertionMethod: an Ed25519 Multikey that 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 Follow from 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 send Follow to 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 an invite_only group, such as an announcement channel, only gains a follower.
  • A Join makes someone a member (as Mobilizon does). Bonfire also treats them as a group follower, so a member who joined with Join also gets sent the group's posts. It sends no Accept(Follow) for this, since the member never sent a Follow.
  • Leave ends membership, but Bonfire keeps them as a follower if they previously also sent a Follow, so they can keep following without being a member.
  • Undo(Follow) removes what that Follow created. If the Follow made them a member (as a join from Lemmy or a follow from Mastodon does) the Undo ends the membership too. If they were already a member, it only removes the follow (Bonfire links each Follow to what it created, so it doesn't have to guess). For an older follow with no link, the Undo removes the follow and keeps the membership.
  • A group that reviews joins manually answers with Accept once a moderator approves. An invite_only group answers nothing.
  • Joining a remote group from Bonfire sends both Follow and Join (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}} (or Announce{Create{Page}} etc) with the Create embedded 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>} with to: [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 Delete with the reason as summary and audience set to the group (as Lemmy does). Bonfire reads the summary on incoming removals too.
  • Locking a thread sends Lock, and unlocking sends Undo(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 Block with target set to the group, plus audience and a summary. 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 Add or Remove on its moderators collection when it promotes or demotes a moderator, and announces it. Incoming Add and Remove on 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 Delete of the group's actor to its followers on other servers, and restoring it sends an Undo of that Delete. Deleting a group for good sends a Delete too.

What federates, by visibility

Group visibilityActor servedPosts federate
Public (federated)yespublic posts
Unlisted (federated)yes with discoverable: falsepublic posts
Local / instance onlyno, a fetch is refusedno
Members onlynono

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 Move to 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: true as 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 subject field set to the queried account (e.g., acct:alice@your.bonfire.instance)
  • A self link 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+json

Example 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=self link must point to the canonical ActivityPub actor URI.
  • The subject must match the queried account.
  • The endpoint must respond with the correct content type (application/jrd+json).

Common pitfalls:

  • Incorrect or missing rel=self link.
  • Mismatched subject field.
  • Not supporting both application/jrd+json and application/json Accept 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:

FormatSpecHeadersStatus
Draft-cavagedraft-cavage-http-signaturesSignature, DigestDefault outbound + verified inbound
RFC 9421RFC 9421Signature + Signature-Input, Content-DigestAdaptive 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
  • Digest header: SHA-256=<base64>

RFC 9421 POST (when remote is known to support it, see below):

  • Signed components: @method, @target-uri, content-digest
  • Content-Digest header: sha-256=:<base64>:
  • Both Signature and Signature-Input headers 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:

  1. If signature-input header is present → RFC 9421 verification
  2. If signature header is present → draft-cavage verification
  3. 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:

  1. HTTP signature re-fetch: Re-fetch the sender's public key and retry verification
  2. Linked Data Signature: Check for an embedded RsaSignature2017 LD signature in the activity body
  3. Source re-fetch: Fetch the activity/object from its canonical id URL and verify containment
  4. Reject oraccept unsigned: If ACCEPT_UNSIGNED_ACTIVITIES=1 is 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):

  1. Inbound signature caching: When a remote server sends us a signed request, we cache which format they used (cavage or RFC 9421)
  2. Accept-Signature header: When we receive an Accept-Signature response header from a remote server (on any response — WebFinger, object fetch, inbox POST), we cache RFC 9421 support for that host
  3. FEP-844e generator detection: Check remote actors' generator.implements or the instance service actor's implements property for RFC 9421 support URIs (see below)
  4. 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)
  5. 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 generator property 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 implements property 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-sha256 is universally accepted across fediverse implementations
  • hs2019 was 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 Create or Update gets 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 assertionMethod entry of type Multikey (FEP-521a), with a #ed25519-key fragment 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 Announce only. 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: false in the :activity_pub config to turn it off. object_integrity_cryptosuite picks the suite, and object_integrity_domain_check (:relay, :strict or :off) sets how a proof's domain is checked on incoming documents.
  • Bonfire lists https://w3id.org/fep/8b32 in the implements of 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 authenticated field: 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) or unverified. 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 Requests or 503 Service Unavailable, Bonfire will respect the Retry-After header 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-After headers and avoid retrying requests too quickly.
  • If you receive a 429 from 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 Flag activity for reporting users, posts, or other objects for moderation.
    • Incoming Flag activities from remote instances are processed as moderation reports and routed to moderators.
    • Outgoing Flag activities are federated to remote instances' shared inbox when a user reports content originating elsewhere.
  • 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 Block with the group as target (see Moderation under groups). It applies incoming blocks as appropriate. Moderation is mostly handled through Bonfire's boundaries functionality, and the Flag activity 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 Flag activities according to local moderation policy.
  • Bonfire federates moderation actions as appropriate, including Flag, Update, and Delete activities.
  • 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 Flag activities.

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 bto or bcc) 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 interactionPolicy vocabulary defined by GoToSocial (not an FEP) for fine-grained interaction control. FEP-044f covers only quote posts.
  • Posts and objects can include an interactionPolicy property, 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, and canQuote, each with automaticApproval and optionally manualApproval fields.
  • Bonfire includes interactionPolicy 15 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 QuoteRequest activity. The author answers with Accept (which carries a QuoteAuthorization the quoting post links to) or Reject, 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 interactionPolicy will 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 interactionPolicy properties 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: Use application/activity+json or application/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-After header.
  • 406 Not Acceptable: Incorrect Accept or Content-Type header.
  • 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