X Articles API: get an Article's full text

#What an X Article is, and why its post holds only a link

An X Article is a long-form post on X with a title, a cover image and a formatted body: headings, bold and italic text, lists, images, video, GIFs, links and embedded posts. X switched Articles on for Premium+ subscribers and verified organizations on March 7, 2024 (opens in a new tab).

To read or keep one Article without writing code, paste its link into the free X to Markdown Converter: it returns the title, author, date and body as Markdown you can copy or download. The rest of this guide reads Articles in code, one at a time or by the thousand.

Writing one is still a paid feature. X's Help Center (opens in a new tab) lists Premium and Premium+, the Plus, Premium, Super and Ultra plans of The X Subscription, and Premium Business and Organizations. Reading is open: anyone can read a public Article on x.com, where it sits in the author's Articles tab, unless the author kept it for subscribers.

Every Article has two links, and the difference decides whether your code works:

• The post. Publishing creates an ordinary post at x.com/<handle>/status/<post ID>. It shows in timelines, collects replies and likes, and its text is only a t.co link.
• The Article. The body lives at x.com/i/article/<Article ID>, under a different number. APIs look the Article up through the post, so keep the post link.

#Can the official X API read X Articles?

Yes: the official X API returns an Article's text and entities when a post lookup asks for the article field, as in GET /2/tweets?ids=<post IDs>&tweet.fields=article. Without that field, the post's text holds only the t.co link.

X staff confirmed the route on the developer forum on September 8, 2026 (opens in a new tab): article for Articles, note_tweet for long posts over 280 characters, on single and multi-ID lookups alike. X's own reference (opens in a new tab) types the article object without naming its sub-fields, so check a real response before you write a parser for it.

Each Article bills as a post read, $0.005, which is $5.00 per 1,000 Articles on X's pay-per-use rate card (opens in a new tab). From November 22, 2026, objects that come back through expansions bill too (X's notice of October 23 (opens in a new tab)): the author's profile adds $0.010 and a cover image $0.005, so an Article with its author costs $15.00 per 1,000. Every read needs a developer account, prepaid credits and a bearer token, and pay-per-use stops at 3 million post reads a month.

Writing goes through two other endpoints. POST /2/articles/draft (opens in a new tab) creates a draft from a title and a DraftJS body, and POST /2/articles/{article_id}/publish puts it live; both need the author's OAuth user token.

#Get an X Article's full text with Sorsa API

For reading X Articles in code, use Sorsa API, a Twitter (X) API and scraper: POST /article takes the post link or ID and returns the full text, preview, cover image, publication date, likes, reposts, replies, quotes, bookmarks, views and the author's full profile in one request. Each Article is one request, from $1.40 per 1,000, at 20 requests per second on every plan, with one API key and no developer account.

1. Get a key. Sign up and copy the API key from your dashboard. The 100 free requests read 100 Articles, whatever their length.

2. Copy the post link. Take x.com/<handle>/status/<ID> of the post that shares the Article, or the ID alone. Not sure which link you have? Paste it here:

   Paste an X link or an ID

   Post link Article link

   Post link: send this one to POST /article.

   Post ID

   2112908047021486497

   Posted, read from the ID

   Oct 21, 2026, 14:05:09 UTC

   Request body for POST /article Copy curl

   {"tweet_link": "https://x.com/harbor_essays_weekly/status/2112908047021486497"}

   Post links go to POST /article as they are; an x.com/i/article/ link holds the Article's own ID, which the endpoint doesn't take.

3. Send the request. POST the post link or its ID as tweet_link to POST /article (opens in a new tab), with your key in the ApiKey header.

   curl -X POST "https://api.sorsa.io/v3/article" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"tweet_link": "2112908047021486497"}'
   

4. Read the response. The body is in full_text, the counters sit beside it, and author is the same full profile the user endpoints return.

   {
     "full_text": "Seven years ago we met in a laundromat...",
     "preview_text": "Seven years ago we met in a laundromat",
     "cover_image_url": "https://pbs.twimg.com/media/HbX2k9WaYAAq3Lm.jpg",
     "published_at": "2026-10-21T14:05:09Z",
     "views_count": 88214,
     "likes_count": 3207,
     "retweet_count": 410,
     "reply_count": 96,
     "quote_count": 58,
     "bookmark_count": 1120,
     "author": {
       "id": "1116267827557806085",
       "username": "harbor_essays_weekly",
       "display_name": "Harbor Essays",
       "description": "Long reads about small clubs and libraries.",
       "followers_count": 48210,
       "followings_count": 312,
       "tweets_count": 2875,
       "created_at": "2019-04-11T09:12:44Z",
       "verified": true,
       "protected": false
     }
   }
   

   Show full response

The same call in Python and Node.js, ready for a loop over many links:

import requests

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


def get_article(link):
    r = requests.post(f"{API}/article", headers=HEADERS,
                      json={"tweet_link": link}, timeout=30)
    if r.status_code == 404:
        return None  # the post doesn't share an Article
    r.raise_for_status()
    return r.json()


art = get_article(
    "https://x.com/harbor_essays_weekly/status/2112908047021486497")
words = len(art["full_text"].split())
print(art["author"]["username"], art["published_at"])
print(f"{words:,} words, {art['views_count']:,} views")

const API = "https://api.sorsa.io/v3";

async function getArticle(link) {
  const r = await fetch(`${API}/article`, {
    method: "POST",
    headers: {
      ApiKey: "YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ tweet_link: link }),
  });
  if (r.status === 404) return null; // not an Article
  if (!r.ok) throw new Error(`HTTP ${r.status}`);
  return r.json();
}

const art = await getArticle(
  "https://x.com/harbor_essays_weekly/status/2112908047021486497");
console.log(art.author.username, art.views_count);

A 404 usually means the post doesn't share an Article: read it with POST /tweet-info instead. A 403 means the key is missing, wrong or out of requests, and a 429 means more than 20 requests in one second, so wait a second and retry. Failed requests are never charged.

#What the /article response holds

The POST /article response has eleven fields: the body twice over (all of it and its opening), the cover, the publish time, six counters and the author. Each one below comes from the live API reference.

• full_text

  What it holds

  The whole body as plain text, however long

• preview_text

  What it holds

  The opening lines X shows before "Read more"

• cover_image_url

  What it holds

  Link to the cover image, null when the author set none

• published_at

  What it holds

  When the Article went live, in ISO 8601

• views_count

  What it holds

  Views (impressions)

• likes_count, retweet_count, reply_count, quote_count, bookmark_count

  What it holds

  Likes, reposts, replies, quotes and bookmarks

• author

  What it holds

  The author's full profile: ID, handle, name, bio, followers, following, post count, join date, verification

The counters are current at the moment of the request, so a second call a week later shows how the Article kept spreading. To read the replies under an Article, see how to see comments on X: they hang on the sharing post like any other.

Good to know

Views come back as views_count on an Article and as view_count on a tweet. If Articles and tweets land in one table, rename that key when you load the data, or one of the two columns stays empty.

#Find every Article an account published

To list an account's Articles, search its posts for links to x.com/i/article with X's url: operator, then read each match with POST /article. The search is POST /search-tweets (opens in a new tab): about 20 posts per request, and next_cursor points to the next page until it comes back empty.

import requests

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


def article_posts(handle):
    query = f"from:{handle} url:x.com/i/article"
    body = {"query": query, "order": "latest"}
    while True:
        r = requests.post(f"{API}/search-tweets", headers=HEADERS,
                          json=body, timeout=30)
        r.raise_for_status()
        page = r.json()
        for tweet in page.get("tweets", []):
            yield tweet["id"]
        if not page.get("next_cursor"):
            break
        body["next_cursor"] = page["next_cursor"]


for post_id in article_posts("harbor_essays_weekly"):
    r = requests.post(f"{API}/article", headers=HEADERS,
                      json={"tweet_link": post_id}, timeout=30)
    if r.ok:
        print(post_id, r.json()["views_count"])

Add since:2026-01-01 or min_faves:100 to the query to keep only recent or popular Articles; the full list is in our guide to Twitter search operators. Swap from: for a keyword and the same query finds Articles by anyone on that topic. A match can also be the account sharing someone else's Article: compare author.username in each POST /article response with the handle to keep only its own.

#Save an X Article as Markdown

For a single Article, the converter linked at the top of this guide is the fastest route. For a batch, write each POST /article response to its own Markdown file, with the facts that matter in a header:

from pathlib import Path


def save_markdown(art, post_link, folder="articles"):
    a = art["author"]
    head = [
        f"# @{a['username']}, {art['published_at'][:10]}",
        "",
        f"Source: {post_link}",
        f"Author: {a['display_name']} ({a['followers_count']:,} followers)",
        f"Views: {art['views_count']:,}  Likes: {art['likes_count']:,}",
        "",
    ]
    if art.get("cover_image_url"):
        head += [f"![cover]({art['cover_image_url']})", ""]
    path = Path(folder) / f"{post_link.rstrip('/').split('/')[-1]}.md"
    path.parent.mkdir(exist_ok=True)
    path.write_text("\n".join(head) + art["full_text"] + "\n",
                    encoding="utf-8")
    return path

Markdown opens in any editor, prints cleanly and goes straight into ChatGPT, Claude or a search index, for summaries, research notes or a dataset for a language model. Images stay as links to X's servers, so download the cover if you need a permanent copy.

Each file is named after the post ID, so running the job again updates a file instead of adding a copy. The header keeps the source link, the author and the counters next to the text, which is what you need to cite an Article or compare two of them later. To print one Article, open its file in any Markdown editor and print from there: the layout stays plain and readable on paper.

#What reading X Articles costs per 1,000

Sorsa API reads 1,000 X Articles from $1.40 with the author's profile in the same response; the official X API charges $5.00 for the posts alone and $15.00 with author profiles from November 22, 2026.

On Sorsa API an Article costs one request whatever its length, so a 6,000-word essay and a 500-word note cost the same. At 20 requests per second on one key, the time grows in step with the count:

• 1K

  Sorsa API, from

  $1.40

  Official X API, posts only

  $5.00

  Official X API, with author (from Nov 22, 2026)

  $15.00

  Time on Sorsa API at 20 requests per second

  about 1 minute

• 10K

  Sorsa API, from

  $14

  Official X API, posts only

  $50

  Official X API, with author (from Nov 22, 2026)

  $150

  Time on Sorsa API at 20 requests per second

  about 8 minutes

• 100K

  Sorsa API, from

  $140

  Official X API, posts only

  $500

  Official X API, with author (from Nov 22, 2026)

  $1,500

  Time on Sorsa API at 20 requests per second

  about 1.4 hours

• 1M

  Sorsa API, from

  $1,400

  Official X API, posts only

  $5,000

  Official X API, with author (from Nov 22, 2026)

  $15,000

  Time on Sorsa API at 20 requests per second

  about 14 hours

Finding the Articles adds search requests: one per page of about 20 posts. Pulling an account's Articles once a week costs a few requests per account, and the analytics around them are covered in the Twitter analytics API guide.

#Read your first X Articles today

Pick one Article, copy the link of the post that shares it, and send it to POST /article: the text, the counters and the author come back as one JSON object. Sorsa API reads X Articles from $1.40 per 1,000 with the author included, at 20 requests per second, with no developer account and no risk to your own X account, and your 100 free requests cover the first 100 Articles.

#FAQ