> ## 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.

# Autenticação

> Aprenda a autenticar suas requisições na API Helius de forma segura e eficiente

A API Helius usa chaves de API para autenticar requisições. Toda requisição à API deve incluir sua chave de API para verificar sua identidade e permissões.

<Warning>
  Sua chave de API é uma informação sensível que concede acesso à sua conta Helius. Nunca a exponha em código do lado do cliente, repositórios públicos ou áreas acessíveis por navegadores.
</Warning>

## Começando

### 1. Crie sua Chave de API

<Steps>
  <Step title="Cadastre-se ou faça login">
    Crie uma conta no [Helius Dashboard](https://dashboard.helius.dev) ou faça login na sua conta existente.
  </Step>

  <Step title="Navegue até Chaves de API">
    Vá para a seção **Chaves de API** na barra lateral do seu dashboard.
  </Step>

  <Step title="Gere uma nova chave">
    Clique em **Criar Nova Chave de API** e forneça um nome descritivo para seu projeto (por exemplo, "Aplicativo de Produção", "Ambiente de Desenvolvimento").
  </Step>

  <Step title="Copie e proteja sua chave">
    Copie sua chave de API imediatamente e armazene-a com segurança. Você não poderá vê-la novamente após sair da página.
  </Step>
</Steps>

### 2. Usando sua Chave de API

Inclua sua chave de API como um parâmetro na query em todas as requisições:

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

  ```javascript JavaScript theme={"system"}
  const url = `https://mainnet.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: 'getAccountInfo',
      params: ['ACCOUNT_ADDRESS']
    })
  });
  ```

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

  url = f"https://mainnet.helius-rpc.com/?api-key={YOUR_API_KEY}"
  payload = {
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getAccountInfo",
      "params": ["ACCOUNT_ADDRESS"]
  }
  response = requests.post(url, json=payload)
  ```
</CodeGroup>

## Começando (Para Agentes)

Agentes podem se inscrever programaticamente para contas Helius, criar projetos e gerar chaves de API usando o [Helius CLI](/docs/pt-BR/agents/cli).

Para instruções completas, leia: [https://dashboard.helius.dev/agents.md](https://dashboard.helius.dev/agents.md)

### Instale o Helius CLI

<CodeGroup>
  ```bash theme={"system"}
  npm install -g helius-cli
  ```
</CodeGroup>

### Gere um Par de Chaves

<CodeGroup>
  ```bash theme={"system"}
  helius keygen
  ```
</CodeGroup>

### Financie a Carteira Gerada (somente Autopay)

Pule esta etapa se for pagar via link de pagamento hospedado (`--pay` / `--resume`). Para autopay, envie 1 USDC e 0.001 SOL para o endereço da carteira fornecido na Etapa 2.

### Inscreva-se e Obtenha a Chave de API

<CodeGroup>
  ```bash theme={"system"}
  helius signup --email you@example.com --first-name Jane --last-name Doe --json
  ```
</CodeGroup>

## Melhores Práticas de Segurança

<CardGroup cols={2}>
  <Card title="Variáveis de Ambiente" icon="shield-check">
    Armazene sua chave de API em variáveis de ambiente, não no seu código-fonte.

    ```bash theme={"system"}
    export HELIUS_API_KEY="YOUR_API_KEY"
    ```
  </Card>

  <Card title="Restrições de IP" icon="globe">
    Configure restrições de IP para suas chaves de API no dashboard para limitar o acesso a endereços IP ou intervalos específicos.
  </Card>

  <Card title="Chaves Separadas" icon="key">
    Use chaves de API diferentes para ambientes de desenvolvimento, teste e produção para isolar o uso e melhorar a segurança.
  </Card>

  <Card title="Monitorar Uso" icon="chart-line">
    Verifique regularmente seu uso de API no dashboard para detectar padrões incomuns ou possíveis problemas de segurança.
  </Card>
</CardGroup>

### Gestão de Segredos

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={"system"}
    // Use environment variables
    const apiKey = process.env.HELIUS_API_KEY;

    // Or use a secrets manager
    const { SecretManagerServiceClient } = require('@google-cloud/secret-manager');
    const client = new SecretManagerServiceClient();

    async function getApiKey() {
      const [version] = await client.accessSecretVersion({
        name: 'projects/PROJECT_ID/secrets/helius-api-key/versions/latest',
      });
      return version.payload.data.toString();
    }
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={"system"}
    import os
    from dotenv import load_dotenv

    # Load environment variables
    load_dotenv()
    api_key = os.getenv('HELIUS_API_KEY')

    # Or use AWS Secrets Manager
    import boto3

    def get_secret():
        client = boto3.client('secretsmanager')
        response = client.get_secret_value(SecretId='helius-api-key')
        return response['SecretString']
    ```
  </Tab>

  <Tab title="Docker">
    ```dockerfile theme={"system"}
    # In your Dockerfile
    ENV HELIUS_API_KEY=""

    # Or use Docker secrets
    RUN --mount=type=secret,id=helius_key \
        cat /run/secrets/helius_key > /app/api_key.txt
    ```
  </Tab>
</Tabs>

## Limites de Taxa e Uso

<Note>
  Os limites de taxa variam conforme o plano de assinatura. Monitore seu uso no [Helius Dashboard](https://dashboard.helius.dev) para garantir que você esteja dentro dos limites alocados.
</Note>

### Entendendo os Limites de Taxa

* **Requisições por segundo**: Com base no seu nível de assinatura
* **Quota de requisições mensais**: Total de requisições permitidas por ciclo de cobrança
* **Permissão de Estouro**: Picos de curto prazo acima do seu limite base de taxa

### Lidando com os Limites de Taxa

<CodeGroup>
  ```javascript JavaScript theme={"system"}
  async function makeRequest(url, data) {
    try {
      const response = await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(data)
      });
      
      if (response.status === 429) {
        const retryAfter = response.headers.get('Retry-After');
        console.log(`Rate limited. Retry after ${retryAfter} seconds`);
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
        return makeRequest(url, data); // Retry
      }
      
      return response.json();
    } catch (error) {
      console.error('Request failed:', error);
      throw error;
    }
  }
  ```

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

  def make_request(url, data):
      try:
          response = requests.post(url, json=data)
          
          if response.status_code == 429:
              retry_after = int(response.headers.get('Retry-After', 60))
              print(f"Rate limited. Waiting {retry_after} seconds...")
              time.sleep(retry_after)
              return make_request(url, data)  # Retry
          
          response.raise_for_status()
          return response.json()
      except requests.exceptions.RequestException as e:
          print(f"Request failed: {e}")
          raise
  ```
</CodeGroup>

## Solução de Problemas

<AccordionGroup>
  <Accordion title="Erro de Chave de API Inválida">
    **Sintomas**: 401 Unauthorized ou erros de "Chave de API Inválida"

    **Soluções**:

    * Verifique se sua chave de API está correta e não foi regenerada
    * Verifique se você está incluindo a chave de API como um parâmetro na query: `?api-key=YOUR_KEY`
    * Certifique-se de que não há espaços ou caracteres extras na sua chave de API
    * Confirme se sua chave de API não expirou ou foi revogada
  </Accordion>

  <Accordion title="Limite de Taxa Excedido">
    **Sintomas**: Erros 429 Too Many Requests

    **Soluções**:

    * Verifique seu uso atual no dashboard
    * Implemente o backoff exponencial na sua lógica de reintento
    * Considere atualizar seu plano para limites mais altos
    * Otimize suas requisições para reduzir chamadas desnecessárias
  </Accordion>

  <Accordion title="Acesso Proibido">
    **Sintomas**: Erros 403 Forbidden

    **Soluções**:

    * Verifique se as restrições de IP não estão bloqueando suas requisições
    * Verifique se sua assinatura inclui acesso ao endpoint
    * Certifique-se de que sua chave de API tem as permissões necessárias
  </Accordion>
</AccordionGroup>

## Próximos Passos

<CardGroup cols={2}>
  <Card title="Guia de Início Rápido" icon="rocket" href="/docs/pt-BR/quickstart">
    Comece a fazer suas primeiras chamadas de API com Helius
  </Card>

  <Card title="Referência da API" icon="book" href="/docs/pt-BR/api-reference">
    Explore todos os endpoints e métodos disponíveis
  </Card>

  <Card title="Limites de Taxa" icon="credit-card" href="/docs/pt-BR/billing/rate-limits">
    Entenda os limites de taxa e opções de upgrade
  </Card>

  <Card title="Dashboard" icon="chart-line" href="https://dashboard.helius.dev">
    Monitore seu uso de API e gerencie chaves
  </Card>
</CardGroup>

## Suporte

Precisa de ajuda com autenticação ou tem perguntas sobre chaves de API?

<CardGroup cols={2}>
  <Card title="Comunidade no Discord" icon="discord" href="https://discord.com/invite/6GXdee3gBj">
    Participe do nosso Discord para suporte em tempo real e ajuda da comunidade
  </Card>

  <Card title="Suporte por Email" icon="envelope" href="mailto:support@helius.xyz">
    Entre em contato diretamente com nossa equipe de suporte
  </Card>
</CardGroup>