X Spaces API: hosts, speakers and listener counts

#What a Space lookup returns, and what no API returns

A Space lookup returns three things about one Space: what it is (title, state, scheduled and start times), who runs it (the host, the co-hosts and the speakers) and how many people listen. Nothing more comes back: no audio, no transcript, and no complete roll call of the audience. For every other kind of X data an API can read, the map of what data you can get from the Twitter API lists them side by side.

X's own developer platform reads Spaces through GET /2/spaces/{id} and its batch and by-creator versions. Its Spaces documentation (opens in a new tab) sets three limits that shape any project:

• Listeners arrive as a number. The participant_count field counts everyone in the room, hosts included; there is no listener list.
• People arrive as IDs. The host, co-hosts and speakers come back as user IDs, and their profiles only through expansions.
• Ended Spaces are gone. Once a Space ends, the Spaces endpoints return an error instead of the Space.

The price sits on X's pay-per-use rate card (opens in a new tab): $0.005 per Space read, $5.00 per 1,000. From November 22, 2026, every user profile that comes back through an expansion is billed too, at $0.010 (X's notice of October 23 (opens in a new tab)), so a Space with its host's profile costs $0.015. Each call also needs a developer account, prepaid credits and an OAuth 2.0 or bearer token.

The listener limit is not X's API being stingy. Spaces are public, and X's Help Center (opens in a new tab) says people who listen while logged out may never be listed as guests in the room at all. A count of listeners is solid data; a list of every listener does not exist anywhere.

#Get a Space's details with Sorsa API

To read X Spaces in code, use Sorsa API, a Twitter (X) API and scraper: GET /spaces takes a Space ID or link and returns the title, state and times, the host's full profile, the co-hosts and speakers, and live and replay counts, in one request from $1.40 per 1,000 Spaces. Every plan runs at 20 requests per second, with one API key and no developer account.

1. Get a key. Sign up and copy your API key from the dashboard. Your 100 free requests look up 100 Spaces.

2. Copy the Space ID. A Space ID is the code of letters and digits after /i/spaces/ in a Space's link: in x.com/i/spaces/1yNxaYzQkPwKj it is 1yNxaYzQkPwKj. X caps it at 13 characters, and it is not the long number a post carries.

3. Send the request. Call GET /spaces (opens in a new tab) with the ID as id, or the whole link as link, and your key in the ApiKey header.

   curl -G "https://api.sorsa.io/v3/spaces" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "id=1yNxaYzQkPwKj"
   

4. Read the response. One JSON object comes back: the Space's fields at the top, creator with the host's full profile, participants with the people by role, stats with the audience numbers and settings with replay and access flags.

   {
     "id": "1yNxaYzQkPwKj",
     "title": "Shipping hardware in Q1: founders compare notes",
     "state": "Running",
     "scheduled_start": 1793642400000,
     "created_at": 1793641912000,
     "updated_at": 1793645530000,
     "media_key": "28_1793641912057",
     "is_subscribed": false,
     "creator": {
       "id": "1630218874471563264",
       "username": "harbor_founders_live",
       "display_name": "Harbor Founders",
       "description": "Weekly live audio for people who ship hardware.",
       "followers_count": 48210,
       "followings_count": 312,
       "verified": true,
       "protected": false,
       "created_at": "2023-02-27T14:05:11Z",
       "profile_image_url": "https://pbs.twimg.com/profile_images/1630/harbor.jpg"
     },
     "participants": {
       "admins": [
         {
           "id": "1630218874471563264",
           "username": "harbor_founders_live",
           "name": "Harbor Founders",
           "is_verified": true,
           "start": 1793642405000
         },
         {
           "id": "1488230561123123200",
           "username": "maren_builds_hardware",
           "name": "Maren Holt",
           "is_verified": false,
           "start": 1793642460000
         }
       ],
       "speakers": [
         {
           "id": "1712093345678901248",
           "username": "tomas_ships_firmware",
           "name": "Tomas Reyes",
           "is_verified": false,
           "is_muted_by_admin": false,
           "start": 1793643120000
         }
       ],
       "listeners": [],
       "total": 1286
     },
     "stats": {
       "total_live_listeners": 1183,
       "total_participants": 1286,
       "total_replay_watched": 0
     },
     "settings": {
       "is_space_available_for_replay": true,
       "is_space_available_for_clipping": true,
       "is_locked": false,
       "disallow_join": false,
       "max_admin_capacity": 3
     }
   }
   

   Show full response

The same call in Python and Node.js, ready to loop over a list of Spaces:

import requests

API = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": "YOUR_API_KEY"}

def get_space(space_id):
    r = requests.get(f"{API}/spaces", headers=HEADERS,
                     params={"id": space_id}, timeout=30)
    r.raise_for_status()
    return r.json()

space = get_space("1yNxaYzQkPwKj")
people = space["participants"]
print(space["title"], "|", space["state"])
print("Host:", space["creator"]["username"])
print("Admins:", [p["username"] for p in people["admins"]])
print("Speakers:", [p["username"] for p in people["speakers"]])
print("Live listeners:", space["stats"]["total_live_listeners"])

const url = "https://api.sorsa.io/v3/spaces?id=1yNxaYzQkPwKj";
const res = await fetch(url, {
  headers: { ApiKey: "YOUR_API_KEY" },
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);

const space = await res.json();
const speakers = space.participants.speakers.map((p) => p.username);
console.log(space.title, space.state);
console.log("Speakers:", speakers);
console.log("Live listeners:", space.stats.total_live_listeners);

A wrong or unknown ID returns 404, a missing or exhausted key returns 403, and failed requests are never charged. Requests over 20 per second return 429: wait a second and send again.

#The fields that answer "who" and "how many"

Most Space projects read five fields: who hosts, who speaks, how many listen live, how many played the replay, and the state. The figure groups the whole response by the question each part answers.

If you are moving code from the official X API, the fields line up like this:

• Who started the Space

  Sorsa API field

  creator, a full profile

  Official X API field

  creator_id, a profile only through expansions

• Host and co-hosts

  Sorsa API field

  admins in participants, with username and name

  Official X API field

  host_ids

• Speakers

  Sorsa API field

  speakers in participants, with username and name

  Official X API field

  speaker_ids

• Audience size

  Sorsa API field

  total_live_listeners and total_participants in stats

  Official X API field

  participant_count

• Replay views

  Sorsa API field

  total_replay_watched in stats

  Official X API field

  none

• Scheduled or live

  Sorsa API field

  state, scheduled_start

  Official X API field

  state, scheduled_start, started_at

• Replay and clips allowed

  Sorsa API field

  two flags in settings

  Official X API field

  none

One detail saves debugging time: times in a Space object are Unix timestamps (plain numbers), while the rest of Sorsa API uses ISO 8601 dates, as the creator.created_at above shows.

Good to know

Treat participants.listeners as the people the room happens to show, not as an attendance sheet: X lists only some listeners, and logged-out listeners never appear. For audience size, read stats.total_live_listeners, which counts everyone.

Admins and speakers come with a username, a name and a verified flag, while the host comes with a full profile. When you need follower counts and bios for everyone on stage, pass their usernames to GET /info-batch (opens in a new tab): up to 100 profiles in one request, from $0.014 per 1,000.

#Find Spaces to look up: search for posts that link to them

A Space lookup needs an ID, and the place to find IDs is X itself: hosts announce their Spaces in posts, and every such post carries the Space's link. Sorsa API's POST /search-tweets (opens in a new tab) with the filter:spaces operator returns only posts that contain a Space link, about 20 per request, across the full archive back to 2006.

Build the query from the operators you already know from the Twitter search operators guide:

• from:harbor_founders_live filter:spaces finds every Space one host has shared.
• "hardware" filter:spaces since:2026-10-01 finds Spaces on a topic from October on.
• (from:host_one_on_stage OR from:host_two_on_stage) filter:spaces watches a short list of hosts.

The script below pages through the results with next_cursor, pulls Space IDs out of each post's text and links, and looks each one up with get_space() from the step above:

import re
import requests

API = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": "YOUR_API_KEY"}
SPACE_LINK = re.compile(r"/i/spaces/([A-Za-z0-9]{1,13})")

def find_space_ids(query, max_pages=5):
    ids, cursor = set(), None
    for _ in range(max_pages):
        body = {"query": query, "order": "latest"}
        if cursor:
            body["next_cursor"] = cursor
        r = requests.post(f"{API}/search-tweets", headers=HEADERS,
                          json=body, timeout=30)
        r.raise_for_status()
        page = r.json()
        for post in page.get("tweets", []):
            links = [e.get("link") or "" for e in post.get("entities", [])]
            for text in [post["full_text"], *links]:
                ids.update(SPACE_LINK.findall(text))
        cursor = page.get("next_cursor")
        if not cursor:
            break
    return ids

for space_id in find_space_ids("from:harbor_founders_live filter:spaces"):
    space = get_space(space_id)
    print(space_id, space["state"], space["title"],
          space["stats"]["total_live_listeners"])

Each search page and each lookup is one request. Five pages of search that surface 30 Spaces cost 35 requests in all, and at 20 requests per second the whole run finishes in a few seconds.

#Track a live Space: listener counts over time

To see how a Space's audience grows and fades, look the same Space up on a schedule while it is live and store each reading. Every lookup returns the current state, the live listener count and the people on stage, so a list of readings is the Space's audience curve.

import time
from datetime import datetime, timezone

def track(space_id, every_seconds=180, checks=30):
    for _ in range(checks):
        space = get_space(space_id)
        now = datetime.now(timezone.utc).strftime("%H:%M")
        stage = len(space["participants"]["speakers"])
        print(now, space["state"],
              space["stats"]["total_live_listeners"], stage)
        time.sleep(every_seconds)

track("1yNxaYzQkPwKj")

A 90-minute Space checked every 3 minutes takes 30 requests, about $0.06 at the Pro plan's $1.99 per 1,000. Every Sorsa API request is answered live, so each check shows the room as it is at that moment. The calculator turns your Spaces and checks into requests and the plan that covers them:

For alerts when a watched account posts, including the post that opens a Space, the real-time Twitter monitoring guide shows the polling loop at scale, and a public X List lets one request read the latest posts of up to 5,000 hosts, as the Twitter List API guide explains.

#What X Spaces data costs: Sorsa API vs the official X API

A Space lookup on Sorsa API costs one request whatever the Space holds, from $1.40 per 1,000 Spaces with the host's full profile included. On the official X API the same Space with its host's profile costs $0.015 from November 22, 2026, which is $15.00 per 1,000.

On the official X API every co-host and speaker you expand adds another $0.010, so a Space with five people on stage costs $0.055 there; Sorsa API returns the same people in the same single request. Price is one of five things that decide a Spaces project, and Sorsa API's answer to each is a number:

• Price per 1,000 Spaces: from $1.40 on Sorsa API, against $5.00 for the bare Space and $15.00 with its host on the official X API.
• People: the host's full profile, co-hosts and speakers in the same response; full profiles for everyone on stage at 100 per extra request.
• Audience numbers: live listeners, all participants and replay views, against one participant count.
• Finding Spaces: search with filter:spaces across posts back to 2006, so you are never limited to links someone sent you.
• Setup and speed: one API key in a header, no developer account or OAuth, and 20 requests per second on every plan, so 1,000 Spaces take under a minute.

Sorsa API is read-only by design and never asks for your X login, so your own X account is never at risk. To create or host Spaces, use X's apps; to post about them, pair Sorsa API with the official X API.

#Look up your first Space

An X Space's hosts, speakers and listener counts come from one lookup by the ID in its link, and the official X API returns nothing once the Space has ended. Sorsa API reads the same Space with the host's full profile and live and replay counts in one request, from $1.40 per 1,000 Spaces, and finds Spaces for you through search. Your 100 free requests look up 100 Spaces: paste a Space link into the request above and run it.

#FAQ