Twitter List API: get members and tweets

#What a Twitter List API can read

An X List is a named group of up to 5,000 accounts with its own timeline, and an API can read three parts of a public one. Each part comes from its own endpoint:

• Members: the accounts the List's owner added. This is the curated set people export into spreadsheets and CRMs.
• Followers: the people who follow the List to read its timeline, which X also calls subscribers. They are not the members' own followers; for an account's followers, see the Twitter followers API guide.
• The feed: the List's timeline, the newest posts from every member in one place.

The List ID is the long number in the List's address, x.com/i/lists/1234567890123456789. Every List request starts from it.

A few rules from X's Help Center (opens in a new tab) decide what you can read. Lists are public by default, and anyone can follow a public one. A private List is visible only to the account that made it, so no API reads it. Names run to 25 characters. Nobody can leave someone else's List except by blocking its owner.

Two things no List endpoint returns: when an account was added, and who left. To track changes, export the members on a schedule and compare the files by id. Because the owner picks the accounts once in the X app and your code needs only the ID, a List is also the simplest unit for real-time Twitter monitoring.

#Export a List's members to CSV

To export a List, use Sorsa API, a Twitter (X) API and scraper: its GET /list-members (opens in a new tab) returns up to 200 members per request, so even a full 5,000-member List takes 25 requests. The steps below write every member into one CSV file.

1. Copy the List ID. Open the List on x.com and take the number after /lists/ from the address bar.

2. Get a key. Sign up and copy your API key from the dashboard. No card, and the first 100 requests are free.

3. Request the first page. Send the ID as list_id with your key in the ApiKey header.

   curl -G "https://api.sorsa.io/v3/list-members" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "list_id=1234567890123456789"
   

   {
     "users": [
       {
         "id": "1592041833471827968",
         "username": "dana_tracks_markets",
         "display_name": "Dana Tracks Markets",
         "description": "Rates, FX and the odd chart.",
         "location": "Chicago, IL",
         "followers_count": 48210,
         "followings_count": 612,
         "tweets_count": 15873,
         "verified": true,
         "protected": false,
         "created_at": "2014-03-09T16:22:41Z"
       }
     ],
     "next_cursor": "DAABCgABGc3yPLu__-0KAAIZsbqf"
   }
   

   Show full response

4. Follow the cursor and write the rows. Send next_cursor back with each request until it comes back empty, and save every page as it arrives.

   import csv
   import requests
   
   URL = "https://api.sorsa.io/v3/list-members"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   FIELDS = ["id", "username", "display_name",
             "followers_count", "verified", "created_at"]
   
   
   def export_members(list_id, path="list_members.csv"):
       params = {"list_id": list_id}
       with open(path, "w", newline="", encoding="utf-8") as f:
           out = csv.DictWriter(f, fieldnames=FIELDS,
                                extrasaction="ignore")
           out.writeheader()
           while True:
               r = requests.get(URL, headers=HEADERS,
                                params=params, timeout=30)
               r.raise_for_status()
               page = r.json()
               out.writerows(page.get("users", []))
               cursor = page.get("next_cursor")
               if not cursor:
                   break
               params["next_cursor"] = cursor
   
   
   export_members("1234567890123456789")
   

   import { writeFileSync } from "node:fs";
   
   const URL = "https://api.sorsa.io/v3/list-members";
   const headers = { ApiKey: "YOUR_API_KEY" };
   const rows = [["id", "username", "followers_count"]];
   
   let cursor = null;
   do {
     const params = new URLSearchParams({
       list_id: "1234567890123456789",
     });
     if (cursor) params.set("next_cursor", cursor);
     const res = await fetch(`${URL}?${params}`, { headers });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
     const page = await res.json();
     for (const u of page.users ?? []) {
       rows.push([u.id, u.username, u.followers_count]);
     }
     cursor = page.next_cursor;
   } while (cursor);
   
   writeFileSync("list_members.csv", rows.map((r) => r.join(",")).join("\n"));
   

Every row is a full public profile: the same id, handle, bio, location, counts and creation date that the profile endpoints return. Keep id as the key in your files, since a handle can change and the ID never does. A 403 means the key is missing or out of requests; a 429 means more than 20 requests in one second on that key, so wait a second and send it again.

The same loop exports a List's followers through GET /list-followers (opens in a new tab), also up to 200 followers per page. Change the path, and send the List as list_link instead of list_id.

Good to know

The two parameters differ. /list-members and /list-tweets take list_id, the number alone. /list-followers takes list_link, which accepts the whole List URL or the number. Pasting the full address into list_id is an easy slip, so strip it to the digits first.

#Read a List's tweets as one feed

GET /list-tweets (opens in a new tab) returns the List's timeline: the newest posts from all its members, about 20 per request, each with its text, date, like, reply, repost and view counts, and the author's profile. One request covers every account on the List, whether it holds 12 accounts or 5,000.

The feed has no "since" filter, so a monitor reads it from the top and stops at the first post it has already stored. Snowflake IDs, the numbers X gives every post, grow with time, so the newest ID you saved marks where the last check ended.

This loop checks a List every five minutes and prints each new post once:

import time
import requests

URL = "https://api.sorsa.io/v3/list-tweets"
HEADERS = {"ApiKey": "YOUR_API_KEY"}
LIST_ID = "1234567890123456789"


def new_posts(seen, max_pages=10):
    """Read the feed from the top until a post we already have."""
    fresh, params = [], {"list_id": LIST_ID}
    for _ in range(max_pages):
        r = requests.get(URL, headers=HEADERS,
                         params=params, timeout=30)
        r.raise_for_status()
        page = r.json()
        for tweet in page.get("tweets", []):
            if tweet["id"] in seen:
                return fresh
            fresh.append(tweet)
        cursor = page.get("next_cursor")
        if not cursor:
            break
        params["next_cursor"] = cursor
    return fresh


seen = set()
while True:
    for t in reversed(new_posts(seen)):
        seen.add(t["id"])
        print(t["created_at"], "@" + t["user"]["username"],
              t["full_text"][:80])
    time.sleep(300)  # check again in 5 minutes

In production, keep seen in a database and cap it at the last few thousand IDs. The max_pages limit keeps the very first run, when nothing is stored yet, to 200 posts.

The feed is built for what's new. For a List's older posts, use search instead: put the members' handles into from: operators joined by OR, in batches, and send the query to POST /search-tweets (opens in a new tab) with a date range. The Twitter search API guide covers the operators, and the archive reaches back to 2006.

#Why one List beats polling every account

A List feed costs one request per check however many accounts it holds, while reading each account's own timeline costs one request per account per check. For 500 accounts checked every 5 minutes, that is 4.3M requests a month one by one, and 8,640 through one List, as long as fewer than 20 new posts land between checks.

Speed sets a second limit. At 20 requests per second, a key reads 1,200 timelines a minute, so 5,000 accounts take more than four minutes to sweep once. The List feed answers the same question in one request, or in a few when the List is busy.

Pages per check grow only with the number of new posts: about one request for every 20 posts that arrived since the last check. A List watches what chosen accounts post. To catch every post that names a brand, whoever writes it, search for the brand with the Twitter mentions API instead.

#What List data costs per 1,000

List members and followers cost from $0.007 per 1,000 on Sorsa API, and a List's posts from $0.07 per 1,000. The official X API bills $10.00 per 1,000 members or followers and $5.00 per 1,000 posts on its pay-per-use price list (opens in a new tab).

From November 22, 2026, X also bills every author profile that comes back with those posts, at $0.010 each (X's notice of October 23 (opens in a new tab)). On Sorsa API the author's profile is part of every post at no extra cost.

Five things decide a List API: price, setup, request rate, volume and the safety of your X account. Sorsa API leads on each:

• Members or followers, per 1,000

  Sorsa API

  from $0.007, 200 per request

  Official X API

  $10.00, 100 per page

• List posts, per 1,000

  Sorsa API

  from $0.07, about 20 per request

  Official X API

  $5.00, plus $0.010 per author from Nov 22, 2026

• A full 5,000-member List

  Sorsa API

  from $0.035

  Official X API

  $50.00

• Setup

  Sorsa API

  one API key

  Official X API

  developer account, app, Bearer token, prepaid credits

• Request rate

  Sorsa API

  20 requests per second on every plan

  Official X API

  900 requests per 15 minutes per List endpoint

• Volume ceiling

  Sorsa API

  plans up to 10M requests a month, more on request

  Official X API

  3M post reads per billing cycle, then Enterprise

• Your X account

  Sorsa API

  never touched: no login, no cookies

  Official X API

  your developer account and its app

For List data, use Sorsa API: members at 200 per request from $0.007 per 1,000, the whole List's feed from $0.07 per 1,000, and nothing to set up beyond one key. Failed requests are never charged. Sorsa API is a REST API: one request with your key returns clean JSON, with nothing to run in your browser and no X account of yours at risk.

#What about X Communities?

X announced on April 23, 2026 that it would shut Communities down, first on May 6 and then on May 30, citing low use and spam (TechCrunch (opens in a new tab)). The feature outlived both dates and was still live in late July, with no new date from X.

Sorsa API's reference still lists five Community endpoints, among them POST /community-tweets (opens in a new tab) for a Community's posts and POST /community-members (opens in a new tab) for its members, plus a single-account check, POST /check-community-member (opens in a new tab). Our docs ask you to confirm with support which of them return data before you build a new workflow on them. Membership checks for campaigns are covered in the engagement verification API guide.

For anything that has to keep working, put the accounts on a List instead. Lists are not part of the shutdown, and every List endpoint above reads them today.

#Pull your first List

Copy a List's ID, send one request to GET /list-members, and up to 200 profiles come back as JSON. Sorsa API reads a List's members and followers 200 per request from $0.007 per 1,000 and its whole feed from $0.07 per 1,000, with one key and 20 requests per second on every plan. Your 100 free requests export 20K List members, four full Lists, before you pay anything.

#FAQ