Scraper de imagens do Twitter: baixe todas as imagens

#Como funciona um scraper de imagens do Twitter

Todo scraper de imagens do Twitter faz as mesmas três coisas, seja qual for a base em que roda. Para um único post você não precisa de nenhuma delas: cole o link dele no Downloader de mídia, gratuito, e salve cada foto em tamanho original. Para centenas ou milhares de imagens, o trabalho é assim:

1. Encontre os posts que têm fotos. O operador de busca filter:images do X mantém só os posts com pelo menos uma imagem, de uma conta com from: ou sobre qualquer tema.

2. Leia o link de cada foto. Toda imagem fica no servidor de mídia do X, em um link como https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz.jpg.

3. Baixe o original. Peça esse link com ?format=jpg&name=orig; sem isso, o X envia uma cópia que cabe em 1.200 pixels.

As ferramentas diferem no passo 1, na origem dos posts. O x.com mostra a um visitante sem login posts avulsos e alguns dos posts mais novos de um perfil, e manda a busca para a página de login. Extensões de navegador, downloaders de desktop e ferramentas de linha de comando, por isso, leem o X por meio de uma conta logada. A documentação delas mesmas diz isso: um downloader em lote muito usado pede o seu cookie auth_token e avisa que a conta pode ser suspensa.

Só uma API alcança as imagens de uma conta inteira: a API oficial do X, com uma conta de desenvolvedor e OAuth, ou uma API de dados do Twitter/X com uma única chave.

O guia sobre como fazer web scraping do Twitter cobre todas as rotas e o que as quebra, e o comparativo dos melhores scrapers de Twitter precifica as ferramentas uma a uma.

#Baixe todas as imagens de uma conta do X

A Sorsa API, uma API e scraper do Twitter (X), devolve os posts com imagem de uma conta como JSON, com o link de cada foto dentro, cerca de 20 posts por requisição e desde 2006. Quatro passos levam de um handle a uma pasta de arquivos originais.

1. Obtenha uma chave. Cadastre-se e copie a chave de API do seu painel. As primeiras 100 requisições são grátis, sem cartão.

2. Busque os posts com imagem da conta. Envie from: mais filter:images para POST /search-tweets (abre em uma nova aba), com order definido como latest para trazer os mais novos primeiro.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "from:northfield_photo_lab filter:images",
          "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "1984213377309245441",
         "created_at": "2026-10-30T14:12:09Z",
         "full_text": "Fog over the north ridge this morning.",
         "likes_count": 412,
         "entities": [
           {
             "type": "photo",
             "link": "https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz.jpg",
             "preview": "https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz.jpg"
           },
           {
             "type": "photo",
             "link": "https://pbs.twimg.com/media/G4kQ2vZaQAEw9Lp.jpg",
             "preview": "https://pbs.twimg.com/media/G4kQ2vZaQAEw9Lp.jpg"
           }
         ],
         "user": {
           "username": "northfield_photo_lab",
           "display_name": "Northfield Photo Lab",
           "media_count": 1840
         }
       }
     ],
     "next_cursor": "DAADDAABCgABG8vZ0Qm__-oKAAIbuv3MBVvA0AgAAwAAAAIAAA"
   }
   

   Ver resposta completa

3. Siga o cursor. Um cursor é um token que marca onde a próxima página começa: envie next_cursor de volta no corpo da requisição seguinte até ele voltar vazio.

4. Salve cada foto em tamanho original. O script mantém só as entidades photo, reescreve cada link para name=orig e nomeia os arquivos <post id>_<n>.jpg. Ele registra cada arquivo em images.csv e guarda o cursor depois de cada página, então uma execução interrompida continua de onde parou.

   import csv
   import os
   import sys
   import time
   from urllib.parse import parse_qs, urlparse
   
   import requests
   
   API = "https://api.sorsa.io/v3/search-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def orig(url):
       """Rewrite a pbs.twimg.com image link to its original size."""
       u = urlparse(url)
       path = u.path
       fmt = parse_qs(u.query).get("format", ["jpg"])[0]
       if "." in path.rsplit("/", 1)[-1]:
           path, fmt = path.rsplit(".", 1)
       fmt = fmt.split(":")[0]
       return f"https://pbs.twimg.com{path}?format={fmt}&name=orig", fmt
   
   
   def photo_urls(tweet):
       """Original-size links of every photo in a post."""
       for e in tweet.get("entities") or []:
           if e.get("type") != "photo":
               continue
           for link in (e.get("link"), e.get("preview")):
               if link and "pbs.twimg.com/media/" in link:
                   yield orig(link)
                   break
   
   
   def post(body):
       while True:
           r = requests.post(API, headers=HEADERS, json=body, timeout=60)
           if r.status_code == 429:  # over 20 requests a second: wait
               time.sleep(1)
               continue
           r.raise_for_status()  # 403: no key, or no requests left
           return r.json()
   
   
   def download(query, folder):
       os.makedirs(folder, exist_ok=True)
       state = os.path.join(folder, "cursor.txt")
       body = {"query": query, "order": "latest"}
       if os.path.exists(state):  # resume a stopped run
           body["next_cursor"] = open(state).read().strip()
       log_path = os.path.join(folder, "images.csv")
       with open(log_path, "a", newline="", encoding="utf-8") as f:
           log = csv.writer(f)
           while True:
               page = post(body)
               for t in page.get("tweets", []):
                   for n, (url, fmt) in enumerate(photo_urls(t), 1):
                       path = os.path.join(folder, f"{t['id']}_{n}.{fmt}")
                       if os.path.exists(path):
                           continue
                       img = requests.get(url, timeout=60)
                       img.raise_for_status()
                       with open(path, "wb") as out:
                           out.write(img.content)
                       log.writerow([t["id"], t["created_at"], url, path])
               cursor = page.get("next_cursor")
               if not cursor:
                   break
               body["next_cursor"] = cursor
               with open(state, "w") as s:
                   s.write(cursor)
       if os.path.exists(state):
           os.remove(state)
   
   
   if __name__ == "__main__":
       download(sys.argv[1], sys.argv[2])
   

   import fs from "node:fs";
   import path from "node:path";
   
   const API = "https://api.sorsa.io/v3/search-tweets";
   const HEADERS = {
     ApiKey: "YOUR_API_KEY",
     "Content-Type": "application/json",
   };
   
   // Rewrite a pbs.twimg.com image link to its original size.
   function orig(link) {
     const u = new URL(link);
     let p = u.pathname;
     let fmt = u.searchParams.get("format") || "jpg";
     if (p.split("/").pop().includes(".")) {
       fmt = p.slice(p.lastIndexOf(".") + 1);
       p = p.slice(0, p.lastIndexOf("."));
     }
     fmt = fmt.split(":")[0];
     return [`https://pbs.twimg.com${p}?format=${fmt}&name=orig`, fmt];
   }
   
   function* photoUrls(tweet) {
     for (const e of tweet.entities ?? []) {
       if (e.type !== "photo") continue;
       const link = [e.link, e.preview]
         .find((l) => l?.includes("pbs.twimg.com/media/"));
       if (link) yield orig(link);
     }
   }
   
   async function post(body) {
     for (;;) {
       const r = await fetch(API, {
         method: "POST", headers: HEADERS, body: JSON.stringify(body),
       });
       if (r.status === 429) {          // over 20 requests a second: wait
         await new Promise((ok) => setTimeout(ok, 1000));
         continue;
       }
       if (!r.ok) throw new Error(`HTTP ${r.status}`); // 403: key or quota
       return r.json();
     }
   }
   
   async function download(query, folder) {
     fs.mkdirSync(folder, { recursive: true });
     const body = { query, order: "latest" };
     const log = path.join(folder, "images.csv");
     for (;;) {
       const page = await post(body);
       for (const t of page.tweets ?? []) {
         let n = 0;
         for (const [url, fmt] of photoUrls(t)) {
           const file = path.join(folder, `${t.id}_${++n}.${fmt}`);
           if (fs.existsSync(file)) continue;
           const img = await fetch(url);
           if (!img.ok) throw new Error(`HTTP ${img.status} for ${url}`);
           fs.writeFileSync(file, Buffer.from(await img.arrayBuffer()));
           fs.appendFileSync(log, `${t.id},${t.created_at},${url},${file}\n`);
         }
       }
       if (!page.next_cursor) break;
       body.next_cursor = page.next_cursor;
     }
   }
   
   await download(process.argv[2], process.argv[3]);
   

Rode-o com uma busca e um nome de pasta: python twitter_images.py "from:northfield_photo_lab filter:images" northfield_photo_lab. Uma resposta 403 significa que a chave está ausente ou sem requisições; um 429 significa mais de 20 requisições em um segundo, e o script espera um segundo e tenta de novo. Arquivos que já estão no disco são pulados, então rodar o mesmo comando de novo só acrescenta as imagens novas.

Bom saber

Um quote ou um retweet carrega fotos de outra pessoa: elas ficam em quoted_status.entities e retweeted_status.entities, e o script as deixa de fora. Acrescente essas duas listas a photo_urls para mantê-las. Para dimensionar o trabalho antes, GET /info (abre em uma nova aba) devolve o media_count da conta, as fotos e vídeos que ela postou.

Para percorrer a timeline da conta post a post em vez de buscá-la, envie o handle para POST /user-tweets (abre em uma nova aba). Ele devolve os mesmos objetos de tweet, 20 por requisição, então photo_urls lê as imagens deles sem mudanças; posts só de texto vêm junto, então o trabalho leva mais requisições.

#Faça scraping das imagens de uma hashtag ou de uma busca

O mesmo script coleta as imagens de qualquer tema: só a consulta muda. filter:images se combina com todos os operadores de busca do X, e a busca alcança o passado até 2006.

• Uma hashtag

  Consulta

  #nightphotography filter:images

• Uma palavra-chave em um mês

  Consulta

  aurora filter:images since:2026-10-01 until:2026-11-01

• Só imagens populares

  Consulta

  #interiordesign filter:images min_faves:500

• Uma conta sem as respostas dela

  Consulta

  from:northfield_photo_lab filter:images -filter:replies

• Várias contas ao mesmo tempo

  Consulta

  (from:northfield_photo_lab OR from:harborline_studio_co) filter:images

Para um tema grande, rode uma janela de datas por mês, cada uma em sua própria pasta. Cada execução fica curta, uma que falhou é fácil de repetir, e as janelas rodam lado a lado em uma única chave, até 20 requisições por segundo em todos os planos. Defina order como popular para os melhores posts do X primeiro ou latest para os mais novos. Todos os operadores, com exemplos, estão no guia de operadores de busca do Twitter.

As imagens de uma hashtag mudam conforme as pessoas postam, então um trabalho de monitoramento reexecuta a janela mais recente em intervalos. Como o script pula os arquivos que já tem e registra só os novos, cada nova execução acrescenta apenas as imagens postadas desde a anterior.

#Obtenha cada imagem em tamanho original

O X guarda cada upload inteiro, mas serve cópias menores, e a cópia que você recebe depende apenas do valor de name no link. Em 2 de novembro de 2026 pedimos quatro imagens públicas em todos os tamanhos que o X serve e medimos o que voltou; a escada abaixo é de uma foto postada no fim de outubro de 2026.

• O link simples é a cópia medium. Um link pbs.twimg.com sem name devolve uma imagem que cabe em 1.200 pixels.
• large para em 2.048 pixels e 4096x4096 em 4.096. Um upload menor que isso volta no próprio tamanho.
• name=orig devolve o próprio upload. Para a foto acima, isso foram 8.000 × 4.501 pixels, 44 vezes os pixels do link simples.
• format=png não acrescenta detalhe. Ele recodifica um upload JPG em um PNG várias vezes maior, e format=png&name=orig devolve 404 para um JPG, então mantenha o formato que o link já tem.

Baixar de pbs.twimg.com é uma requisição HTTP comum, sem chave, então os arquivos em si não gastam requisições da API: só encontrar os posts gasta.

#Baixe imagens em massa sem código

Sem código, o trabalho se divide em dois: exportar os links das imagens e depois baixar os arquivos.

1. Exporte os links dos posts recentes. A ferramenta Exportar tweets, gratuita, salva os posts mais recentes de uma conta em CSV, Excel ou JSON com uma coluna media_urls; ative Somente posts com mídia.

2. Exporte uma conta inteira ou uma busca. No playground da API, rode POST /search-tweets com sua chave e uma consulta como from:northfield_photo_lab filter:images; ele segue o cursor por você e exporta cada página para CSV ou JSON.

3. Transforme os links em originais. Cole os links das imagens no conversor abaixo e copie os links em tamanho original que ele devolve.

4. Baixe a lista. Carregue os links em qualquer gerenciador de downloads que aceite uma lista de URLs, e ele salva os arquivos de uma vez.

   Links de imagens do X https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz.jpg https://pbs.twimg.com/media/G4kQ2vZaQAEw9Lp?format=jpg&name=small https://pbs.twimg.com/media/G4jx81-WgAA0nHc.png:large

   Um por linha, ou cole uma coluna inteira de CSV.

   Links no tamanho original 3 links

   https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz?format=jpg&name=orig https://pbs.twimg.com/media/G4kQ2vZaQAEw9Lp?format=jpg&name=orig https://pbs.twimg.com/media/G4jx81-WgAA0nHc?format=png&name=orig

   Copiar links

   Cole quantos links do pbs.twimg.com quiser, um por linha ou direto de uma coluna de CSV; nada sai do seu navegador.

#Quanto custa baixar imagens em massa

Na Sorsa API, os posts com imagem custam a partir de US$ 0,07 por 1.000, porque uma página de busca com cerca de 20 posts é uma requisição, não importa quantas fotos ela tenha. Na API oficial do X, os links de imagem só vêm pela expansão de mídia. A partir de 22 de novembro de 2026, o X cobra cada imagem expandida (abre em uma nova aba) a US$ 0,005 além da leitura do post de US$ 0,005: US$ 10,00 por 1.000 posts com uma imagem, US$ 25,00 quando cada um tem quatro.

Lado a lado, as formas de obter os posts diferem no que exigem de você tanto quanto no preço.

• Sorsa API

  O que exige

  Uma chave de API

  Custo por 1.000 posts com imagem

  a partir de US$ 0,07

• API oficial do X

  O que exige

  Conta de desenvolvedor e OAuth

  Custo por 1.000 posts com imagem

  US$ 10,00 a partir de 22 de nov. de 2026 (post e uma imagem)

• Extensões e downloaders

  O que exige

  Seu login do X ou o cookie da sua sessão

  Custo por 1.000 posts com imagem

  Grátis ou por assinatura, com a conta em risco

O pagamento por uso (abre em uma nova aba) da API oficial do X também para em 3 milhões de leituras de posts por ciclo de cobrança; acima disso, o X vende só contratos Enterprise. Na Sorsa API, as 100 requisições grátis cobrem cerca de 2.000 posts com imagem, requisições com falha nunca são cobradas, e a tarifa do plano por 1.000 requisições vale para todos os endpoints.

O tempo decorre do limite de requisições, 20 por segundo por chave em todos os planos. 1 milhão de posts com imagem levam 50 mil requisições, cerca de 42 minutos com as janelas de datas rodando lado a lado; os arquivos de imagem então são baixados direto dos servidores do X, na velocidade da sua conexão.

#Obtenha as imagens de posts específicos

Para obter as imagens de posts que você já tem, envie os links ou IDs deles para POST /tweet-info-bulk (abre em uma nova aba): até 100 posts por requisição, a partir de US$ 0,014 por 1.000, com a mesma lista entities que a busca devolve.

curl -X POST "https://api.sorsa.io/v3/tweet-info-bulk" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tweet_links": [
        "https://x.com/northfield_photo_lab/status/1984213377309245441",
        "1983850021164118016"]}'

Um único post vai para POST /tweet-info (abre em uma nova aba) com tweet_link. Passe o link de cada foto pela mesma função orig e você tem os arquivos em tamanho original. Na API oficial do X, a mesma consulta exige um bearer token mais expansions=attachments.media_keys e media.fields=url, e a partir de 22 de novembro cada imagem na resposta acrescenta US$ 0,005.

Vídeos e GIFs voltam na mesma lista entities com o próprio type. Os arquivos MP4 e as variantes de qualidade deles exigem mais um passo, coberto no guia para baixar mídia do Twitter por API; para exportações de texto completo com uma coluna de mídia, veja como baixar todos os tweets de um usuário.

#Comece o seu primeiro download de imagens

Para baixar todas as imagens de uma conta do X ou de uma busca em tamanho original, use a Sorsa API: cerca de 20 posts com imagem por requisição, a partir de US$ 0,07 por 1.000, sem risco para a sua conta do X. Copie o script, coloque sua chave, e suas 100 requisições grátis baixam os primeiros 2.000 posts com imagem.

#Perguntas frequentes