Implementing the Organization (Service) + Group + Person structure in WordPress ActivityPub #2322

Jiwoon-Kim · 2025-10-15T17:58:54Z

Jiwoon-Kim
Oct 15, 2025

“Do not summarize or paraphrase. Translate literally, preserving line breaks, punctuation, and markdown structure exactly as in the source.”

You are a professional multilingual translator.
Translate the following text into [English] without omitting, merging, or reordering any part of the original structure.

Keep:

Line breaks, paragraph spacing, and list formatting exactly as in the original.
Sentence and punctuation structure as close as possible to the source.
Bold, italic, headings (#, ##), bullet points, and symbols as-is.
URLs, code snippets, and inline quotes in their original positions.

Do not summarize or interpret the meaning — translate literally but naturally.
Preserve the full structure of the source text.

[INPUT TEXT BELOW]

Implementing the Organization (Service) + Group + Person structure in WordPress ActivityPub
Study on use cases by actor type

https://ko.wordpress.org/plugins/user-activity-log/

Person actor implementation examples

In WordPress, how to create and switch between multiple profiles under one account like Facebook

In the basic structure of WordPress, it is designed as “one account = one user profile”, so it does not natively support having multiple profiles (or pages/characters/brands) under one account like Facebook.
However, it can be implemented through several approaches and plugin combinations.

① When you want to switch between multiple profiles (alias accounts, brands, characters)

Method: Create and switch between multiple “sub-profiles” under one main account

This is not possible with the default WordPress functionality, but it can be done using user role extension plugins + custom profile features.

Use user_meta to store multiple “profile slots.”
Example:

update_user_meta( get_current_user_id(), 'sub_profiles', [
  ['name' => 'kimjiwoon96', 'avatar' => '...', 'bio' => 'traveler'],
  ['name' => 'thaumiel999', 'avatar' => '...', 'bio' => 'AI & Design']
]);

Implement a “profile switch” button in the frontend UI → select the current profile using a session variable such as set_current_profile()
When writing posts, overwrite post_author_meta or the ActivityPub actor URL based on the “current profile.”

➡ As a result, you can stay logged in with one account and use the “profile switch” menu to act under multiple personas.
(Very similar to Facebook’s “page switch”)

② When you want to operate a “separate feed for each profile” within the blog

Method: Custom Post Type + Author Meta + ActivityPub integration

The WordPress ActivityPub plugin creates Fediverse actors based on “user accounts,”
but by slightly extending ActivityPub\Actor_Factory, you can also create profile-level actors.
That is, you can create and switch between multiple actors (sub-identities) under one account.

Example flow

Main account: @[email protected]
Sub accounts (profiles):
- @[email protected] (pet chicken daily feed)
- @[email protected] (design·AI feed)

➡ Separate actor endpoints in the plugin (/actor/{profile} form)
➡ Each profile has its own public key, outbox/inbox URL
➡ The admin just logs into one WordPress account and switches profiles.

This requires customization of ActivityPub, but is fully implementable.

Then what about shared profiles where multiple moderators manage one actor, like a blog profile?
“Add group actor + moderator connection function by customizing the ActivityPub plugin”

Implementing a “Group actor that has multiple moderators/admins in a shared profile form in WordPress corresponds to an advanced design that intersects the existing ActivityPub spec and WordPress’s user structure.

🧠 First, conceptual clarification

Concept	Description
Person(Individual) Actor	Individual user (1 WordPress user account = 1 ActivityPub Actor)
Group Actor	A ‘shared profile’ managed by multiple users (ex. joint blog, brand account)
Shared Inbox / Outbox	Allows multiple admins to post or approve on the group actor feed
Moderators/Admins	Co-admins managing the group actor’s content and followers

In ActivityPub, the Group type actor exists and is structurally defined as follows:

{
  "@context": "https://www.w3.org/ns/activitystreams",
  "type": "Group",
  "id": "https://example.com/@busantravel",
  "name": "Travel in Busan",
  "attributedTo": [
    "https://example.com/@jiwoon",
    "https://example.com/@mogu"
  ],
  "manuallyApprovesFollowers": true,
  "followers": "https://example.com/@busantravel/followers",
  "inbox": "https://example.com/@busantravel/inbox",
  "outbox": "https://example.com/@busantravel/outbox"
}

That is,
“The Group Actor itself is an independent profile, but it is jointly managed by multiple users (Actors).”

How to implement in WordPress in 3 steps

Define Group Actor
Extend the Actor Registry of the ActivityPub plugin (includes/class-activitypub-actor-factory.php)
to register a new actor with type: Group.

add_filter('activitypub_get_actor_types', function($types) {
    $types['group'] = 'Group';
    return $types;
});

This way, within WordPress,

Individual Actor (type: Person)
Group Actor (type: Group)
Both types coexist.

Connecting group profiles with actual users (setting shared ownership)

Link WordPress user IDs in the group actor’s metadata under moderators or attributedTo fields:

update_post_meta($group_id, 'moderators', [1, 3, 7]);

"attributedTo": [
  "https://travel-in-busan.com/@jiwoon",
  "https://travel-in-busan.com/@thaumiel999"
]

➡ This makes the group profile
a “shared account where multiple users can post together.”

Inbox/Outbox behavior of shared profile

This part is key.

By default, the ActivityPub plugin manages inbox/outbox by /author/{user},
but the Group Actor must have separate paths.

/group/busantravel/inbox
/group/busantravel/outbox

In this outbox, merge activities from multiple admins.
That is, posts from Jiwoon and thaumiel999 are both propagated to /group/busantravel/outbox.
(Override the get_actor() part of ActivityPub\Transformer\Post class to achieve this.)

🔐 Permission (Moderation) structure

Role	Function
Owner (Super Admin)	Group creator, can add/remove admins
Moderator	Can post/delete/manage followers as group actor
Member	Can post as group name only
Follower	External ActivityPub user

➡ In WordPress, use the capabilities system (edit_posts, manage_options, etc.)
to map these roles to actual admin permissions.
Create a custom capability such as group_moderator and restrict access with user_can().

🌐 Example result

For example,

Group profile: @[email protected]
Admins:
- @[email protected]
- @[email protected]

In this case:

Both accounts can post to /group/travel-in-busan
On Fediverse, appears only under the name @travel-in-busan
Followers, reactions, and replies go into the group inbox
Each admin can approve/delete in WordPress backend

Thus, it becomes perfectly “a Facebook page operated by multiple admins.”

Advanced: clues already implemented at the ActivityPub plugin level

The current WordPress ActivityPub plugin already includes a Blog type actor.
(class-activitypub-blog.php)
This is effectively “a shared profile representing the entire site.”
By extending this to type Group + adding moderator linkage,
it can be directly transformed into a “shared profile.”

class Activitypub_Group extends Activitypub_Blog {
    public $type = 'Group';
    public $moderators = [];
}

This way, @[email protected]
acts as the official group actor of the entire WordPress blog,
allowing multiple accounts to publish under that name.

Summary

Item	Description
Structure	Group Actor (ActivityPub type=Group)
Admin connection	Connect multiple users via `moderators` or `attributedTo` field
Shared outbox/inbox	Create separately as `/group/{slug}/outbox`
Permission control	WordPress capability + usermeta

👉 An integrated structure of Blog Actor + Group Actor is ideal.

That is,

@travel-in-busan → Site’s representative shared profile (Group)
@jiwoon, @mogu → Individual Actors (Person)
When writing, choose between shared profile/personal profile with “author switch” menu
On Fediverse, published under the group name

Mapping bbPress multi-forums as individual ActivityPub group actors

🧠 Basic conceptual overview

Element	Role	Corresponding in ActivityPub
bbPress Forum (Forum CPT)	One topic group	Group Actor
Forum Moderator	Moderator of the group actor	`attributedTo` / `moderators`
Forum Topic	Post created by group	Create Activity (outbox item)
Forum Reply	Comment/thread message	Note / Reply Activity
Whole Site	Fediverse hub	WordPress instance = ActivityPub server

That is:
Forum = Group Actor
Topic = Activity (Create)
Reply = Activity (Reply)

Once this structure is established, each forum operates as an independent group actor connected with external instances.

① Register bbPress forums as ActivityPub Group Actors

By default, bbPress forums have post_type = forum.
So add a hook to automatically register these forums to the ActivityPub plugin’s Actor Factory.

add_filter('activitypub_get_actors', function($actors) {
    $forums = get_posts([
        'post_type' => 'forum',
        'post_status' => 'publish',
        'numberposts' => -1
    ]);
    foreach ($forums as $forum) {
        $actors[] = [
            'id' => get_permalink($forum->ID),
            'type' => 'Group',
            'preferredUsername' => sanitize_title($forum->post_title),
            'name' => $forum->post_title,
            'inbox' => home_url("/forum/{$forum->post_name}/inbox"),
            'outbox' => home_url("/forum/{$forum->post_name}/outbox"),
            'attributedTo' => get_post_meta($forum->ID, 'moderators', true) ?: []
        ];
    }
    return $actors;
});

This creates forum-level actor endpoints in WordPress such as:

/forum/travel-tips/inbox
/forum/travel-tips/outbox

That is, on Fediverse,

@[email protected]

functions as a single group actor (forum).

② Moderator/Admin connection (group actor managers)

Each forum in bbPress supports setting Forum Moderator,
so link this to the ActivityPub metadata’s attributedTo or moderators field.

$moderators = bbp_get_forum_moderators($forum_id);
update_post_meta($forum_id, 'moderators', array_map(function($user_id) {
    return get_author_posts_url($user_id);
}, $moderators));

➡ Thus, on Fediverse

"attributedTo": [
  "https://travel-in-busan.com/@jiwoon",
  "https://travel-in-busan.com/@thaumiel999"
]

is displayed, showing that both people jointly manage the forum group.

③ Convert Topics and Replies to Activities

When a new topic (post_type = topic) is created → send a Create Activity
When a comment (post_type = reply) is added → send an Announce or Reply Activity

Example:

add_action('publish_topic', function($topic_id) {
    $forum_id = bbp_get_topic_forum_id($topic_id);
    $actor_url = get_permalink($forum_id);
    activitypub_send_create_activity($topic_id, $actor_url);
});

add_action('publish_reply', function($reply_id) {
    $topic_id = bbp_get_reply_topic_id($reply_id);
    activitypub_send_reply_activity($reply_id, $topic_id);
});

Thus, even on external instances (e.g., Mastodon, Misskey, Friendica, etc.),
new topics from that forum appear as “group posts.”

④ Federated forum subscription (Follow/Join)

Because it is a Group Actor, you can use the standard ActivityPub Follow / Join / Announce.

When an external user Follows @[email protected]
→ added to followers list
bbPress can automatically grant “followers-only access rights”
When an external instance sends a Reply to the group,
→ it goes into /forum/travel-tips/inbox and is saved as a comment in WordPress

That is, when a Mastodon user comments,
→ it automatically appears in the WordPress bbPress forum thread ✨

🏗️ Structure diagram

[WordPress + bbPress + ActivityPub]
       │
       ├── Forum A = Group Actor (@travel-tips)
       │     ├── Moderator: @jiwoon
       │     ├── Topic 1 → Create Activity
       │     └── Reply → Note Activity
       │
       ├── Forum B = Group Actor (@ai-design)
       │     ├── Moderator: @thaumiel999
       │     ├── Topic 1 → Create Activity
       │     └── Reply → Reply Activity
       │
       └── Site Blog Actor (@travel-in-busan)

Each forum is independently exposed to Fediverse as a group,
and communities on different topics (travel, AI, design, etc.) are naturally separated.

💡 Application ideas

Category-based groups: treat taxonomy terms as group actors instead of forums
ActivityPub-based Q&A forum: map upvote/downvote to Like/Dislike Activities
Join feature extension: link ActivityPub Join activity with bbPress Subscribe

⚠️ Caution / Limitations

Item	Notes
ActivityPub Plugin	By default, only `author`-based actors are supported, so group/forum actors require customization
Inbox Security	When receiving external replies, signature verification and spam filtering are important
Caching	If there are many forum actors, outbox/inbox request load can increase
Multi-forum Structure	Since the forum slug becomes the Fediverse username, name management is important

✨ Summary

Element	Role	Fediverse Equivalent
Forum	Group Actor	@forumslug@domain
Topic	Create Activity	Post created by the group
Reply	Note / Reply	Threaded conversation
Moderators	attributedTo	Group administrators
Forum Followers	followers	External users

Thus, each forum functions as an independent Fediverse community as a group actor,
and you and co-administrators can control all of it with a single WordPress admin account.

https://socialhub.activitypub.rocks/t/where-and-how-to-send-join-activity/4263/2

When a local WordPress person actor joins and posts in a remote Lemmy group (forum), how and where does the message flow?

⚙️ Premise

On the local site (A): Person actor: @[email protected]
On the remote site (B): Group actor: @[email protected]
ActivityPub protocol compliant

🔁 1. Join Process

The local Person actor creates a Join Activity for the remote Group actor.

{
  "@context": "https://www.w3.org/ns/activitystreams",
  "type": "Join",
  "actor": "https://a.example/users/jiwoon",
  "object": "https://b.example/groups/forum",
  "to": ["https://b.example/groups/forum"]
}

This Activity is sent to the remote group’s Inbox.
That is → POST https://b.example/inbox
The remote Group server verifies this Join request and, upon approval (or auto-approval), registers the Person as a group member.

🗣️ 2. Post (Create) Process

Now let’s see when @[email protected] posts to the group.

The local server (A) generates a Create Activity.

{
  "@context": "https://www.w3.org/ns/activitystreams",
  "type": "Create",
  "actor": "https://a.example/users/jiwoon",
  "to": ["https://b.example/groups/forum"],
  "object": {
    "type": "Note",
    "content": "This is a post I made in the group forum."
  }
}

The key point here is "to": ["https://b.example/groups/forum"]
→ Since the recipient is the group actor, this Activity is sent to the remote Group’s Inbox.
That is, the post goes directly into b.example’s /inbox.
The Group server (B) checks whether the received Activity is addressed to itself,
→ copies it into the group’s outbox to publish it to the group feed,
→ and broadcasts it to group members (followers).

📦 3. Internal Operation of the Remote Group

While processing Create, the remote server (B):

Delivers the Activity to all users following the group (depending on to, cc)
Displays it on the group’s public timeline
Shows @[email protected] as the author
Ownership of the post belongs to @jiwoon, but hosting is handled by the group (B)

🔄 4. Flow of Replies/Notifications

If someone comments on the group post, and the to field of that comment includes the original author (@jiwoon),
→ the remote group server (B) forwards it back to the local server (A)’s inbox.
→ In other words, bidirectional Activity flow occurs between servers.

💡 In Summary

Step	Activity	Transmission Direction	Description
Join	Person → Group	Local → Remote	Group join request
Create	Person → Group	Local → Remote	Post in group
Announce / Deliver	Group → Followers	Remote → Each Follower	Group distributes post
Reply	Member → Person	Remote → Local	Comment/mention delivery

⚠️ Cautions

The default WordPress ActivityPub plugin does not yet fully support Group actors.
→ Requires additional extension or custom implementation.
Mastodon does not support Groups, but Lemmy / Kbin / Mobilizon / PeerTube / bbPress ActivityPub extensions do.
Join approval/permission handling (Accept, Reject, Moderation) varies by implementation.

👉 Conclusion:

When a local Person joins a remote Group and posts, the post is sent to the remote Group’s Inbox,
and that server broadcasts it to the group feed and followers.
In short: “The post enters the group server and spreads from there.”

“When a local Person posts to a remote Group, where exactly is the post (Object) stored?”
— The ‘ownership vs hosting’ structure in ActivityPub design.

🧩 Key Summary

Category	Description
Author (Person)	The original creator of the post — recorded in the Object’s `attributedTo` field
Group (Group)	The publishing entity — Object appears in the group feed and is stored on the group server
Storage Location	The Object actually exists (is hosted) on the group server (Group’s outbox)

That is,

When a local Person posts to a remote Group,
the Object (post data) is stored on the remote Group server,
with author information linked remotely via attributedTo.

⚙️ Detailed Data Flow

① Activity creation on local server (A)

{
  "@context": "https://www.w3.org/ns/activitystreams",
  "type": "Create",
  "actor": "https://a.example/users/jiwoon",
  "to": ["https://b.example/groups/forum"],
  "object": {
    "id": "https://a.example/users/jiwoon/posts/12345",
    "type": "Note",
    "attributedTo": "https://a.example/users/jiwoon",
    "content": "Hello, this is a group post.",
    "published": "2025-10-12T10:00:00Z"
  }
}

Here, object.id is the original address on the local server (A).
However, the remote group (B) processes this post and creates a “hosted copy.”

② Inbox processing on remote server (B)

When the remote group @[email protected] receives Create, it performs the following:

Check object.id — whether it’s externally hosted.
Create a copy — store internally (replace object.id with its own URL or keep canonical link).
Add to group’s outbox — display in the group feed.
Broadcast to followers.

Thus, the actual storage is divided as follows:

Item	Storage Location	Description
Original Object	`https://a.example/users/jiwoon/posts/12345`	Original on author’s server (optional, if publicly accessible)
Replicated Object	`https://b.example/groups/forum/posts/9876`	Copy stored by group server (used by most implementations)

Most Fediverse servers (Lemmy, Kbin, Mobilizon, etc.) fetch the “original post” and store a full replicated copy internally.
Therefore, “forum post data” is stored in the group server’s database,
and the author remains only as the “source.”

📦 Example Storage Structure (Based on Lemmy or bbPress extension design)

Database (b.example):

Groups:
  - id: forum
    inbox: /inbox
    outbox: /outbox

Posts:
  - id: 9876
    object_id: https://b.example/groups/forum/posts/9876
    attributedTo: https://a.example/users/jiwoon
    content: "Hello, this is a group post."
    canonical_url: https://a.example/users/jiwoon/posts/12345

→ The group server maintains the original URL (canonical_url) while storing a replicated copy in its own DB.
→ Therefore, if the group disappears, the post disappears too, and the author’s post “only existed within the group.”

🧠 Conceptual Summary

Role	Object Owner	Object Identifier	Notes
Local Person posting on their own timeline	Local server	Local domain-based ID	Full ownership
Local Person posting to a remote Group	Remote server	Remote domain-based ID	Group-hosted, Person-sourced
Group posting its own announcement	Remote server	Remote domain-based ID	Group is the author

⚠️ Points to Note

Default WordPress ActivityPub plugin structure does not yet support Object replication (“federated post hosting”).
→ That is, if the original Object is external, it is shown only as a simple link.
→ To use a Group model, you need an ActivityPub extension (e.g. activitypub-forum, bbpress-activitypub-extension).
Preventing Object ID duplication:
The Group server often issues a new internal ID instead of using the received Object’s ID directly.
Deletion (Undo/Delete) synchronization issue:
Even if the original author deletes the post, the replicated copy on the remote group often remains.

🔍 Summary

✅ Post (Object) is stored on the “group server.”
🧭 Author (Person) is linked only via attributedTo.
🗂️ Original Object ID may remain as a “reference link (canonical).”
⚠️ WordPress’s default ActivityPub implementation does not automate this replication/hosting.

“When converting a bbPress forum into an ActivityPub-based Group, how to map the Object replication/storage structure to the WordPress database (postmeta-based)”
Example: wp_posts ↔ activitypub_objects ↔ group_meta structure.

Can a Tombstone Object be restored back into an Article?

Lifecycle of ActivityPub “Tombstone” Object — “When a deleted post is restored, can it be reverted back to Article/Object at the ActivityPub level?”

✅ It is possible, but rather than simply reverting the Tombstone,
it should be considered as creating a new Object (Create).

⚰️ 1. What is a Tombstone?

According to the ActivityPub spec (W3C Recommendation),
a Tombstone is an object type that acts as a ‘marker’ for a deleted object.

{
  "type": "Tombstone",
  "formerType": "Article",
  "id": "https://example.com/posts/123",
  "deleted": "2025-10-12T12:00:00Z"
}

That is:

id remains the same as the previous post ID.
formerType indicates the pre-deletion type (Note, Article, etc.)
deleted records the deletion time.

💡 When this object appears,
followers or remote servers recognize “the Object with this ID is gone.”
(Usually the UI hides or marks it as “deleted.”)

🧟 2. Restoring a Tombstone (Theoretical Possibility)

The question is: Can the Tombstone be “revived”?
In the spec, a Tombstone is treated as a “permanent deletion marker,”
👉 so restoring the original Object as-is is not forbidden,
but you must propagate it as a new Create.

That is, instead of directly reverting the Tombstone:

You can reuse the same ID, but most servers treat it as a “new Object.”
Therefore, upon restoration, a new Create Activity must be issued.

This is closer to “reposting” than restoration.

That is, WordPress internally distinguishes between “trash” and “delete,”
but ActivityPub plugins usually do not —
when post_status = trash, they just send a Delete Activity.

Therefore, when restoring, you must manually send a new Create Activity.

Practically Safe Restoration Procedure (Example for WordPress)

When post_status = trash, ActivityPub publishes a Delete Activity and generates a Tombstone.
When the user clicks “Restore”:
- Reset post_status to publish.
- Issue a new Create Activity.
- (Optional) Keep or reissue the object.id.
On remote servers, it appears as a new post, often overwriting the old one.

💡 Recommendation:

Issue a new object.id, and specify the old ID in the replaces field —
this cleanly expresses continuity between Tombstone and Article.

{
  "type": "Article",
  "id": "https://example.com/posts/456",
  "replaces": "https://example.com/posts/123",
  "content": "This is the restored post."
}

“In the WordPress ActivityPub plugin, synchronize permanent deletion with Tombstone and re-propagate Create upon reposting (PHP filter + REST hook)”

“When the visibility of a post is changed later, how is it synchronized across the network?”

To fully understand this, you need to know:

Structure of the to, cc, audience fields in ActivityPub
The immutability principle in Activity Streams
And how implementations like Mastodon/Lemmy/WordPress actually handle them

🌐 1. Basic Concept: Visibility is valid only “at the time of distribution”

In ActivityPub, visibility is determined at the time the post is first sent (to/cc).

The important point here is:

✳️ to / cc / audience are merely “recipient lists,”
and once sent, they cannot be taken back.

Because ActivityPub is a federated broadcast system,
once a post is distributed, it’s stored in remote server databases,
and there’s no mechanism to “recall” or “re-broadcast” with modified visibility.

🎭 A. Using `Update` Activity

To change the visibility, you have to think of it as “sending the modified Object again.”

Technically, this is not “visibility modification” but “replacing (Updating) the entire object.”
However, most servers do not update the visibility settings of the existing Object even when they receive an Update.

That is, it is possible in the standard, but it almost never works in practice.

🔒 B. “Private Repost (Re-create)” Pattern

In actual federated networks like Misskey, this method is used:

Send a Delete Activity for the existing post (processed as Tombstone in all instances)
Repost the same content with a new Create Activity,
specifying new to / cc ranges (e.g., Public → Followers)

🧩 In short, delete + re-create is the safest method.
(This is in fact the de facto standard convention across the entire Fediverse.)

🧭 3. Behavior in the WordPress ActivityPub Plugin

In WordPress, “visibility” is stored as post_status or visibility meta.
The default plugin maps this to the to field of ActivityPub:

WP Status	ActivityPub Target	Description
`public`	`Public` + followers	Public post
`private`	followers only	Followers only
`draft` / `trash`	Unpublished / Tombstone	Not sent

When this state is changed,

locally, the post_visibility changes,
but “Update” is not sent to remote.

That is,

The WordPress ActivityPub plugin does not reflect visibility changes to the federation.
→ To reflect it, you must manually send Update or “Delete+Create” through a custom hook.

Why ActivityPub Does Not Support “Visibility Changes”

ActivityPub is fundamentally an event-based, immutable log structure.
It has no function to “edit a previously sent Activity,”
and must always represent the state through a new Activity.

Therefore, visibility changes are “delete and recreate.”
Through this:

Maintain consistency of past logs
Guarantee integrity of cached remote data
Prevent data inconsistency within the federation

📌 Conclusion

“Changing visibility” must be handled as “creating a new object,” not modifying object properties, under ActivityPub
Overwriting via Update only works in certain implementations (WordPress, Friendica, some Pleroma)
For Mastodon or Misskey compatibility, “reposting as a new post” is safest

Personally, I think it’s more appropriate to designate the default posts page (blog page) as an organization actor and treat custom post type: forum as a group actor, but the problem is that there are no implementation examples of organization actor.

The concept of “default posts page → Organization actor, custom post type: forum → Group actor”
is a very logical design that naturally maps the WordPress content structure to the Fediverse concept.

However, across the ActivityPub network, the Organization type is almost a “theoretical species that exists in the spec but is rarely used in practice.”
Let’s go through why that is, how it can be complemented, and how to make it feasible in WordPress step by step.

🧩 1. Why Your Model Is Valid

WordPress Structure	Actor Type	Meaning
`Posts Page` (blog root)	Organization	Publisher, brand/site identifier
`Author` (individual writer)	Person	Actual user profile
`Custom Post Type: forum`	Group	Topic-based community/discussion space
`Comment` or `reply`	Note / Article	Interaction object

This mapping exactly matches the Fediverse social hierarchy of “site = institution, forum = community, user = member.”

That is,

Organization = units like “corporation” or “project,”
Group = “affiliated team or forum,”
Person = “individual user.”

This structure is far richer than the single Person-centric model of Mastodon or Misskey.

🧩 2. Why “Organization” Is Not Actually Used

🚫 1) Mastodon / Misskey / Lemmy / PeerTube etc. only implement `Person` or `Service`

Although the ActivityPub spec defines the following Actor types:

Person
Group
Organization
Service
Application

In actual implementations, only Person is generally supported.
For example, in the Actor JSON of Mastodon:

"type": "Person"

Misskey is the same.

Organization is practically a “dead spec” — it exists in the standard but most software does not recognize it.
This is because the Fediverse has long been centered on “individual-based microblogging.”

🧩 3. In Practice, Organization Has Been Replaced by Service / Application

Mastodon instance accounts are effectively Service actors.
Entire WordPress.com or a blog like travel-in-busan.com also has the nature of an Organization,
but for federation compatibility, it must be treated as Service.

That is, while Organization is technically correct in the spec,
using Service type is the realistic compromise to ensure interoperability.

{
  "@context": "https://www.w3.org/ns/activitystreams",
  "type": "Service",
  "id": "https://travel-in-busan.com/blog",
  "name": "Travel in Busan Blog",
  "preferredUsername": "blog",
  "inbox": "https://travel-in-busan.com/blog/inbox",
  "outbox": "https://travel-in-busan.com/blog/outbox"
}

Even with this, most Fediverse clients display it normally.
(It appears as an account called “Blog.”)

🧩 4. Mapping Group Actor to Forum CPT Is Perfectly Valid

In a WordPress + bbPress environment, a forum has the following relationships:

Forum (group)
 ├── Topic (discussion thread)
 │    ├── Reply (post)
 │    └── ...

This matches exactly with ActivityPub’s structure:

Group actor
 ├── Create (Note or Article)
 │    ├── inReplyTo
 │    └── ...

Thus, a forum can be treated as a “group per board” in federation.
For example:

{
  "type": "Group",
  "id": "https://travel-in-busan.com/forums/busan-food",
  "name": "Busan Food Forum",
  "inbox": "https://travel-in-busan.com/forums/busan-food/inbox",
  "members": [
    "https://travel-in-busan.com/users/jiwoon",
    "https://mastodon.social/users/alice"
  ]
}

Users can then join this group with a Join activity
and post within it via Create.

🧩 5. Why an Organization Actor Is Necessary

Treating an entire site as a single Person causes issues.

Situation	Problem
Operating multiple forums	Appears as if one “person” owns everything
Multi-author blog	Ambiguous separation between `Person`s
Corporate blog	Cannot express “non-human organization” identity
ActivityPub signature	Requires organization key, not individual key

Therefore, designating the entire WordPress blog as an Organization (or Service) provides:

Identity for the organization-level (whole blog) sender
Parent-context for subordinate actors (Person, Group)
Meaning in federation that “this is sent by the site itself”

🧩 6. Suggested Implementation Direction

✅ 1) Register posts page as Service actor

add_filter( 'activitypub_actors', function( $actors ) {
    $actors['organization'] = [
        'id' => home_url( '/blog' ),
        'type' => 'Service',
        'name' => get_bloginfo( 'name' ),
        'preferredUsername' => 'blog',
        'inbox' => home_url( '/blog/inbox' ),
        'outbox' => home_url( '/blog/outbox' ),
        'url' => home_url( '/blog/' ),
    ];
    return $actors;
});

→ This makes the “site itself” function as an independent sender in federation.

✅ 2) Register forum CPT as Group actor

add_filter( 'activitypub_actors', function( $actors ) {
    $forums = get_posts(['post_type' => 'forum', 'post_status' => 'publish']);
    foreach ( $forums as $forum ) {
        $actors[ $forum->post_name ] = [
            'id' => get_permalink( $forum->ID ),
            'type' => 'Group',
            'name' => $forum->post_title,
            'preferredUsername' => $forum->post_name,
            'inbox' => get_permalink( $forum->ID ) . 'inbox',
            'outbox' => get_permalink( $forum->ID ) . 'outbox'
        ];
    }
    return $actors;
});

→ Creates an independent group actor per forum
→ Remote users can follow or join each forum

✅ 3) Person → actual user (author)

This is already provided by the existing WordPress ActivityPub plugin.
Thus, the site structure expands as follows:

Service (blog)
 ├── Group (Forum 1)
 │    ├── Person (User A)
 │    └── Person (User B)
 ├── Group (Forum 2)
 └── ...

This makes the hierarchy “users belonging to forum groups within this blog” clearly visible across the federation.

🧩 7. Final Summary

Element	Recommended Actor	Reason
Default posts page	`Service` (technically `Organization`, use `Service` for compatibility)	Site-wide sender identity
Forum (CPT)	`Group`	Community-level activity
User (author)	`Person`	Individual activity
Bot / automation	`Application`	Non-human automation actor

💡 Conclusion

Your concept — “seeing the blog as an Organization and forum as a Group” —
is completely correct according to the spec,
but must be substituted with Service instead of Organization for real-world compatibility.

And by applying this model to WordPress ActivityPub,
a multi-layered Fediverse network of “site → forum → user” becomes possible.

Create an example of “implementing a structure in the WordPress ActivityPub plugin where Organization (Service) + Group + Person are simultaneously registered” as functions.php or a standalone plugin.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Implementing the Organization (Service) + Group + Person structure in WordPress ActivityPub #2322

Uh oh!

{{title}}

Uh oh!

Replies: 0 comments

Select a reply

Uh oh!

Implementing the Organization (Service) + Group + Person structure in WordPress ActivityPub #2322

Uh oh!

Jiwoon-Kim Oct 15, 2025

🧠 First, conceptual clarification

🔐 Permission (Moderation) structure

🌐 Example result

🧠 Basic conceptual overview

④ Federated forum subscription (Follow/Join)

🏗️ Structure diagram

💡 Application ideas

⚠️ Caution / Limitations

✨ Summary

⚙️ Premise

🔁 1. Join Process

🗣️ 2. Post (Create) Process

📦 3. Internal Operation of the Remote Group

🔄 4. Flow of Replies/Notifications

💡 In Summary

⚠️ Cautions

🧩 Key Summary

⚙️ Detailed Data Flow

① Activity creation on local server (A)

② Inbox processing on remote server (B)

📦 Example Storage Structure (Based on Lemmy or bbPress extension design)

🧠 Conceptual Summary

⚠️ Points to Note

🔍 Summary

⚰️ 1. What is a Tombstone?

🧟 2. Restoring a Tombstone (Theoretical Possibility)

Practically Safe Restoration Procedure (Example for WordPress)

🌐 1. Basic Concept: Visibility is valid only “at the time of distribution”

🎭 A. Using Update Activity

🔒 B. “Private Repost (Re-create)” Pattern

🧭 3. Behavior in the WordPress ActivityPub Plugin

Why ActivityPub Does Not Support “Visibility Changes”

🧩 1. Why Your Model Is Valid

🧩 2. Why “Organization” Is Not Actually Used

🚫 1) Mastodon / Misskey / Lemmy / PeerTube etc. only implement Person or Service

🧩 3. In Practice, Organization Has Been Replaced by Service / Application

🧩 4. Mapping Group Actor to Forum CPT Is Perfectly Valid

🧩 5. Why an Organization Actor Is Necessary

🧩 6. Suggested Implementation Direction

✅ 1) Register posts page as Service actor

✅ 2) Register forum CPT as Group actor

✅ 3) Person → actual user (author)

🧩 7. Final Summary

💡 Conclusion

Replies: 0 comments

Jiwoon-Kim
Oct 15, 2025

🎭 A. Using `Update` Activity

🚫 1) Mastodon / Misskey / Lemmy / PeerTube etc. only implement `Person` or `Service`