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

# Gatekeeper (Beta)

> Gateway de borda de alto desempenho da Helius desenvolvido para Solana

Gatekeeper é o novo gateway de borda da Helius, agora em beta público, que remove o Cloudflare do caminho crítico. Eliminar nossa latência de borda libera a verdadeira velocidade de nossas APIs e serviços principais—os aprimoramentos nos tempos de resposta variam de dezenas a centenas de milissegundos.

Gatekeeper atua como um ponto único e unificado de entrada para todas as requisições (por exemplo, JSON-RPC, WebSockets e APIs Helius): ele encerra conexões em locais de borda distribuídos geograficamente e encaminha inteligentemente as solicitações para nossa infraestrutura de backend.

Para cargas de trabalho críticas de latência, o Gatekeeper oferece o caminho de rede mais curto, reduzindo saltos e economizando milissegundos.

## Introdução Rápida

Para usar o Gatekeeper, substitua seu endpoint existente pelo endpoint Gatekeeper (Beta):

<CodeGroup>
  ```javascript Before theme={"system"}
  const url = "https://mainnet.helius-rpc.com?api-key=YOUR_API_KEY";
  ```

  ```javascript After theme={"system"}
  const url = "https://beta.helius-rpc.com?api-key=YOUR_API_KEY";
  ```
</CodeGroup>

**É isso!**

Sua chave de API existente funciona sem alterações adicionais.

## Métodos Suportados

Atualmente, o Gatekeeper suporta:

* Todos os endpoints padrão Solana RPC
* Todos os endpoints RPC específicos da Helius (por exemplo, gTFA)
* Todos os endpoints WebSocket da Helius (métodos padrão Solana, além das extensões Helius como `transactionSubscribe`)
* Todos os endpoints da API DAS
* Todos os endpoints da API Photon (ou seja, Compressão ZK)
* A API de Taxa Prioritária da Helius
* A API de Transações Aprimoradas

<Note>
  **Atualmente não suportado**: LaserStream ainda não está disponível no Gatekeeper. Continue usando os [endpoints LaserStream](/docs/pt-BR/laserstream/grpc#mainnet-endpoints) dedicados para conexões gRPC.
</Note>

## Exemplos de Uso

<CodeGroup>
  ```javascript JavaScript/TypeScript theme={"system"}
  const url = `https://beta.helius-rpc.com?api-key=${YOUR_API_KEY}`;

  const response = await fetch(url, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getLatestBlockhash',
      params: []
    })
  });

  const data = await response.json();
  console.log(data);
  ```

  ```python Python theme={"system"}
  import requests

  url = f"https://beta.helius-rpc.com?api-key={YOUR_API_KEY}"

  response = requests.post(url, json={
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getLatestBlockhash",
      "params": []
  })

  print(response.json())
  ```

  ```rust Rust theme={"system"}
  use reqwest;
  use serde_json::json;

  #[tokio::main]
  async fn main() -> Result<(), Box<dyn std::error::Error>> {
      let url = format!("https://beta.helius-rpc.com?api-key={}", YOUR_API_KEY);

      let client = reqwest::Client::new();
      let response = client
          .post(&url)
          .json(&json!({
              "jsonrpc": "2.0",
              "id": 1,
              "method": "getLatestBlockhash",
              "params": []
          }))
          .send()
          .await?;

      let data = response.json::<serde_json::Value>().await?;
      println!("{:?}", data);

      Ok(())
  }
  ```

  ```bash cURL theme={"system"}
  curl https://beta.helius-rpc.com?api-key=YOUR_API_KEY \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getLatestBlockhash",
      "params": []
    }'
  ```
</CodeGroup>

## Suporte a WebSocket

Gatekeeper suporta WebSockets da Helius — tanto os métodos de assinatura padrão Solana quanto as extensões Helius (`transactionSubscribe`, aprimorado `accountSubscribe`) — com as mesmas melhorias de desempenho.

```javascript theme={"system"}
const ws = new WebSocket(`wss://beta.helius-rpc.com?api-key=${YOUR_API_KEY}`);

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'transactionSubscribe',
    params: [
      {
        accountInclude: ['YOUR_ACCOUNT_ADDRESS']
      },
      {
        commitment: 'confirmed',
        encoding: 'jsonParsed',
        transactionDetails: 'full',
        showRewards: true,
        maxSupportedTransactionVersion: 0
      }
    ]
  }));
});

ws.on('message', (data) => {
  console.log('Transaction:', JSON.parse(data));
});
```

## O Que Esperar

Durante o período beta:

* **Menor Latência** - Tempos de resposta significativamente mais rápidos em geral
* **Melhor Desempenho Sob Carga** - Maior confiabilidade durante períodos de alto tráfego
* **Tempos de Resposta Mais Consistentes** - Redução na variação de latência
* **Estabilidade de WebSocket Aprimorada** - Conexões em tempo real mais confiáveis
* **Compatibilidade Completa com API** - Todos os métodos RPC existentes funcionam de forma idêntica
* **Mesmo Preço** - Sem custo adicional para acesso beta
* **Distribuição Global** - Nós de borda em vários continentes

## Quem Deve Usar o Gatekeeper?

Gatekeeper é ideal para aplicativos onde o desempenho é importante:

* **Aplicações de Alta Frequência** - Qualquer app onde a latência importa
* **Bots de Trading** - Velocidade máxima para oportunidades de arbitragem
* **Protocolos DeFi** - Feeds de preço em tempo real e submissão rápida de transações
* **Aplicações de Jogos** - Baixo tempo de resposta para uma experiência de usuário fluida
* **Mercados NFT** - Minting instantâneo e consultas de baixa latência

## Lista de Verificação para Migração

<Steps>
  <Step title="Atualize Seu Endpoint">
    Altere `mainnet.helius-rpc.com` para `beta.helius-rpc.com` em seu código
  </Step>

  <Step title="Teste no Desenvolvimento">
    Execute sua suíte de testes para verificar se tudo funciona conforme esperado
  </Step>

  <Step title="Monitore o Desempenho">
    Verifique suas métricas—você deve ver latência melhorada e tempos de resposta mais consistentes
  </Step>

  <Step title="Implemente na Produção">
    Uma vez verificado, implemente suas mudanças na produção
  </Step>
</Steps>

## Reversão

Se precisar reverter por algum motivo, simplesmente retorne ao endpoint padrão:

```javascript theme={"system"}
const url = "https://mainnet.helius-rpc.com?api-key=YOUR_API_KEY";
```

## Limitações e Problemas Conhecidos

<Warning>
  **Status Beta**: Gatekeeper está pronto para produção, mas ainda está sendo otimizado. Recomendamos testar em desenvolvimento antes de mudar o tráfego de produção.
</Warning>

**Ainda não suportado:**

* **LaserStream**: Use os [endpoints LaserStream](/docs/pt-BR/laserstream/grpc#mainnet-endpoints) dedicados para conexões gRPC

**Status atual:**

* Alguns recursos avançados ainda estão sendo implementados
* Estamos continuamente otimizando algoritmos de roteamento
* Melhorias de desempenho estão em andamento

## Plano de Lançamento

Atualmente, o Gatekeeper é **opt-in** enquanto otimizamos o desempenho e coletamos feedback.

Cronograma:

* **Agora**: Beta público disponível para todos os usuários
* **Próximas Semanas**: Otimizações adicionais e melhorias de desempenho
* **Próximos Meses**: Migração gradual de todo o tráfego para o Gatekeeper como padrão

## Feedback e Suporte

Estamos monitorando ativamente o desempenho do Gatekeeper e gostaríamos do seu feedback:

* **Dúvidas ou perguntas?** Contate [support@helius.dev](mailto:support@helius.dev)
* **Entre em nosso Discord** para discussões em tempo real: [https://discord.com/invite/6GXdee3gBj](https://discord.com/invite/6GXdee3gBj)
* **Reporte bugs** através do seu painel de desenvolvedor

## FAQs

<AccordionGroup>
  <Accordion title="Preciso de uma nova chave de API?">
    Não. Sua chave de API existente funciona com o Gatekeeper sem nenhuma alteração.
  </Accordion>

  <Accordion title="O Gatekeeper terá um custo extra?">
    Não. O Gatekeeper está disponível sem custo adicional. Seu plano de preços existente se aplica.
  </Accordion>

  <Accordion title="Quais endpoints são suportados no Gatekeeper?">
    Todos os endpoints JSON-RPC são totalmente suportados, incluindo métodos padrão Solana RPC, endpoints RPC específicos da Helius (por exemplo, gTFA), DAS, Photon, API de Taxa Prioritária e a API de Transações Aprimoradas. WebSockets — tanto os métodos de assinatura padrão Solana quanto as extensões Helius como `transactionSubscribe` — também são suportados.
  </Accordion>

  <Accordion title="Quais endpoints ainda não são suportados no Gatekeeper?">
    LaserStream ainda não está disponível no Gatekeeper. Para conexões gRPC, use os [endpoints LaserStream](/docs/pt-BR/laserstream/grpc#mainnet-endpoints) dedicados.
  </Accordion>

  <Accordion title="O que fazer se eu encontrar problemas ao usar o Gatekeeper?">
    Você pode facilmente reverter voltando para `mainnet.helius-rpc.com`. Entre em contato com [suporte](https://www.helius.dev/docs/support) se precisar de ajuda.
  </Accordion>

  <Accordion title="Quando o Gatekeeper se tornará padrão?">
    Estamos planejando um lançamento gradual nos próximos meses. Notificaremos todos os usuários antes de fazer alterações nos endpoints padrão da Helius.
  </Accordion>

  <Accordion title="Posso usar o Gatekeeper no Solana Devnet ou Testnet?">
    Não, o Gatekeeper está atualmente disponível apenas no Solana Mainnet. O suporte para Solana Devnet e Testnet está chegando em breve.
  </Accordion>
</AccordionGroup>

## Comece Agora

<CardGroup cols={2}>
  <Card title="Experimente o Gatekeeper" icon="rocket" href="https://www.helius.dev/docs/gatekeeper/migration-guide">
    Migre para o Gatekeeper em menos de 5 minutos
  </Card>

  <Card title="Saiba Mais Sobre o Gatekeeper" icon="book" href="https://www.helius.dev/blog/introducing-gatekeeper">
    Leia nosso blog para entender como o Gatekeeper funciona
  </Card>
</CardGroup>