Twitter Media Scraper API: Pull Photo and Video URLs

The endpoint that reads an account's Media tab

This route returns what you see on an account's Media tab, in order, a page at a time. Give it one identifier, either username or user_id, and raise count above its default of 20 when you are crawling. The parameter table is generated from our OpenAPI document.

Sample response from GET /twitter/user/media

Each item is a normal tweet object with its attachments under extended_entities.media. The tab occasionally surfaces a link or card post with no attachment, so guard on that field before you read it. That single check is the difference between a crawl that finishes and one that throws on page 40.

{
  "tweets": [
    {
      "id": "1759987654321000111",
      "text": "A new image of the Pillars of Creation.",
      "extended_entities": {
        "media": [
          {
            "type": "photo",
            "media_url_https": "https://pbs.twimg.com/media/abc.jpg",
            "url": "https://t.co/abc123",
            "ext_alt_text": "The Pillars of Creation imaged by JWST."
          }
        ]
      },
      "author": {
        "id": "11348282",
        "username": "nasa"
      }
    }
  ],
  "next_cursor": "DAABCgABF..."
}

Quickstart: pull an account's media as JSON

This is a read, so a Bearer key is all you need. There is no X account to connect, no cookie to refresh and no browser to keep alive. The request below fetches one page, and a loop over next_cursor turns it into a full crawl.

1. Create a key at signup. The key works straight away.
2. Send the request below with a handle in username.
3. Read next_cursor from the response and repeat with cursor set to it until no cursor comes back.
4. Guard on extended_entities before reading media, then download each media_url_https you want to keep.

curl "https://api.twitterapis.com/twitter/user/media?username=nasa" \
  -H "Authorization: Bearer $TWITTERAPIS_KEY"

import os
import requests

resp = requests.get(
    "https://api.twitterapis.com/twitter/user/media",
    headers={"Authorization": f"Bearer {os.environ['TWITTERAPIS_KEY']}"},
    params={"username": "nasa"},
)
resp.raise_for_status()
data = resp.json()
print(data)

const url = new URL("https://api.twitterapis.com/twitter/user/media");
url.search = new URLSearchParams({ username: "nasa" }).toString();
const resp = await fetch(url, {
  headers: { Authorization: `Bearer ${process.env.TWITTERAPIS_KEY}` },
});
const data = await resp.json();
console.log(data);

What a Twitter media scrape costs per 1,000 posts

You pay per call, so the price per post depends on how full each page is. The table gives you three honest readings: a full page at the maximum count, a page at the default count, and the fill we actually measure across paying timeline traffic, which already includes empty calls.

Measured over October 22 to 28, 2026 (UTC) on paying calls only. The media route is not sampled on its own, so the last row is the nearest timeline read rather than this endpoint's own figure. The signup credit of $0.50 covers 625 calls.

Ways to scrape Twitter media compared

Most media scrapers on the first page of Google are browser extensions, open-source libraries or general scraping actors. They all work for a one-off, and they differ in what they ask from you once the job runs every day. This is how the common routes stack up.

Photos, videos and GIFs in one feed

The Media tab mixes every attachment type, so your crawler should branch on type first. Photos are the simple case: media_url_https is the file. Add ?name=orig to a photo URL to request the largest size X stores, which is what you want for an archive and what you do not want for a thumbnail grid.

Videos and GIFs need one more step, because media_url_https is only the poster frame on those. The playable files sit in the video variants of the same media entry, and our answer on downloading a video from a tweet shows how to pick the right one. To get image URLs out of tweets you already hold, the guide to extracting image URLs covers that path.

Who reads the Media tab through an API

A media crawl is a small part of many different products, and the shared requirement is that it runs unattended. A script that needs someone's laptop open is fine once, and it stops being fine the day the job goes on a schedule. These are the jobs we see it used for.

• Brand and rights monitoring. Collect what an account has published, then compare images against your own assets.
• Dataset building. Pair each image with its caption and alt text for labelled training data. Read our notes on using the API for AI training data first.
• Creator tools. Show a creator their own media history, with engagement from a tweet lookup beside each item.
• Archiving. Keep a copy of a public account's images before an account closes, one cursor page at a time.

How to crawl a large account without surprises

Store the cursor after every page, so a crash resumes where it stopped instead of paying for the same pages twice. Download files in a separate step from the API crawl, because the two fail for different reasons and you want to retry them independently. Files from pbs.twimg.com do not count against your API balance at all.

One flat ceiling of 600 requests per minute per key applies, which is far more than a single account needs. If you crawl many accounts, keep concurrency under the limit of 20 per key and back off on a 429. For text as well as media, the timeline API gives you every post rather than only those with attachments.

A complete crawl in about twenty lines

The loop below walks one account's Media tab from newest to oldest. It requests the maximum page size, skips any item with no attachment, writes out each media URL, and stops when no cursor comes back. Saving the cursor between runs is left out for clarity, and it is the first thing to add for an account with a long history.

Run it for a test account first and look at the output before you schedule anything. Accounts differ a lot in how much media they post, and a quick look tells you whether you need the full history or only the last few pages. For most monitoring jobs, a daily run that stops at the first post you have already seen is both cheaper and simpler than a full crawl.

import os
import requests

API = "https://api.twitterapis.com/twitter/user/media"
HEADERS = {"Authorization": f"Bearer {os.environ['TWITTERAPIS_KEY']}"}

params = {"username": "nasa", "count": 100}

while True:
    resp = requests.get(API, headers=HEADERS, params=params, timeout=30)
    resp.raise_for_status()
    page = resp.json()

    for tweet in page["tweets"]:
        entities = tweet.get("extended_entities")
        if not entities:
            continue
        for item in entities["media"]:
            print(tweet["id"], item["type"], item["media_url_https"])

    if not page.get("next_cursor"):
        break
    params["cursor"] = page["next_cursor"]

Choosing between the media, timeline and scraper routes

Several routes can return an account's posts, and the right one depends on what you want to keep. The Media tab is the efficient choice when you only care about attachments, because a timeline crawl spends calls on text posts you would throw away. Reach for one of the others when your job needs more than the images themselves.

If you are still comparing vendors rather than routes, our ranking of the best Twitter scraping APIs prices the main options side by side, and the answer on whether you need proxies to scrape Twitter explains why an API removes that problem. All of them return the same JSON shape for tweets.

• Every post from an account. Use the timeline API, which includes text-only posts and replies.
• Keyword or hashtag collection. Use the search API, which works across all accounts rather than one.
• General tweet collection. Start with the Twitter scraper API page, which covers the broader job.
• Profile data. Follower counts and bios come from the user API, one call per account.

Rights, storage and what you may do with the files

Reading a public image and owning it are different things. The author keeps the copyright in what they post, so a crawl gives you access to the file and not a licence to republish it. Monitoring, research and internal analysis sit in a very different place from reposting someone's photo in your own campaign, and you should get advice on anything commercial. Our answer on whether it is legal to scrape Twitter lays out the main questions.

If you keep files, store the tweet ID and author beside each one so you can honour a takedown later. Hotlinking pbs.twimg.com URLs in a product is fragile, because a file can disappear when the post is deleted, so copy what you need into your own storage and record where it came from.

Reading media from one post instead of a whole account

When you already know the post, skip the crawl. A tweet by ID lookup returns the attached media on that single post, which is the cheaper route for a link a user pasted. Use the Media tab when the account is the unit of work, and use a lookup when the post is.

Pull media from an AI agent

Ask an agent what an account has been posting visually and it can read the Media tab directly through the tool below. The tool takes the same username, user_id, cursor and count inputs as the REST call, and the MCP page has the setup for each client.

• twitter_user_media calls GET /twitter/user/media

npx -y @twitterapis/mcp@latest