> ## Documentation Index
> Fetch the complete documentation index at: https://docs.squarecloud.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Como criar e hospedar um bot do X (Twitter)

> Crie e hospede um bot do X (Twitter) na Square Cloud com Node.js e twitter-api-v2: configure as chaves da API, responda a novas menções e faça o deploy.

export const RecommendedPlan = ({lang, plan, tier, cpu, appType, min}) => {
  const t = {
    'en': {
      q: <>Which plan should you choose for {appType}?</>,
      rec: p => <>We recommend the {p} plan: its <b>{tier} GB</b> of RAM and <b>{cpu} vCPU</b> handle most projects of this kind, with headroom for traffic spikes.</>,
      min: m => <> Lighter projects also run on the {m} plan.</>,
      pro: p => <> For larger projects, the {p} plan adds more RAM and CPU.</>
    },
    'pt-br': {
      q: <>Qual plano escolher para {appType}?</>,
      rec: p => <>Recomendamos o plano {p}: seus <b>{tier} GB</b> de RAM e <b>{cpu} vCPU</b> atendem a maioria dos projetos desse tipo, com folga para picos de tráfego.</>,
      min: m => <> Projetos mais leves também rodam no plano {m}.</>,
      pro: p => <> Para projetos maiores, o plano {p} oferece mais RAM e CPU.</>
    },
    'es': {
      q: <>¿Qué plan elegir para {appType}?</>,
      rec: p => <>Te recomendamos el plan {p}: sus <b>{tier} GB</b> de RAM y <b>{cpu} vCPU</b> cubren la mayoría de los proyectos de este tipo, con margen para picos de tráfico.</>,
      min: m => <> Los proyectos más ligeros también funcionan en el plan {m}.</>,
      pro: p => <> Para proyectos más grandes, el plan {p} ofrece más RAM y CPU.</>
    },
    'fr': {
      q: <>Quel plan choisir pour héberger {appType} ?</>,
      rec: p => <>Nous recommandons le plan {p} : ses <b>{tier} Go</b> de RAM et <b>{cpu} vCPU</b> suffisent pour la plupart des projets de ce type, avec une marge pour les pics de trafic.</>,
      min: m => <> Les projets plus légers fonctionnent aussi avec le plan {m}.</>,
      pro: p => <> Pour les projets plus importants, le plan {p} offre davantage de RAM et de CPU.</>
    },
    'de': {
      q: <>Welcher Plan eignet sich für {appType}?</>,
      rec: p => <>Wir empfehlen den {p}-Plan: <b>{tier} GB</b> RAM und <b>{cpu} vCPU</b> reichen für die meisten Projekte dieser Art, mit Reserven für Lastspitzen.</>,
      min: m => <> Kleinere Projekte laufen auch mit dem {m}-Plan.</>,
      pro: p => <> Für größere Projekte bietet der {p}-Plan mehr RAM und CPU.</>
    },
    'it': {
      q: <>Quale piano scegliere per {appType}?</>,
      rec: p => <>Ti consigliamo il piano {p}: i suoi <b>{tier}GB</b> di RAM e <b>{cpu}vCPU</b> bastano per la maggior parte dei progetti di questo tipo, con margine per i picchi di traffico.</>,
      min: m => <> I progetti più leggeri funzionano anche con il piano {m}.</>,
      pro: p => <> Per progetti più grandi, il piano {p} offre più RAM e CPU.</>
    },
    'ja': {
      q: <>{appType}にはどのプランを選べばよいですか？</>,
      rec: p => <>{p}プランをおすすめします。<b>{tier}GB</b>のRAMと<b>{cpu}vCPU</b>があれば、この種のプロジェクトの多くをトラフィックのピークにも余裕を持って動かせます。</>,
      min: m => <>軽量なプロジェクトは{m}プランでも動作します。</>,
      pro: p => <>より大規模なプロジェクトには、RAMとCPUが増える{p}プランをご検討ください。</>
    },
    'zh': {
      q: <>托管{appType}应该选择哪个套餐？</>,
      rec: p => <>我们推荐 {p} 套餐：<b>{tier}GB</b> RAM 和 <b>{cpu}vCPU</b> 足以运行大多数此类项目，并能从容应对流量高峰。</>,
      min: m => <>较轻量的项目也可以在 {m} 套餐上运行。</>,
      pro: p => <>对于更大的项目，{p} 套餐提供更多 RAM 和 CPU。</>
    }
  };
  const siteLang = t[lang] ? lang : 'en';
  const c = t[siteLang];
  const pay = (name, query) => <a href={`https://squarecloud.app/${siteLang}/pay?${query}`}>{name}</a>;
  const isPro = plan.toLowerCase() === 'pro';
  return <Note>
      <b>{c.q}</b><br />
      {c.rec(pay(plan, `plan=${plan.toLowerCase()}&tier=${tier}`))}
      {min ? c.min(pay(min, `plan=${min.toLowerCase()}`)) : null}
      {isPro ? null : c.pro(pay('Pro', 'plan=pro'))}
    </Note>;
};

export const appType_0 = "um bot do X (Twitter)"

## Introdução

Para desenvolver e hospedar {appType_0} na Square Cloud, siga a sequência de configurações e pré-requisitos abaixo.
Este guia cobre todo o processo, da configuração inicial ao deploy em produção.

### Pré-requisitos

* **Conta Square Cloud**: Cadastre-se através da [página de cadastro](https://squarecloud.app/pt-br/signup) usando seu e-mail.
* **Plano ativo**: Garante recursos dedicados e desempenho otimizado para seu aplicativo. Confira nossos [planos disponíveis](https://squarecloud.app/pt-br/pricing) e escolha o mais adequado às suas necessidades.

<RecommendedPlan appType="bots do X (Twitter)" plan="Standard" tier="4" cpu="4" min="Hobby" lang="pt-br" />

Este guia usa o [runtime Node.js](/pt-br/articles/getting-started-with-nodejs).

## Crie o projeto

Uma conta ativa no X (Twitter) é necessária para autenticação e operação do bot. Se você não tem uma, inscreva-se no [site oficial do X](https://x.com/).
Uma conta de Desenvolvedor X também é necessária para acessar as APIs. Solicite acesso através do [Portal do Desenvolvedor X](https://developer.x.com/en).

<Warning>A API do X é cobrada por uso: ler menções e publicar respostas é cobrado na sua conta de desenvolvedor do X, incluindo as verificações periódicas de menções do bot. Confira os valores atuais na [página de preços da API do X](https://docs.x.com/x-api/getting-started/pricing) antes de fazer o deploy.</Warning>

### Aplicação de bot no X

<Steps>
  <Step title="Abra o Portal do Desenvolvedor">
    1. Acesse o [Portal do Desenvolvedor X](https://developer.x.com/en/portal/dashboard).
    2. Faça login com sua conta X (Twitter).
    3. Se for sua primeira vez, complete o processo de solicitação de acesso de desenvolvedor.
  </Step>

  <Step title="Crie um projeto">
    1. No Developer Portal, clique em "Create Project" (Criar Projeto).
    2. Escolha um nome para seu projeto (ex: "Square Cloud Bot").
    3. Selecione o caso de uso mais apropriado (ex: "Making a bot" - Criando um bot).
    4. Forneça uma descrição detalhada do seu bot.
    5. Confirme a criação do projeto.
  </Step>

  <Step title="Crie um aplicativo">
    1. Dentro do projeto criado, clique em "Create App" (Criar Aplicativo).
    2. Defina um nome exclusivo para seu aplicativo.
    3. Confirme a criação do aplicativo.
    4. Anote o **App ID** gerado para referência futura.
  </Step>

  <Step title="Gere as chaves de API">
    1. Navegue até a seção "Keys and tokens" (Chaves e tokens) do seu aplicativo.
    2. Na seção "Consumer Keys" (Chaves de Consumidor), clique em "Regenerate" (Regerar) para gerar:
       * **API Key** (Chave de Consumidor)
       * **API Secret Key** (Chave Secreta de Consumidor)
    3. **Importante**: Copie e salve estas chaves imediatamente, pois você não poderá visualizá-las novamente.
  </Step>

  <Step title="Defina as permissões do aplicativo">
    1. Vá para a seção "App permissions" (Permissões do App).
    2. Clique em "Edit" (Editar) para modificar as permissões.
    3. Selecione "Read and write" (Leitura e escrita) para permitir que seu bot publique tweets.
    4. Se necessário, selecione "Read and write and Direct message" (Leitura, escrita e Mensagem direta) para funcionalidade de DM.
    5. Salve as alterações.
  </Step>

  <Step title="Gere os tokens de acesso">
    1. Retorne à seção "Keys and tokens".
    2. Na seção "Access Token and Secret" (Token e Segredo de Acesso), clique em "Generate" (Gerar).
    3. Confirme a geração do token.
    4. Copie e salve:
       * **Access Token** (Token de Acesso)
       * **Access Token Secret** (Segredo do Token de Acesso)
    5. **Aviso**: Estes tokens não podem ser visualizados novamente após fechar a página.
  </Step>

  <Step title="Confira as suas credenciais">
    1. Confirme que você possui todas as 4 credenciais necessárias:
       * API Key (Chave de Consumidor)
       * API Secret Key (Chave Secreta de Consumidor)
       * Access Token (Token de Acesso)
       * Access Token Secret (Segredo do Token de Acesso)
    2. Armazene essas credenciais em um local seguro
    3. **Importante**: Nunca compartilhe ou exponha estas credenciais publicamente
  </Step>
</Steps>

## Desenvolva o bot

1. **Verificação do Node.js**: Verifique se o Node.js está instalado em seu sistema. Caso contrário, baixe-o no [site oficial do Node.js](https://nodejs.org/).

2. **Inicialização do projeto**: Crie um novo projeto Node.js executando:

```bash Terminal theme={"system"}
npm init -y
```

3. **Instalação de dependências**: Instale as bibliotecas necessárias para o bot:

```bash Terminal theme={"system"}
npm install twitter-api-v2
```

4. **Credenciais**: o código lê as quatro credenciais de variáveis de ambiente, então elas nunca entram no seu código. Para testar o bot no seu computador, coloque-as em um arquivo `.env` e inicie o bot com `node --env-file=.env index.js`:

```env .env theme={"system"}
API_KEY=sua_api_key_aqui
API_SECRET_KEY=sua_api_secret_key_aqui
ACCESS_TOKEN=seu_access_token_aqui
ACCESS_TOKEN_SECRET=seu_access_token_secret_aqui
```

A Square Cloud não lê esse arquivo quando o bot roda: você define as mesmas variáveis na plataforma em [Defina as credenciais](#defina-as-credenciais).

5. **Criação do arquivo principal**: Desenvolva o arquivo `index.js` com a estrutura base do bot:

```javascript index.js theme={"system"}
// Importa módulos necessários
const { TwitterApi } = require('twitter-api-v2');

// Configure o cliente Twitter com autenticação
const client = new TwitterApi({
  appKey: process.env.API_KEY,
  appSecret: process.env.API_SECRET_KEY,
  accessToken: process.env.ACCESS_TOKEN,
  accessSecret: process.env.ACCESS_TOKEN_SECRET,
});

// Cliente com permissões de leitura e escrita
const rwClient = client.readWrite;

// Armazena o ID do usuário autenticado do bot (definido em verifyBot)
let botUserId = null;

// ID da menção mais recente já vista: só menções mais novas são buscadas
let sinceId;
let firstCheck = true;

// Função para verificar se o bot está funcionando
async function verifyBot() {
  try {
    // Obtém informações do usuário autenticado (X API v2)
    const me = await rwClient.v2.me();
    botUserId = me.data.id;
    console.log(`Bot inicializado com sucesso! Usuário: @${me.data.username}`);
    return true;
  } catch (error) {
    console.error('Erro ao verificar o bot:', error);
    return false;
  }
}

// Função para postar um tweet
async function postTweet(text) {
  try {
    const tweet = await rwClient.v2.tweet(text);
    console.log(`Tweet publicado com sucesso! ID: ${tweet.data.id}`);
    return tweet;
  } catch (error) {
    console.error('Erro ao postar tweet:', error);
    throw error;
  }
}

// Função para responder a menções
async function respondToMentions() {
  if (!botUserId) return;
  try {
    // Busca menções mais novas que sinceId (X API v2)
    const mentions = await rwClient.v2.userMentionTimeline(botUserId, {
      max_results: 10,
      since_id: sinceId,
    });

    // Guarda a menção mais recente, para a próxima verificação pular as tratadas agora
    sinceId = mentions.data?.meta?.newest_id ?? sinceId;

    // Primeira verificação após iniciar: só registra a menção mais recente, para um reinício não responder às antigas de novo
    if (firstCheck) {
      firstCheck = false;
      return;
    }

    for (const tweet of mentions.data?.data ?? []) {
      if (tweet.text.includes('!ping')) {
        // Responde à menção
        await rwClient.v2.reply(
          'Pong! 🤖 Bot do X funcionando corretamente!',
          tweet.id
        );
        console.log(`Respondeu à menção (tweet ID: ${tweet.id})`);
      }
    }
  } catch (error) {
    console.error('Erro ao processar menções:', error);
  }
}

// Função para buscar e interagir com tweets específicos
async function searchAndInteract(query) {
  if (!botUserId) return;
  try {
    // Busca tweets recentes (X API v2)
    const tweets = await rwClient.v2.search(query, {
      max_results: 10,
    });

    for (const tweet of tweets.data?.data ?? []) {
      // Curte o tweet
      await rwClient.v2.like(botUserId, tweet.id);
      console.log(`Curtiu o tweet ID: ${tweet.id}`);

      // Espera um pouco entre as ações para evitar rate limiting
      await new Promise(resolve => setTimeout(resolve, 2000));
    }
  } catch (error) {
    console.error('Erro ao buscar e interagir:', error);
  }
}

// Função principal do bot
async function runBot() {
  console.log('Iniciando bot X...');
  
  // Verifica se o bot está configurado corretamente
  const botOk = await verifyBot();
  if (!botOk) {
    console.error('A inicialização do bot falhou');
    return;
  }
  
  // Registra a menção mais recente que já existe, para que só as menções novas recebam resposta
  await respondToMentions();
  
  // Loop principal do bot
  setInterval(async () => {
    try {
      // Verifica e responde a menções a cada 5 minutos
      await respondToMentions();
      
      // Exemplo: Busca e interage com tweets sobre um tópico específico
      // await searchAndInteract('#SquareCloud');
      
    } catch (error) {
      console.error('Erro no loop principal:', error);
    }
  }, 5 * 60 * 1000); // 5 minutos
  
  console.log('Bot rodando. Pressione Ctrl+C para parar.');
}

// Manipulação de sinal para encerramento elegante
process.on('SIGINT', () => {
  console.log('\nEncerrando bot X...');
  process.exit(0);
});

process.on('SIGTERM', () => {
  console.log('\nEncerrando bot X...');
  process.exit(0);
});

// Inicializa o bot
runBot();
```

## Configure a Square Cloud

Crie um arquivo `squarecloud.app` na raiz do projeto, ao lado do `index.js`. Ele diz à Square Cloud como rodar o seu bot:

```systemd squarecloud.app theme={"system"}
DISPLAY_NAME=My X Bot
MAIN=index.js
MEMORY=512
VERSION=recommended
AUTORESTART=true
```

* `MEMORY` é a RAM do bot em MB. Bots precisam de pelo menos 256 MB; 512 MB deixa espaço para crescer.
* `AUTORESTART=true` inicia o bot de novo se ele travar. Veja [como funciona o auto restart](https://help.squarecloud.app/pt-br/article/como-usar-o-auto-restart-na-square-cloud-mdyj38/).
* Não há `SUBDOMAIN`: o bot chama a API do X e não serve páginas web.

Veja a [referência do arquivo de configuração](/pt-br/getting-started/config-file) para todos os campos.

## Defina as credenciais

<Note>**Segurança**: nunca inclua suas credenciais de API diretamente no código. Sempre use variáveis de ambiente na Square Cloud.</Note>

O bot precisa de quatro variáveis de ambiente:

* `API_KEY`: sua chave de API do X
* `API_SECRET_KEY`: sua chave secreta de API do X
* `ACCESS_TOKEN`: seu token de acesso
* `ACCESS_TOKEN_SECRET`: seu segredo do token de acesso

Defina-as de uma destas formas:

* **Dashboard**: na página de upload, abra **Configuração avançada** e adicione as quatro variáveis. Para um bot que já está no ar, adicione-as na página **Variáveis de ambiente** da aplicação e reinicie o bot.
* **CLI**: logo depois de enviar o bot (veja [Faça o deploy e verifique](#faça-o-deploy-e-verifique)), carregue-as do seu arquivo `.env` local com [`squarecloud app env set`](/pt-br/cli-reference/environment-variables#squarecloud-app-env-set) e reinicie o bot:

```bash theme={"system"}
squarecloud app env set --from-file .env
squarecloud app restart
```

O bot lê as variáveis de ambiente quando inicia, então reinicie-o após cada alteração. Veja [Variáveis de ambiente](/pt-br/platform/environment-variables) para as outras formas de gerenciá-las.

## O que vai no ZIP

* O `index.js` e os seus outros arquivos de código.
* `package.json`.
* `squarecloud.app`.

Deixe a `node_modules` de fora: a Square Cloud instala as suas dependências quando o bot inicia. Deixe de fora também o seu arquivo `.env`: se você faz o upload pela CLI, adicione uma linha com `.env` ao seu arquivo [`squarecloud.ignore`](/pt-br/getting-started/squarecloud-ignore) para que a CLI o ignore.

## Faça o deploy e verifique

Crie o ZIP descrito acima e faça o upload:

### Via dashboard

<Steps>
  <Step title="Acesse a página de upload">
    Acesse a [página de upload](https://squarecloud.app/pt-br/dashboard/new) e envie seu arquivo zip.
  </Step>

  <Step title="Configure seu ambiente">
    Após fazer o upload do seu arquivo zip, você precisará configurar o nome, o arquivo principal ou o ambiente de execução e outras configurações do seu projeto.\
    Se você estiver enviando um projeto web, certifique-se de selecionar "Publicação na Web" e definir um subdomínio para o seu projeto.
  </Step>

  <Step title="Faça o deploy do projeto">
    Por fim, clique no botão "Deploy" para hospedar seu projeto na Square Cloud.
    Após o deploy, você poderá monitorar o status e os registros do seu projeto no dashboard.

    <Frame>
      <img src="https://cdn.squarecloud.app/docs/articles/dashboard/uploading-pt-br.gif" alt="Enviando aplicação para a Square Cloud" style={{ borderRadius: "0.2rem" }} />
    </Frame>
  </Step>

  <Step title="Confirme que seu app está no ar">
    Seu primeiro deploy geralmente leva menos de um minuto. No [dashboard](https://squarecloud.app/pt-br/dashboard), aguarde o status da sua aplicação mudar para em execução e verifique os registros em busca de erros de inicialização.\
    Se você fez deploy de um site ou API, abra `https://<seu-subdominio>.squareweb.app` no navegador: você deve ver sua aplicação respondendo. Se você fez deploy de um bot, envie um comando para confirmar que ele está online.
    <Tip>Seu app não está iniciando? Veja o [guia de solução de problemas](/pt-br/platform/troubleshooting/app-wont-start) para as causas e correções mais comuns.</Tip>
  </Step>
</Steps>

### Via CLI

Para usar esse método, seu projeto precisa de um arquivo de configuração chamado `squarecloud.app` na raiz. Ele informa à Square Cloud como executar a sua aplicação.

<Card title="Guia do arquivo de configuração" icon="link" href="/pt-br/getting-started/config-file">
  Saiba como criar o arquivo de configuração `squarecloud.app` que define o ambiente da sua aplicação.
</Card>

<Steps>
  <Step title="Instale a CLI">
    Instale a [CLI da Square Cloud](/pt-br/cli-reference/installation). Se você já a tem, execute o mesmo comando para atualizá-la:

    <CodeGroup>
      ```bash macOS, Linux e WSL theme={"system"}
      curl -fsSL https://cli.squarecloud.app/install | bash
      ```

      ```bash Windows com npm theme={"system"}
      npm install -g @squarecloud/cli@latest
      ```
    </CodeGroup>
  </Step>

  <Step title="Faça login">
    Execute o comando abaixo. Ele abre o seu navegador: aprove o login lá e a CLI está pronta. Não há nenhuma chave de API para copiar. Para scripts e CI, veja [autenticação da CLI](/pt-br/cli-reference/authentication).

    ```bash theme={"system"}
    squarecloud auth login
    ```
  </Step>

  <Step title="Envie o seu projeto">
    Na pasta do seu projeto, execute o comando abaixo. A CLI compacta a pasta atual, deixando de fora o que o [`squarecloud.ignore`](/pt-br/getting-started/squarecloud-ignore) lista, e faz o upload:

    ```bash theme={"system"}
    squarecloud upload
    ```

    Para enviar um zip que você mesmo criou, passe-o com `--file`:

    ```bash theme={"system"}
    squarecloud upload --file <caminho/para/zip>
    ```
  </Step>

  <Step title="Confirme que seu app está no ar">
    Seu primeiro deploy geralmente leva menos de um minuto. Verifique o status e os registros da sua aplicação diretamente pelo terminal:

    ```bash theme={"system"}
    squarecloud app status
    squarecloud app logs
    ```

    Se você fez deploy de um site ou API, abra `https://<seu-subdominio>.squareweb.app` no navegador: você deve ver sua aplicação respondendo. Se você fez deploy de um bot, envie um comando para confirmar que ele está online.
    <Tip>Seu app não está iniciando? Veja o [guia de solução de problemas](/pt-br/platform/troubleshooting/app-wont-start) para as causas e correções mais comuns.</Tip>
  </Step>
</Steps>

### Teste o bot

Após o deploy, verifique os logs da aplicação no dashboard da Square Cloud em busca da mensagem `Bot inicializado com sucesso!` para confirmar que o bot autenticou corretamente. Em seguida, de outra conta, publique um tweet que mencione o bot com `!ping` (por exemplo, `@seu_bot !ping`) e confirme que ele responde com `Pong! 🤖 Bot do X funcionando corretamente!` no X em poucos minutos. Menções publicadas antes de o bot iniciar são ignoradas.

## Erros comuns

### Request failed with code 401

Os logs mostram `Erro ao verificar o bot:` seguido deste erro. Uma das quatro credenciais está errada ou faltando. Copie-as de novo da seção "Keys and tokens", defina as quatro variáveis e reinicie o bot.

### Request failed with code 403 ao responder

O bot se autentica, mas não consegue publicar. Os tokens de acesso foram gerados enquanto o aplicativo tinha permissão somente de leitura. Selecione "Read and write" nas permissões do aplicativo, gere de novo o Access Token e o Secret, atualize a `ACCESS_TOKEN` e a `ACCESS_TOKEN_SECRET` e reinicie o bot.

### Request failed with code 429

O bot atingiu um limite de taxa da API do X. Espere antes da próxima requisição e espace as suas chamadas como em [Limitação de taxa (rate limiting)](#limitação-de-taxa-rate-limiting).

## Indo além

Os trechos abaixo estendem o `index.js`: adicione-os ao arquivo e chame-os onde o seu bot precisar.

### Monitoramento de hashtags

```javascript theme={"system"}
// Função para monitorar hashtags específicas
async function monitorHashtags(hashtags) {
  for (const hashtag of hashtags) {
    try {
      const tweets = await rwClient.v2.search(`#${hashtag}`, {
        max_results: 10,
      });

      // Processa os tweets encontrados
      for (const tweet of tweets.data?.data ?? []) {
        console.log(`Tweet encontrado com #${hashtag}: ${tweet.text}`);
        // Implementar lógica de interação
      }
    } catch (error) {
      console.error(`Erro ao monitorar #${hashtag}:`, error);
    }
  }
}
```

### Postagens agendadas

```javascript theme={"system"}
// Função para agendar postagens
function schedulePost(text, delay) {
  setTimeout(async () => {
    try {
      await postTweet(text);
      console.log('Postagem agendada publicada com sucesso!');
    } catch (error) {
      console.error('Erro ao publicar postagem agendada:', error);
    }
  }, delay);
}

// Exemplo: Agendar uma postagem para 1 hora
schedulePost('🤖 Postagem agendada pelo bot!', 60 * 60 * 1000);
```

### Limitação de taxa (rate limiting)

O X (Twitter) possui limites de taxa rigorosos. Implemente controles para evitar exceder esses limites:

```javascript theme={"system"}
// Controle de Limitação de Taxa
const rateLimiter = {
  lastRequest: 0,
  minInterval: 1000, // 1 segundo entre as requisições
  
  async wait() {
    const now = Date.now();
    const timeSinceLastRequest = now - this.lastRequest;
    
    if (timeSinceLastRequest < this.minInterval) {
      const waitTime = this.minInterval - timeSinceLastRequest;
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
    
    this.lastRequest = Date.now();
  }
};
```

### Tratamento de erros

```javascript theme={"system"}
// Função auxiliar para tentar novamente uma operação em caso de falha
async function retryOperation(operation, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await operation();
    } catch (error) {
      console.error(`Tentativa ${i + 1} falhou:`, error.message);
      
      if (i === maxRetries - 1) {
        throw error;
      }
      
      // Espera antes de tentar novamente
      await new Promise(resolve => setTimeout(resolve, 2000 * (i + 1)));
    }
  }
}
```

## Próximos passos

<CardGroup cols={3}>
  <Card title="A aplicação não inicia" icon="triangle-exclamation" href="/pt-br/platform/troubleshooting/app-wont-start">
    Corrija módulos faltando, erros de memória e outras falhas na inicialização.
  </Card>

  <Card title="Variáveis de ambiente" icon="key" href="/pt-br/platform/environment-variables">
    Gerencie as credenciais do seu bot e outros segredos.
  </Card>

  <Card title="Runtime Node.js" icon="node-js" href="/pt-br/articles/getting-started-with-nodejs">
    Como a Square Cloud roda aplicações Node.js.
  </Card>
</CardGroup>

Para saber mais sobre o twitter-api-v2 e a API do X, consulte a [documentação oficial do twitter-api-v2](https://github.com/PLhery/node-twitter-api-v2), a [documentação oficial da API do X](https://docs.x.com/overview), as [políticas de uso da API do X](https://developer.x.com/en/developer-terms/policy) e a [introdução à API do X](https://docs.x.com/x-api/getting-started/about-x-api).

## Contate-nos

Se você continuar enfrentando **dificuldades técnicas**, nossa **equipe de suporte especializada** está disponível para auxiliá-lo. [**Entre em contato conosco**](https://squarecloud.app/pt-br/support) e teremos prazer em ajudá-lo a resolver qualquer questão: a qualidade do suporte é uma grande parte do motivo pelo qual desenvolvedores avaliam a Square Cloud com [**4,9/5 em 402 avaliações**](https://www.trustpilot.com/review/squarecloud.app) no Google e Trustpilot.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.