Build on the unsuppressed feed.

Candor Reach is the open-source infrastructure layer for the Open Feed Network — a chronological, zero-suppression data pipeline that any developer can read from, write to, and run a node on.

Authentication

Candor Reach uses two auth models depending on the operation. Read operations (subscribing to feeds, querying posts) require a public app key. Write operations (publishing posts, managing accounts) require a signed user token.

App key — read access

GET /v1/feed HTTP/1.1
Host: reach.candor.network
Authorization: App your_app_key_here
Accept: application/json

User token — write access

POST /v1/posts HTTP/1.1
Host: reach.candor.network
Authorization: Bearer user_jwt_token_here
Content-Type: application/json

Quickstart

Subscribe to the live feed and publish your first post in under two minutes.

import { CandorReach } from '@candor/reach';

const reach = new CandorReach({
  appKey: process.env.CANDOR_APP_KEY,
});

// Subscribe to the live chronological feed
const feed = reach.subscribe({ limit: 20 });

feed.on('post', (post) => {
  console.log(`[${post.timestamp}] ${post.author.handle}: ${post.content}`);
});

// Publish a post (requires user token)
const result = await reach.publish({
  content:  'Hello from the open feed.',
  userToken: process.env.CANDOR_USER_TOKEN,
});

console.log(`Published: ${result.postId}`);

from candor_reach import CandorReach

reach = CandorReach(app_key="your_app_key")

# Fetch the latest 20 posts
posts = reach.feed.get(limit=20)
for post in posts:
    print(f"[{post.timestamp}] {post.author.handle}: {post.content}")

# Publish a post
result = reach.publish(
    content="Hello from the open feed.",
    user_token="your_user_token"
)
print(f"Published: {result.post_id}")

# Fetch the live feed
curl https://reach.candor.network/v1/feed \
  -H "Authorization: App your_app_key"

# Publish a post
curl -X POST https://reach.candor.network/v1/posts \
  -H "Authorization: Bearer your_user_token" \
  -H "Content-Type: application/json" \
  -d '{"content":"Hello from the open feed."}'

Subscribe to feed

The primary read endpoint. Returns posts in strict chronological order — newest first. No ranking algorithm. No suppression. What was published is what you receive.

{
  "posts": [
    {
      "id":        "post_9f8e7d6c5b4a",
      "content":  "The feed is live.",
      "timestamp": "2026-05-23T14:22:01.000Z",
      "author": {
        "id":     "acc_a1b2c3",
        "handle": "rolando",
        "displayName": "Rolando Cruz"
      },
      "nodeId":   "node_iad_01",
      "signature": "ed25519:a3f9c12d..."
    }
  ],
  "cursor":    "post_9f8e7d6c5b4a",
  "hasMore":   true,
  "nodeCount": 5
}

Publish to feed

Query feed

Search

Run a node

The Candor Reach network is federated. Any developer can run a node that syncs with the global network, serves local traffic, and contributes to network resilience. Nodes are the foundation of the decentralized architecture.

Accounts

WebSocket feed

Connect to the live feed over WebSocket for real-time post delivery. Posts arrive within milliseconds of being published to any node in the network.

const ws = new WebSocket(
  `wss://reach.candor.network/v1/stream?appKey=${APP_KEY}`
);

ws.onopen = () => {
  // Subscribe to the global feed
  ws.send(JSON.stringify({
    type: 'subscribe',
    channel: 'feed.global',
  }));

  // Or subscribe to a specific account
  ws.send(JSON.stringify({
    type: 'subscribe',
    channel: 'feed.account',
    handle: 'rolando',
  }));
};

ws.onmessage = ({ data }) => {
  const event = JSON.parse(data);

  switch (event.type) {
    case 'post.created':
      console.log('New post:', event.post);
      break;
    case 'post.deleted':
      console.log('Deleted:', event.postId);
      break;
    case 'node.joined':
      console.log('New node:', event.nodeId);
      break;
  }
};

WebSocket event types

Post object

Account object

Chronological guarantee

Candor Reach makes a hard protocol guarantee: posts are always delivered in timestamp order. There is no ranking algorithm, no engagement scoring, no promoted content, and no suppression mechanism in the protocol layer.

Every post is signed with the publishing node's Ed25519 key. Signatures include the post content, author ID, and timestamp — making it cryptographically verifiable that a post was not modified or reordered after publication.

Sync lag

In a federated network, posts originating on one node propagate to all other nodes via the sync protocol. Typical sync lag is under 500ms across nodes in the same region, and under 2s globally. The nodeId field on each post indicates where it originated.

Error codes

All errors return a consistent JSON body: { error, code, message }.

Rate limits

Limits are per app key for read operations and per user token for write operations.

Open source

Candor Reach is fully open source under the Apache 2.0 license. You can read the code, run your own node, submit issues, and contribute pull requests.

Test the Candor Shield API in real time. No API key required for this demo.

Real-time health of all Candor infrastructure. Updated every 30 seconds.