Know what an account posted before the refresh

Why this exists

Watching X yourself is a job, not a feature

How it works

Name the accounts. Open one connection.

Everything an account does becomes an event with a stable id and a typed payload. You choose which accounts, which event types, and whether you want them on a socket or at a webhook.

1. Add an account

   One POST with a handle. We resolve it and activate delivery, usually within a minute, with nothing for you to configure. Add up to a hundred at once.

2. Open a WebSocket, or register a webhook

   One connection carries every event for every account and keyword on your key. No subscribe handshake, no channel bookkeeping.

3. Handle events by id

   Each event has a stable id. Store the last position you processed and pass it back after a disconnect to replay what you missed.

Real time, and everything else

Posts as they happen, changes as soon as they can be seen

New posts are delivered in real time. Replies, deletions, profile edits and follow-graph changes follow as soon as they become visible. Every event type documents whether it can arrive in two frames — a thin first frame to act on, then the full payload — so you can build for speed without guessing.

What you receive

Seventeen event types, one envelope

Beyond accounts

Watch a phrase, not just a person

Register a query in X's own search syntax and every new public post matching it arrives as an event. Any language, any script — no English-only restriction. We read the chronological tab, so you get what was just posted rather than what is popular.

curl -X POST https://api.xsignalfeed.com/v1/keywords \
  -H "X-API-Key: xsf_your_key" -H "Content-Type: application/json" \
  -d '{"query": "($SOL OR \"Solana\") -filter:retweets -filter:replies", "label": "solana"}'

Integrating

Three ways in, whichever suits your runtime

async with websockets.connect("wss://ws.xsignalfeed.com/v1/stream?api_key=…") as ws:
    async for raw in ws:
        ev = json.loads(raw)
        if ev["t"] == "tweet.create":
            trade(ev["target"]["screen_name"], ev["d"]["text"])

const ws = new WebSocket("wss://ws.xsignalfeed.com/v1/stream?api_key=…");
ws.on("message", (raw) => {
  const ev = JSON.parse(raw);
  if (ev.t === "tweet.create") trade(ev.target.screen_name, ev.d.text);
});

c, _, _ := websocket.DefaultDialer.Dial("wss://ws.xsignalfeed.com/v1/stream?api_key=…", nil)
for {
    _, raw, err := c.ReadMessage()
    if err != nil { break }
    handle(raw)
}

Who uses it

Built for people who act on a post, not just read it

Reliability

Designed for the day a machine dies

Worth knowing before you build

What this is not

• Not a firehose. You get the accounts and queries you register, not all of X.
• Not a posting API. We read public data and never act on your behalf. There is no write path.
• Not exactly-once. Reconnects can repeat an event. Deduplicate on id — the docs show how.
• Not retroactive. History starts when you add an account; we hold events for 30 days.
• Not able to see what X hides. Protected accounts, and accounts X suppresses in search, stay invisible.

Getting started

Request access

We onboard accounts deliberately, because every monitored handle consumes real collector capacity. Tell us roughly how many accounts you want to watch and what you are building, and we will send a key with a trial allowance.

Already have a key? GET /v1/account tells you what it can do, and the quickstart has you streaming in about five minutes.