Threads, Meta’s microblogging platform, is built on the ActivityPub protocol. This means it can connect to other services in the fediverse, such as Mastodon and Pixelfed. Server administrators who run their own federated services may need to manage which other servers their users can interact with. Defederation is the act of blocking an entire server from communicating with your own. This article explains the defederation options available at the server level for Threads and how they compare to traditional fediverse platforms.
Key Takeaways: Threads Server-Level Defederation Controls
- ActivityPub federation settings: Threads allows server administrators to block entire domains from interacting with their instance.
- Moderation queue: Incoming federation requests can be reviewed and rejected before any content is shared.
- Domain block lists: Administrators can import or create lists of known spam or malicious servers to block automatically.
Understanding Defederation Controls in Threads
Defederation is a core concept in the fediverse. It lets a server administrator stop all communication with another server. When you defederate from a server, users on your instance cannot see posts from users on that server. Users on that server cannot see posts from your instance. This is different from blocking individual users, which only affects specific accounts.
Threads, as a large centralized platform operated by Meta, does not give individual users defederation controls. Instead, Meta’s server administrators manage these settings. This is similar to how Mastodon instances are managed by their respective admins. The key difference is that Threads users cannot choose to defederate from specific servers themselves.
The available options for server-level defederation in Threads are limited compared to open-source fediverse software. Meta has stated that it will use automated tools and human moderators to manage defederation decisions. The company has also published a transparency report that includes data on servers it has blocked or limited.
What Defederation Does
When a server is defederated from Threads, the following happens:
- Posts from users on the blocked server do not appear in Threads feeds or search results.
- Threads users cannot follow accounts on the blocked server.
- Accounts on the blocked server cannot follow Threads users.
- Any existing follows between the instances are broken.
Types of Defederation Actions
Threads supports three levels of defederation action:
- Full block: All communication between Threads and the target server is stopped.
- Limited federation: Some content types or interactions are blocked. For example, media uploads might be restricted while text posts are allowed.
- Suspension: The server is blocked and all existing data from that server is removed from Threads.
Options Available to Server Administrators
Server administrators who run their own ActivityPub-compatible services can configure defederation settings. Threads itself does not provide a public dashboard for server admins to manage defederation. Instead, Meta makes these decisions internally. However, if you run a Mastodon or other fediverse server, you can choose to defederate from Threads.
The following options are available for server administrators who want to control federation with Threads:
Manual Domain Blocking
In Mastodon, go to Preferences > Administration > Domain Blocks. Here you can add the Threads domain (threads.net) to your block list. This will prevent any communication between your server and Threads.
Importing Block Lists
Some fediverse software allows you to import block lists from community sources. These lists often include servers that are known for spam, harassment, or other policy violations. You can import a list that contains threads.net if you want to block it automatically.
Moderation Reports
If you see problematic behavior coming from Threads users, you can report it to Meta. However, this does not give you direct defederation control. Reporting can lead to Meta taking action on its own servers, but it is not a guarantee.
Common Issues and Limitations
Server-level defederation controls in Threads are not as granular as those in open-source platforms. Here are the main limitations you should know.
Threads Does Not Offer User-Level Defederation
Individual Threads users cannot block entire servers. If you want to avoid content from a specific fediverse server, you must block individual accounts or mute keywords. This is a significant difference from Mastodon, where users can mute or block entire domains.
Defederation Decisions Are Opaque
Meta does not publicly announce every defederation decision. Server administrators may not know why their server was blocked or how to appeal the decision. This lack of transparency can be frustrating for small server operators.
Limited Federation Controls
Threads does not allow server administrators to set custom federation rules. For example, you cannot configure Threads to accept posts only from servers that have a certain minimum user count or that follow specific moderation policies. This is a feature available in some fediverse software.
Threads vs Mastodon: Defederation Controls Compared
| Item | Threads | Mastodon |
|---|---|---|
| User-level defederation | Not available | Available via domain muting and blocking |
| Server-level defederation | Managed by Meta only | Managed by instance administrators |
| Block list import | Not supported | Supported via CSV or JSON files |
| Transparency reporting | Quarterly reports with aggregated data | Public moderation logs on many instances |
| Appeal process | Limited, no public documentation | Often available via instance admin contact |
Server-level defederation controls in Threads are limited to what Meta decides. If you run your own fediverse server, you have more control by blocking Threads at your end. Understanding these options helps you manage your instance effectively and protect your community from unwanted interactions. For the most current information, check Meta’s transparency reports and the ActivityPub implementation details on the Threads developer documentation.