API de vídeo do Twitter: pegue a URL do MP4 de qualquer vídeo do X

#Como o X guarda um vídeo: versões e bitrates

O X nunca serve o arquivo que o autor enviou. Ele recodifica cada vídeo em uma escada de arquivos MP4, um por tamanho, mais uma playlist HLS (um índice .m3u8 que os players de vídeo usam para trocar de tamanho durante a reprodução). Cada MP4 é um arquivo completo com som, então qualquer um deles baixa e toca sozinho. Para um único post, o Baixador de vídeos do Twitter gratuito salva o arquivo a partir de um link colado; este guia é para obter os arquivos em código.

Em 2 de novembro de 2026, lemos as listas de versões de 23 posts públicos de 2017 a 2026 e medimos os 72 arquivos MP4 que o X serviu para eles. O bitrate que o X lista para cada arquivo é um teto, e os arquivos reais ficam de três a cinco vezes mais enxutos:

• 270p

  Tamanho do quadro, pixels

  480 × 270

  Bitrate que o X lista

  256 kbps

  Bitrate médio real

  cerca de 91 kbps

• 360p

  Tamanho do quadro, pixels

  640 × 360

  Bitrate que o X lista

  832 kbps

  Bitrate médio real

  cerca de 233 kbps

• 720p

  Tamanho do quadro, pixels

  1280 × 720

  Bitrate que o X lista

  2.176 kbps

  Bitrate médio real

  cerca de 626 kbps

• 1080p

  Tamanho do quadro, pixels

  1920 × 1080

  Bitrate que o X lista

  10,4 Mbps

  Bitrate médio real

  cerca de 2.172 kbps

O que as medições mostram:

• O maior bitrate é o melhor arquivo. Ordene as entradas MP4 por bitrate e pegue a do topo. A entrada da playlist, do tipo application/x-mpegURL, não traz bitrate e é um índice, não um arquivo.
• O tamanho depende do formato do quadro. Vídeos verticais recebem de 320 × 568 até 1080 × 1920, os quadrados de 320 × 320 até 1080 × 1080, e um envio de 1936 × 1548 recebeu um quinto arquivo a 25,1 Mbps.
• Nem todo envio em 1080p recebe um arquivo de 1080p. De sete envios de 1920 × 1080 de 2025 e 2026, dois pararam em 720p, e a maioria dos posts anteriores a 2022 tem 720p como teto.
• A playlist separa o som da imagem. Os fluxos de vídeo dela são mudos; o áudio vem em faixas separadas a 32, 64 e 128 kbps, com legendas em alguns vídeos.

Um GIF é mais simples: o X guarda um único MP4 mudo, em loop, no tamanho do próprio GIF, sem outras versões e sem playlist.

#Pegue a URL do MP4 de um vídeo com a Sorsa API

A Sorsa API, uma API e scraper do Twitter (X), devolve cada post com a mídia anexada: cada vídeo, GIF e foto é uma entrada na lista entities do post, com um type, um link direto e uma imagem preview. Uma chave de API em um header substitui a conta de desenvolvedor e o OAuth que a API oficial do X exige.

1. Pegue 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. Envie o link do post. O POST /tweet-info (abre em uma nova aba) aceita a URL de um post ou um ID puro em tweet_link.

   curl -X POST "https://api.sorsa.io/v3/tweet-info" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"tweet_link":
          "https://x.com/northfield_video_lab/status/1984519203377641472"}'
   

   {
     "id": "1984519203377641472",
     "created_at": "2026-10-31T16:04:11Z",
     "full_text": "First ride on the new gravel loop.",
     "entities": [
       {
         "type": "video",
         "link": "https://video.twimg.com/amplify_video/1984519110025023488/vid/avc1/480x270/Qm3vTb8xLwK2pRfA.mp4?tag=21",
         "preview": "https://pbs.twimg.com/amplify_video_thumb/1984519110025023488/img/Hx2LkP9aQwErT0bn.jpg"
       }
     ],
     "user": {
       "username": "northfield_video_lab",
       "display_name": "Northfield Video Lab",
       "media_count": 214
     }
   }
   

   Ver resposta completa

3. Leia as entradas de vídeo. Fique com as entidades cujo type é video e cujo link está em video.twimg.com. Um caminho /tweet_video/ no link marca um GIF.

4. Baixe o arquivo. O MP4 é um arquivo HTTPS comum nos servidores do X: sem chave, sem cookie e sem nenhuma requisição contada.

   import requests
   
   API = "https://api.sorsa.io/v3/tweet-info"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def video_links(post):
       r = requests.post(API, headers=HEADERS,
                         json={"tweet_link": post}, timeout=60)
       r.raise_for_status()  # 403: no key, or no requests left
       tweet = r.json()
       for e in tweet.get("entities") or []:
           if e.get("type") == "video" and "video.twimg.com" in e["link"]:
               yield tweet["id"], e["link"]
   
   
   links = video_links("1984519203377641472")
   for n, (post_id, link) in enumerate(links, 1):
       with open(f"{post_id}_{n}.mp4", "wb") as f:
           f.write(requests.get(link, timeout=120).content)
   

   import fs from "node:fs";
   
   const res = await fetch("https://api.sorsa.io/v3/tweet-info", {
     method: "POST",
     headers: { ApiKey: "YOUR_API_KEY", "Content-Type": "application/json" },
     body: JSON.stringify({ tweet_link: "1984519203377641472" }),
   });
   if (!res.ok) throw new Error(`HTTP ${res.status}`); // 403: key or quota
   const tweet = await res.json();
   
   let n = 0;
   for (const e of tweet.entities ?? []) {
     if (e.type !== "video" || !e.link.includes("video.twimg.com")) continue;
     const file = await fetch(e.link);
     fs.writeFileSync(`${tweet.id}_${++n}.mp4`,
       Buffer.from(await file.arrayBuffer()));
   }
   

O link é um MP4 com som que toca em qualquer lugar. Passamos dois vídeos pelo nosso baixador gratuito, que roda na Sorsa API, em 2 de novembro de 2026, e os dois links eram a versão de 270p do X. Para o de 82 segundos, isso significou 1,1 MB: leve o bastante para pré-visualizações, transcrições, amostragem de quadros e grandes arquivos. O link de um GIF é o seu único arquivo, então ele chega inteiro.

O preview serve também como quadro em tamanho cheio: acrescente ?format=jpg&name=orig a ele (tire antes o .jpg) e o X devolve o quadro no tamanho do próprio envio, 1936 × 1548 pixels em um dos nossos posts de teste. As fotos vêm na mesma lista com type photo; obter cada uma no tamanho original, de um post ou de uma conta inteira, é assunto do guia do scraper de imagens do Twitter.

Para uma lista de posts, envie até 100 links ou IDs em tweet_links ao POST /tweet-info-bulk (abre em uma nova aba). A resposta é {"tweets": [...]} com as mesmas entities em cada post, e o lote inteiro é uma requisição: a partir de US$ 0,014 por 1.000 posts.

#Baixe todos os vídeos de uma conta ou de uma busca

A busca encontra os posts com vídeo para você. O operador de busca filter:native_video do X mantém os posts com um vídeo enviado ao X, e card_name:animated_gif mantém os GIFs. O POST /search-tweets (abre em uma nova aba) devolve cerca de 20 posts correspondentes por requisição, com a busca alcançando 2006.

• Todos os vídeos de uma conta

  Consulta

  from:northfield_video_lab filter:native_video

• Todos os GIFs de uma conta

  Consulta

  from:northfield_video_lab card_name:animated_gif

• Vídeos sobre um tópico em um mês

  Consulta

  "gravel racing" filter:native_video since:2026-10-01 until:2026-11-01

• Só vídeos populares

  Consulta

  #bikepacking filter:native_video min_faves:1000

• Vídeos e links do YouTube

  Consulta

  trail build filter:videos

Todos os operadores, com exemplos, estão no guia de operadores de busca do Twitter. O script abaixo roda uma consulta da primeira página à última.

1. Salve o script. Ele pagina a busca com next_cursor, um token que marca onde começa a próxima página, até o cursor voltar vazio. Grava os vídeos e GIFs de cada post em <post id>_<n>.mp4 e registra cada arquivo em videos.csv.

   import csv
   import os
   import subprocess
   import sys
   import time
   
   import requests
   
   API = "https://api.sorsa.io/v3/search-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def search(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 videos(tweet):
       """(kind, link) for every video and GIF in a post."""
       for e in tweet.get("entities") or []:
           link = e.get("link") or ""
           if e.get("type") == "video" and "video.twimg.com" in link:
               yield ("gif" if "/tweet_video/" in link else "video"), link
   
   
   def save(link, path):
       with requests.get(link, stream=True, timeout=120) as r:
           r.raise_for_status()
           with open(path, "wb") as f:
               for chunk in r.iter_content(1 << 16):
                   f.write(chunk)
   
   
   def save_hd(post_url, n, path):
       """The post's highest-bitrate MP4 through yt-dlp; False if yt-dlp fails."""
       cmd = ["yt-dlp", "-f", "best[protocol=https]", "--playlist-items", str(n),
              "-o", path, post_url]
       done = subprocess.run(cmd, capture_output=True).returncode == 0
       return done and os.path.exists(path)
   
   
   def run(query, folder, hd=False):
       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, "videos.csv")
       with open(log_path, "a", newline="", encoding="utf-8") as f:
           log = csv.writer(f)
           while True:
               page = search(body)
               for t in page.get("tweets", []):
                   for n, (kind, link) in enumerate(videos(t), 1):
                       path = os.path.join(folder, f"{t['id']}_{n}.mp4")
                       if os.path.exists(path):
                           continue
                       url = f"https://x.com/{t['user']['username']}/status/{t['id']}"
                       if not (hd and kind == "video" and save_hd(url, n, path)):
                           save(link, path)
                       log.writerow([t["id"], t["created_at"], kind,
                                     os.path.getsize(path), 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__":
       run(sys.argv[1], sys.argv[2], hd="--hd" in sys.argv[3:])
   

2. Rode-o com uma consulta e uma pasta. python x_videos.py "from:northfield_video_lab filter:native_video" northfield salva os vídeos da conta na pasta northfield. Um 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.

3. Rode-o de novo quando quiser. Os arquivos que já estão no disco são pulados e o cursor é salvo depois de cada página. Uma execução interrompida retoma de onde parou, e uma nova execução acrescenta só os vídeos novos.

Os vídeos de uma conta inteira levam poucas requisições: a cerca de 20 posts por página, uma conta com 300 vídeos leva cerca de 15 requisições, porque a busca devolve apenas os posts que trazem um. Para o texto e todos os outros campos de post em uma planilha, veja como baixar todos os tweets de um usuário.

#Baixe o arquivo em 720p ou 1080p de um post

Para o arquivo em 720p ou 1080p de um post, passe o link dele para o yt-dlp, o baixador de linha de comando open source, que lê posts públicos sem login do X. O filtro de formato abaixo escolhe o MP4 com o maior bitrate:

yt-dlp -f "best[protocol=https]" -o "%(id)s.%(ext)s"   "https://x.com/northfield_video_lab/status/1984519203377641472"

Adicione --hd ao script acima e ele faz isso para cada vídeo, voltando ao link da API quando o yt-dlp falha. No nosso vídeo de teste de 82 segundos, o yt-dlp 2026.10.26 escolheu o arquivo de 1920 × 1080. A tabela de formatos dele, gerada com -F, listava esse arquivo com cerca de 100 MiB, porque a tabela multiplica o bitrate listado pela duração; o download pesou 22,2 MB. O yt-dlp busca um post por vez a partir do seu próprio endereço, então a Sorsa API encontra os vídeos em massa e o yt-dlp baixa só os arquivos HD de que você precisa.

Bom saber

A API oficial do X devolve a lista completa de versões em uma resposta, mas só se você pedir. Adicione expansions=attachments.media_keys e media.fields=variants a uma consulta de post, e cada vídeo volta em includes.media com um array variants de bit_rate, content_type e url. Ela exige conta de desenvolvedor e OAuth, e a partir de 22 de novembro de 2026 cada objeto de mídia nessa resposta é cobrado a US$ 0,005, além dos US$ 0,005 da leitura do post.

#GIFs do Twitter na API

Um GIF publicado no X volta como um MP4, porque o X converte todo GIF em um vídeo curto, mudo e em loop quando ele é publicado. O link dele fica em video.twimg.com/tweet_video/, o X não guarda nenhum outro tamanho, e esse único arquivo é a melhor cópia que existe. Nos dados do próprio X ele é do tipo animated_gif com bitrate 0; nas entities da Sorsa API ele vem como um video cujo link tem esse caminho /tweet_video/.

Para transformá-lo de volta em um arquivo .gif, rode o ffmpeg com uma passada de paleta, que mantém as cores limpas:

ffmpeg -i 1211797914437259264_1.mp4 \
  -vf "fps=15,split[a][b];[a]palettegen[p];[b][p]paletteuse" \
  -loop 0 1211797914437259264.gif

Espere um arquivo bem maior: no nosso teste, um MP4 de 83 KB virou um GIF de 1,76 MB nos mesmos 498 × 272 pixels, 21 vezes o tamanho. Guarde o MP4 para armazenamento e players, e faça o GIF só onde uma página ou um chat precisar de um. Para um único GIF sem código, o Baixador de GIFs do Twitter gratuito o salva a partir do link de um post.

#Quanto custa, em requisições e em armazenamento

Na Sorsa API um post custa o mesmo, seja qual for a mídia que traz. Posts consultados por ID custam a partir de US$ 0,014 por 1.000, 100 por requisição, e posts encontrados pela busca a partir de US$ 0,07 por 1.000, cerca de 20 por requisição. Os arquivos de vídeo são baixados dos servidores do X e não custam requisições. Na API oficial do X todo vídeo chega pela expansão de mídia, e a partir de 22 de novembro de 2026 o X cobra os objetos de expansão (abre em uma nova aba) pela tarifa padrão. Um post com vídeo passa então a custar US$ 0,005 pelo post mais US$ 0,005 pela mídia dele: US$ 10,00 por 1.000.

• Sorsa API, posts por ID

  O que exige

  Uma chave de API

  Custo por 1.000 posts com vídeo

  a partir de US$ 0,014

• Sorsa API, busca

  O que exige

  Uma chave de API

  Custo por 1.000 posts com vídeo

  a partir de US$ 0,07

• API oficial do X

  O que exige

  Conta de desenvolvedor e OAuth

  Custo por 1.000 posts com vídeo

  US$ 10,00 a partir de 22 de nov. de 2026

O preço de 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, e acima disso o X vende apenas contratos Enterprise. A Sorsa API roda 20 requisições por segundo em todos os planos, então lotes de 100 posts consultam 2.000 posts com vídeo por segundo, e requisições com falha nunca são cobradas.

O armazenamento é a conta maior para um arquivo de vídeos, e depende muito mais da versão do que da quantidade. Nos bitrates médios reais que medimos, 1.000 vídeos de trinta segundos ocupam cerca de 0,3 GB em 270p, 2,3 GB em 720p e 8,1 GB em 1080p. Defina a sua duração e a sua quantidade:

#Comece a puxar vídeos do X em código

Para obter em código as URLs de MP4 de vídeos e GIFs do X, use a Sorsa API: uma requisição devolve até 100 posts com o link de cada vídeo, a partir de US$ 0,014 por 1.000. A busca encontra todo vídeo de uma conta ou de um tópico até 2006, e a sua conta do X nunca entra na história. Copie o script, adicione a sua chave, e as suas 100 requisições grátis devolvem os links dos seus primeiros 10 mil posts com vídeo.

#FAQ