API do Twitter em PHP: como obter dados do X em 2026 (guia)

Por Sorsa Editorial

Publicado em junho de 2026. Atualizado em julho de 2026: adicionada a opção inicial de 100 requisições grátis e o preço da Sorsa reapresentado nas taxas de lote por 1.000. Reflete o preço de pagamento por uso atual do X (incluindo as mudanças de custo de escrita de abril de 2026) e o estado das ferramentas de PHP, em que o X publica SDKs oficiais só para Python e TypeScript, não para PHP.

Em resumo: Não existe um SDK oficial da API do X (Twitter) para PHP em 2026; o X publica SDKs oficiais só para Python e TypeScript. As rotas práticas em PHP são uma biblioteca de comunidade como a twitteroauth, cURL puro ou Guzzle com um bearer token, ou uma API REST de terceiros somente leitura.

Se você pesquisou "twitter api php" esperando um pacote oficial e suportado, não existe um. O X publicou SDKs de primeira parte para Python e TypeScript no fim de 2025 e deixou o PHP para a comunidade. A maioria dos tutoriais de PHP que ranqueiam para essa consulta ensina a postar por OAuth, ou usa os endpoints antigos da v1.1 que o X aposentou, contra um preço que não existe mais.

Nós construímos e operamos a Sorsa API, uma API alternativa do Twitter (X), e o caminho somente leitura encaixa no PHP de forma limpa: ela retorna perfis, tweets, resultados de busca e seguidores como JSON que o json_decode transforma em um array simples, com uma chave de API no cabeçalho ApiKey, sem fluxo OAuth e sem aprovação de conta de desenvolvedor para esperar. Em trabalho de leitura intensa, sai até 50x mais barata que a API oficial do X, mantém um fixo de 20 requisições por segundo em todos os planos e dá a partir de US$ 0,02 por 1.000 tweets e de US$ 0,01 por 1.000 perfis nos endpoints em lote, em planos fixos a partir de US$ 49 por mês por 10.000 requisições. Você pode começar com 100 requisições grátis, sem cartão, cobrindo todos os 40 endpoints. Nem todo projeto encaixa nesse formato: alguns precisam postar, e alguns precisam da API oficial para conformidade. Este guia cobre todas as rotas de PHP com código funcional (cURL, Guzzle e WordPress), preço atual e um coletor que pagina e repete. Você também pode testar chamadas sem escrever código no playground.

Índice

• O que mudou: a API do X e as ferramentas de PHP em 2026
• A melhor biblioteca de PHP para a API do X
• Qual abordagem usar?
• Método 1: uma biblioteca de comunidade (twitteroauth)
• Método 2: cURL puro ou Guzzle com um bearer token
• Método 3: uma API REST somente leitura
• Existe um SDK PHP oficial para a API do X?
• Chamando a API do X do WordPress
• Construindo um coletor de dados em PHP
• Comparação: três rotas, lado a lado
• Como obter suas credenciais de API
• Na prática: cortando o custo de uma integração PHP
• Perguntas frequentes
• Primeiros passos

O que mudou: a API do X e as ferramentas de PHP em 2026 {#what-changed-the-x-api-and-php-tooling-in-2026}

Três coisas mudaram para desenvolvedores de PHP desde que os tutoriais antigos foram escritos. A API do X passou para cobrança de pagamento por uso, sem plano gratuito, e cobra por recurso lido. Escrever ficou mais caro após a atualização de abril de 2026. E o X publicou seus primeiros SDKs oficiais, mas só para Python e TypeScript, então desenvolvedores de PHP ainda dependem de bibliotecas de comunidade ou de HTTP puro.

O pagamento por uso é o padrão. Não há plano gratuito nem plano Basic mensal para novos cadastros. Você compra créditos e paga por recurso: US$ 0,005 por post lido, US$ 0,010 por perfil de usuário e US$ 0,010 por registro de seguidor ou de seguindo. Ler os dados da sua própria conta custa US$ 0,001 por recurso, e contas padrão têm teto de 2 milhões de leituras de posts por mês. Os números por trás de um orçamento real estão na nossa análise de preços da API do X e no texto sobre por que o preço da API do X subiu.

Escrever ficou mais caro. Após a atualização de abril de 2026, um post padrão custa US$ 0,015 por requisição e um post com URL custa US$ 0,20. As ações de follow, curtida e quote foram retiradas dos níveis self-service e agora exigem um contrato Enterprise.

Os SDKs oficiais chegaram só para Python e TypeScript. No fim de 2025, o X anunciou SDKs de primeira parte para essas duas linguagens. Não há SDK PHP oficial. As bibliotecas de comunidade preenchem a lacuna, e a mais usada continua a twitteroauth, que suporta os endpoints v2 quando você define a versão da API.

A maioria dos exemplos de PHP online está desatualizada. Boa parte ensina chamadas v1.1 como statuses/update ou search/tweets, que o X aposentou, ou foca só em postar. Ler dados públicos pela v2 é um caminho diferente, e é o que este guia toma.

A melhor biblioteca de PHP para a API do X {#the-best-php-library-for-the-x-api}

Para a maioria dos projetos PHP, a twitteroauth ainda é o padrão: é o cliente PHP mais usado, instala pelo Composer e alcança os endpoints v2 com setApiVersion('2') mais chamadas genéricas get e post. Ela está em modo de manutenção (sem desenvolvimento de novos recursos), mas funciona. Para um wrapper nativo de v2, pacotes de comunidade como o twitter-api-v2-php e o bird-elephant miram a API v2 diretamente. Para coleta de dados somente leitura, muitas equipes pulam bibliotecas e chamam uma API REST de terceiros com cURL puro ou Guzzle, que remove o OAuth por completo.

Veja como as principais opções se comparam.

Seja qual for a biblioteca que você escolha para a API oficial, o custo é idêntico, porque o X cobra por recurso do lado dele, não por biblioteca. A variável que você controla é quantos recursos puxa, que é onde os endpoints em lote e uma API de taxa fixa mudam a conta.

Qual abordagem usar? {#which-approach-should-you-use}

Escolha a rota antes de escrever código. Para leitura e escrita contra a API v2 com a biblioteca mais comum, use a twitteroauth. Para dados somente leitura em volume com configuração mínima, uma API REST de terceiros remove o OAuth e a fila de aprovação. Para controle total sem wrapper, cURL puro ou Guzzle basta. A decisão é, na maior parte, leitura contra escrita e quanto volume você puxa.

Se o seu projeto só lê dados públicos, uma API de terceiros remove o fluxo OAuth: uma chave em um cabeçalho e você começa a puxar dados, sem candidatura de conta de desenvolvedor e sem compra de crédito. Se você precisa postar ou rodar ações de escrita, a API oficial pela twitteroauth é o caminho; nenhum provedor de terceiros posta em seu nome. Trabalhando em outra linguagem? Veja a versão em Python deste guia.

Método 1: uma biblioteca de comunidade (twitteroauth) {#method-1-a-community-library-twitteroauth}

A twitteroauth é o cliente PHP mais usado para a API do X. Ela instala pelo Composer, trata a autenticação e alcança os endpoints v2 quando você chama setApiVersion('2'). Para ler dados públicos, um bearer token somente do app basta.

Instale:

composer require abraham/twitteroauth

Monte uma conexão somente do app e busque nos últimos sete dias:

<?php
require 'vendor/autoload.php';

use Abraham\TwitterOAuth\TwitterOAuth;

// App-only auth: API key, API secret, null, bearer token
$connection = new TwitterOAuth(
    getenv('X_API_KEY'),
    getenv('X_API_SECRET'),
    null,
    getenv('X_API_BEARER_TOKEN')
);
$connection->setApiVersion('2');

$tweets = $connection->get('tweets/search/recent', [
    'query'        => 'php lang:en',
    'max_results'  => 20,
    'tweet.fields' => 'created_at,public_metrics',
]);

foreach ($tweets->data as $tweet) {
    echo $tweet->text . "\n";
}

Consulte um perfil pela mesma chamada genérica get:

$user = $connection->get('users/by/username/elonmusk', [
    'user.fields' => 'public_metrics,created_at',
]);

printf(
    "@%s has %d followers\n",
    $user->data->username,
    $user->data->public_metrics->followers_count
);

A twitteroauth retorna objetos decodificados, então o texto de um tweet é $tweet->text e as métricas de um perfil são $user->data->public_metrics. Os mesmos métodos get e post alcançam qualquer endpoint v2 por caminho, incluindo seguidores (users/:id/followers) e timelines (users/:id/tweets). É a escolha certa quando você quer a opção PHP mais documentada e talvez também escreva. As trocas: ela está em modo de manutenção, e não em desenvolvimento ativo, você ainda precisa de uma conta de desenvolvedor paga do X, e paga o preço por recurso do X em cada chamada.

Método 2: cURL puro ou Guzzle com um bearer token {#method-2-plain-curl-or-guzzle-with-a-bearer-token}

Sem biblioteca, sem wrapper. A extensão cURL embutida do PHP, ou o cliente HTTP Guzzle, consegue chamar a API do X v2 diretamente com um bearer token no cabeçalho Authorization. Essa rota serve para desenvolvedores que querem controle total sobre requisições, ou que preferem evitar uma dependência específica de Twitter.

Consulte um perfil com cURL:

<?php
$ch = curl_init('https://api.x.com/2/users/by/username/elonmusk?user.fields=public_metrics');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . getenv('X_API_BEARER_TOKEN'),
]);

$response = curl_exec($ch);
curl_close($ch);

$user = json_decode($response, true);
printf(
    "@%s has %d followers\n",
    $user['data']['username'],
    $user['data']['public_metrics']['followers_count']
);

A API oficial pagina a busca com um next_token no meta da resposta. Percorra cada resultado com uma trava para uma consulta ampla não esgotar a sua cota:

<?php
function searchRecent(string $token, string $query, int $maxPages = 10): array
{
    $all = [];
    $nextToken = null;
    $pages = 0;

    do {
        $params = [
            'query'        => $query,
            'max_results'  => 100,
            'tweet.fields' => 'created_at,public_metrics',
        ];
        if ($nextToken) {
            $params['next_token'] = $nextToken;
        }

        $url = 'https://api.x.com/2/tweets/search/recent?' . http_build_query($params);
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['Authorization: Bearer ' . $token]);
        $response = curl_exec($ch);
        curl_close($ch);

        $body = json_decode($response, true);
        $all = array_merge($all, $body['data'] ?? []);
        $nextToken = $body['meta']['next_token'] ?? null;
        $pages++;
    } while ($nextToken && $pages < $maxPages);

    return $all;
}

Isso funciona quando você quer dependências mínimas ou está depurando o comportamento da API. A desvantagem é que você é dono da paginação, do tratamento de códigos de status, do rate limit e das retentativas. Para um script pontual, tudo bem; para uma integração de produção, você acaba escrevendo um pequeno cliente. Essa rota ainda exige uma conta de desenvolvedor e créditos de pagamento por uso.

Método 3: uma API REST somente leitura {#method-3-a-read-only-rest-api}

Se uma aplicação PHP só lê dados públicos do Twitter, uma API REST de terceiros pula a API oficial por completo: sem OAuth, sem etapa de candidatura, sem fluxo de compra de crédito, só uma chave em um cabeçalho e JSON que decodifica direto em um array.

Essa é a rota prática para obter dados do X sem uma conta de desenvolvedor. Veja como fica com a Sorsa, usando só cURL.

Obtenha um perfil de usuário:

<?php
$ch = curl_init('https://api.sorsa.io/v3/info?username=elonmusk');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['ApiKey: ' . getenv('SORSA_API_KEY')]);

$response = curl_exec($ch);
curl_close($ch);

$user = json_decode($response, true);
echo "@{$user['username']} ({$user['display_name']}): {$user['followers_count']} followers\n";

Busque tweets com o conjunto completo de operadores da web. O endpoint de busca retorna cerca de 20 tweets por página e um next_cursor para a próxima página:

<?php
$ch = curl_init('https://api.sorsa.io/v3/search-tweets');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'ApiKey: ' . getenv('SORSA_API_KEY'),
    'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'query' => 'php lang:en',
    'order' => 'latest',
]));

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
foreach ($data['tweets'] as $tweet) {
    echo "{$tweet['likes_count']} likes: {$tweet['full_text']}\n";
}

Puxe uma lista de seguidores. Uma requisição retorna até 200 perfis, então uma conta de 1.000 seguidores são cinco requisições em vez de dez páginas paginadas:

<?php
$ch = curl_init('https://api.sorsa.io/v3/followers?username=elonmusk');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['ApiKey: ' . getenv('SORSA_API_KEY')]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
echo 'Got ' . count($data['users']) . " followers in one request\n";

Se o seu projeto já usa o Guzzle, as mesmas chamadas ficam mais curtas. Busque até 100 tweets em uma requisição com o endpoint de lote, que conta como uma única requisição e retorna objetos completos de tweet:

<?php
$client = new GuzzleHttp\Client();

$res = $client->post('https://api.sorsa.io/v3/tweet-info-bulk', [
    'headers' => ['ApiKey' => getenv('SORSA_API_KEY')],
    'json'    => ['tweet_links' => ['1782368585664626774', '1782368585664626775']],
]);

$data = json_decode((string) $res->getBody(), true);

Para consultas complexas, combine operadores como você faria na busca avançada; a lista completa está na nossa referência de operadores de busca, e o endpoint alcança o arquivo completo de tweets. Cada resposta de tweet carrega o perfil do autor e as métricas públicas, então puxar números de engajamento ou buscar listas de seguidores não adiciona chamadas extras. O cabeçalho é ApiKey, a URL base é https://api.sorsa.io/v3, e os nomes de campo batem com a documentação da API exatamente.

Existe um SDK PHP oficial para a API do X? {#is-there-an-official-php-sdk-for-the-x-api}

Não. Em 2026, o X publica SDKs oficiais só para Python e TypeScript; não há SDK PHP oficial. A própria página de ferramentas e bibliotecas do X lista esses dois SDKs de primeira parte mais ferramentas de desenvolvedor, e o gerador de SDK de código aberto dele atualmente publica templates só para Python e TypeScript.

Para PHP, isso deixa as opções cobertas acima: a twitteroauth como o cliente mais usado (v2 por setApiVersion), pacotes de comunidade nativos de v2 como o twitter-api-v2-php e o bird-elephant, cURL puro ou Guzzle para controle total, ou uma API de terceiros somente leitura para trabalho de leitura intensa. Não há pacote de primeira parte para preferir a esses, e a própria twitteroauth está em modo de manutenção, então pese a manutenção de longo prazo ao escolher.

Se um SDK PHP chegar algum dia, ele provavelmente seria gerado da mesma especificação OpenAPI que os de Python e TypeScript. Até lá, trate qualquer tutorial que afirme um "SDK PHP oficial" como impreciso.

Chamando a API do X do WordPress {#calling-the-x-api-from-wordpress}

Boa parte do PHP que toca a API do X roda dentro do WordPress, e você não precisa de um plugin nem de uma biblioteca externa. O WordPress traz a própria HTTP API, então o wp_remote_get pode chamar qualquer endpoint REST e passar o cabeçalho de autenticação diretamente. Para dados somente leitura, isso significa uma função e nenhum OAuth.

<?php
// In a theme's functions.php or a small plugin
$response = wp_remote_get('https://api.sorsa.io/v3/info?username=elonmusk', [
    'headers' => ['ApiKey' => getenv('SORSA_API_KEY')],
    'timeout' => 15,
]);

if (is_wp_error($response)) {
    return;
}

$user = json_decode(wp_remote_retrieve_body($response), true);
echo esc_html("@{$user['username']}: {$user['followers_count']} followers");

O mesmo padrão funciona contra a API oficial trocando a URL e usando um cabeçalho Authorization com um bearer token no lugar do cabeçalho ApiKey. Faça cache do resultado com a Transients API do WordPress (set_transient) para um carregamento de página não bater na API a cada visita, o que ao mesmo tempo acelera a página e segura o volume de requisições. Para um widget somente leitura como um contador de seguidores ou um bloco de tweets recentes, essa é a integração inteira.

Construindo um coletor de dados em PHP {#building-a-data-collector-in-php}

Um coletor de produção precisa de três coisas além de uma única chamada: paginação por cursor para passar da primeira página, uma trava de páginas para uma consulta ampla não esgotar a sua cota, e uma retentativa em rate limits. Aqui vai um coletor somente leitura completo contra o endpoint de busca, paginando com next_cursor e recuando em um 429.

<?php
function collectTweets(string $apiKey, string $query, int $maxPages = 20): array
{
    $collected = [];
    $cursor = null;
    $pages = 0;

    while ($pages < $maxPages) {
        $payload = ['query' => $query, 'order' => 'latest'];
        if ($cursor) {
            $payload['next_cursor'] = $cursor;
        }

        $ch = curl_init('https://api.sorsa.io/v3/search-tweets');
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'ApiKey: ' . $apiKey,
            'Content-Type: application/json',
        ]);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));

        $response = curl_exec($ch);
        $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        // Flat 20 requests per second limit: on a 429, wait a second and retry
        if ($status === 429) {
            sleep(1);
            continue;
        }

        $data = json_decode($response, true);
        $collected = array_merge($collected, $data['tweets'] ?? []);

        $cursor = $data['next_cursor'] ?? null;
        $pages++;
        if (!$cursor) {
            break;
        }
    }

    return $collected;
}

Quando reconstruímos os nossos próprios coletores, um limite fixo por segundo se mostrou mais simples de acompanhar que janelas por endpoint: você espera um segundo em um 429 em vez de rastrear um timestamp de reset por endpoint. A mecânica de cursores está coberta no guia de paginação, e o lado oficial está na nossa referência de rate limits da API do X. Se você precisa de leituras paralelas, o pool do Guzzle deixa você rodar várias requisições de uma vez enquanto limita a concorrência para ficar dentro do limite. O mesmo loop troca para /user-tweets ou /followers mudando o endpoint e o payload.

Comparação: três rotas, lado a lado {#comparison-three-routes-side-by-side}

As três rotas de PHP se dividem em dois eixos: se você pode escrever e como é cobrado. As duas rotas de API oficial precisam de uma conta de desenvolvedor e cobram por recurso. Uma API somente leitura troca o acesso de escrita por uma única chave e cobrança fixa por requisição.

A divisão diz qual escolher: se você precisa postar ou rodar ações de escrita, esse é o território da API oficial pela twitteroauth. Para acesso de leitura intensa a um preço fixo e previsível, uma API somente leitura é a rota mais barata e mais simples, e retorna os mesmos dados públicos.

A diferença de custo na leitura vem da unidade de cobrança. A API oficial cobra por cada post e cada perfil de autor em uma resposta; uma API de taxa fixa cobra uma requisição, não importa quantos itens retorne.

Para trabalho de leitura intensa, o modelo por recurso é a forma cara de fazer um trabalho simples, e é por isso que uma taxa fixa por requisição vence assim que você cruza cerca de 10.000 leituras por mês. As escritas são a exceção: postar e enviar DMs vivem só na API oficial, então uma integração de escrita intensa pertence a ela, seja qual for o custo de leitura.

Como obter suas credenciais de API {#how-to-get-your-api-credentials}

Para a API oficial, crie uma conta de desenvolvedor em developer.x.com, aceite os termos de desenvolvedor, descreva o seu caso de uso e crie um Project e um App para gerar uma API key, um API secret e um bearer token. Compre créditos antes da primeira chamada, já que não há plano gratuito. Para uma API REST de terceiros somente leitura, cadastre-se, gere uma chave e passe-a em um cabeçalho, sem etapa de candidatura ou aprovação.

Leia qualquer credencial do ambiente, nunca do código-fonte:

# .env or your server environment
X_API_KEY=your-x-api-key
X_API_SECRET=your-x-api-secret
X_API_BEARER_TOKEN=your-x-bearer-token
SORSA_API_KEY=your-sorsa-api-key

Em PHP, leia-as com getenv como mostrado acima, ou carregue um arquivo .env em desenvolvimento com um pacote como o vlucas/phpdotenv. Se você está portando código existente da API oficial, o guia de migração mapeia os endpoints e nomes de campo oficiais para os equivalentes de taxa fixa, para você trocar o transporte sem reescrever a lógica.

Na prática: cortando o custo de uma integração PHP {#in-practice-cutting-the-cost-of-a-php-integration}

Uma agência com cerca de 12 pessoas chegou até nós rodando um dashboard de cliente baseado em WordPress que puxava dados de contas acompanhadas pela twitteroauth na API oficial. O código funcionava, mas cada atualização do dashboard pagava por post lido e por perfil de autor, o tratamento de token OAuth adicionava peças móveis, e o teto mensal de 2 milhões de leituras de posts fazia com que vigiassem o volume conforme integravam clientes.

A correção foi uma troca de transporte, não uma reescrita. Eles mantiveram o lado do WordPress e a renderização, apontaram as requisições para os endpoints de busca e /followers, e trocaram o OAuth por um único cabeçalho ApiKey lido pelo wp_remote_get. Como cada requisição retorna até 20 tweets ou 200 perfis de seguidores em vez de cobrar por recurso, a mesma atualização custou uma fração do que custava, até 50x mais barata nas partes de leitura intensa, e um limite por segundo substituiu o teto mensal como a única coisa a acompanhar. Eles fizeram cache das respostas com transients, então a maioria dos carregamentos de página não batia na API. Para uma carga somente leitura, o modelo por recurso tinha sido a forma cara de fazer um trabalho simples.

Perguntas frequentes {#faq}

Existe um SDK oficial da API do X (Twitter) para PHP?

Não. Em 2026, o X publica SDKs oficiais só para Python e TypeScript; não há SDK PHP oficial. O cliente PHP mais usado é a twitteroauth, que alcança os endpoints v2 por setApiVersion e pelos métodos genéricos get e post, embora esteja em modo de manutenção. Pacotes de comunidade nativos de v2 mais novos como o twitter-api-v2-php e o bird-elephant também existem, então trate qualquer afirmação de "SDK PHP oficial" como imprecisa.

Qual é a melhor biblioteca de PHP para a API do Twitter?

Para a maioria dos projetos, a twitteroauth é o padrão prático: é o cliente PHP mais usado, instala pelo Composer e suporta a v2 quando você define a versão da API, embora esteja em modo de manutenção. Para código nativo de v2, o twitter-api-v2-php e o bird-elephant miram os endpoints v2 diretamente. Para dados somente leitura em volume, muitas equipes de PHP pulam bibliotecas e chamam uma API REST de terceiros com cURL puro ou Guzzle.

Como obter tweets em PHP sem uma conta de desenvolvedor?

Chame uma API REST de terceiros somente leitura. Com a Sorsa, você se cadastra, pega uma chave de API, passa-a no cabeçalho ApiKey e envia uma requisição cURL ou Guzzle; o json_decode transforma a resposta em um array simples. Não há fluxo OAuth, análise de app nem compra de crédito, e cada resposta de tweet inclui o perfil do autor e as métricas públicas, então uma única requisição retorna dados completos.

Quanto a API do X custa para um app PHP em 2026?

Na API oficial do X você paga por recurso: US$ 0,005 por post lido, US$ 0,010 por perfil de usuário, US$ 0,015 por post padrão e US$ 0,20 por um post com URL, com teto mensal de 2 milhões de leituras de posts. Uma busca que retorna 20 tweets custa US$ 0,30 quando os perfis de autor são incluídos. A Sorsa cobra por requisição, o que dá a partir de US$ 0,02 por 1.000 tweets e de US$ 0,01 por 1.000 perfis nos endpoints em lote, em planos fixos a partir de US$ 49 por mês por 10.000 requisições, e 100 requisições grátis deixam você testar antes de pagar. Cada requisição retorna até 20 tweets ou 200 perfis de seguidores.

Dá para chamar a API do X do WordPress?

Sim, e você não precisa de um plugin. O WordPress traz uma HTTP API, então o wp_remote_get pode chamar a API do X ou uma API de terceiros e passar o cabeçalho de autenticação diretamente: um bearer token para a API oficial, ou um cabeçalho ApiKey para um provedor somente leitura. Decodifique o corpo com json_decode e faça cache com a Transients API para um carregamento de página não bater na API a cada visita.

Como lidar com rate limits da API do X em PHP?

A API oficial limita requisições por janela de 15 minutos (tipicamente de 300 a 900, conforme o endpoint) e retorna um 429 quando você bate em um. Com cURL ou Guzzle você checa o código de status e espera antes de repetir. Uma API de taxa fixa como a Sorsa usa um limite por segundo de 20 requisições, então, em um 429, você espera um segundo e repete a mesma chamada, e o pool do Guzzle deixa você limitar a concorrência para leituras paralelas.

A twitteroauth suporta a API do X v2?

Sim. A twitteroauth alcança os endpoints v2 quando você chama setApiVersion com o valor 2 e então usa os métodos genéricos get e post com caminhos v2 como tweets/search/recent. Um bearer token somente do app basta para ler dados públicos. Ela exige uma conta de desenvolvedor paga do X, e a biblioteca está em modo de manutenção, então não há novos recursos planejados.

Primeiros passos {#getting-started}

Escolha uma rota e rode um dos exemplos acima.

• Dados somente leitura: pegue uma chave no painel da Sorsa, defina-a como SORSA_API_KEY e rode qualquer exemplo do Método 3. Você começa com 100 requisições grátis, sem cartão, cobrindo todos os 40 endpoints, para testar antes de escolher um plano. Dados estruturados do X caem no seu script em menos de um minuto, e o início rápido percorre a primeira chamada. Planos e limites estão na página de preços.
• Leitura e escrita: crie uma conta de desenvolvedor em developer.x.com, compre créditos e rode os exemplos de twitteroauth ou cURL com o seu bearer token.
• Comparando provedores: para um olhar mais amplo sobre opções somente leitura, veja a comparação de alternativas à API do Twitter, e, para as trocas de scraping gerenciado, nosso guia de como fazer scraping do X.

Revisado por Keksich, fundador da Sorsa, profissional de marketing e pesquisador da API do X.

Como verificamos este guia {#how-we-verified-this-guide}

Escrevemos e verificamos este guia em junho de 2026 operando a API diariamente. A ausência de um SDK PHP oficial e a existência dos SDKs de Python e TypeScript foram confirmadas contra a documentação de ferramentas e bibliotecas do X. O uso de v2 da twitteroauth (geração de bearer somente do app, setApiVersion e get/post genéricos contra caminhos v2) e seu status de modo de manutenção foram checados contra o repositório do projeto. O preço da API do X reflete o modelo atual de pagamento por uso, incluindo as mudanças de custo de escrita de abril de 2026. O comportamento dos endpoints da Sorsa, o agrupamento em lote por requisição e o preço dos planos vêm da documentação da Sorsa API; mais sobre a equipe está na nossa página sobre a Sorsa. Números de versão de biblioteca mudam, então são descritos e não fixados; para um preço atual, a documentação no produto é a fonte da verdade.