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

# Como Obter Tokens Solana SPL: Guia Completo da API

> "Recupere e consulte dados de tokens SPL Solana com Helius: saldos, contas de token, oferta, detentores e a extensão de token fungível, com exemplos de código."

## Visão Geral

Este guia cobre a leitura de tokens fungíveis no Solana: saldos de contas, contas de token por proprietário ou mint, oferta total, maiores detentores e a extensão de token fungível DAS. O Helius expõe tanto os métodos padrão de token RPC do Solana quanto os métodos DAS que adicionam metadados e preços em USD.

Para NFTs, NFTs comprimidos, edições e provas, veja o [guia Get Assets](/docs/pt-BR/das/get-nfts). Esta página foca em tokens fungíveis (SPL e Token-2022).

## Quando usar isso

Use os métodos nesta página quando você estiver:

* Lendo o saldo de uma única conta de token
* Listando todas as contas de token que uma carteira possui
* Encontrando todas as contas que possuem um mint específico
* Verificando a oferta total de um token ou seus maiores detentores
* Buscando metadados de token e preço em USD junto com os saldos

## Saldo de conta de token

Obtenha o saldo para uma conta de token específica usando RPC padrão:

```typescript theme={"system"}
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getTokenAccountBalance',
    params: [
      '3emsAVdmGKERbHjmGfQ6oZ1e35dkf5iYcS6U4CPKFVaa'
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="Referência da API" horizontal icon="code" href="/docs/pt-BR/api-reference/rpc/http/gettokenaccountbalance">
  getTokenAccountBalance
</Card>

## Contas de token por proprietário

Liste todas as contas de token de uma carteira:

```typescript theme={"system"}
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getTokenAccountsByOwner',
    params: [
      '86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY',
      {
        programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
      },
      {
        encoding: 'jsonParsed'
      }
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="Referência da API" horizontal icon="code" href="/docs/pt-BR/api-reference/rpc/http/gettokenaccountsbyowner">
  getTokenAccountsByOwner
</Card>

## Contas de token por mint

Liste todas as contas que possuem um token específico:

```typescript theme={"system"}
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getTokenAccountsByOwner',
    params: [
      'CEXq1uy9y15PL2Wb4vDQwQfcJakBGjaAjeuR2nKLj8dk',
      {
        mint: "8wXtPeU6557ETkp9WHFY1n1EcU6NxDvbAggHGsMYiHsB"
      },
      {
        encoding: 'jsonParsed'
      }
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="Referência da API" horizontal icon="code" href="/docs/pt-BR/api-reference/rpc/http/gettokenaccountsbyowner">
  getTokenAccountsByOwner
</Card>

Para encontrar todas as contas que possuem um mint em todos os proprietários (não apenas um proprietário), use o método DAS `getTokenAccounts` descrito abaixo.

## Oferta de token

Verifique a oferta total de um token:

```typescript theme={"system"}
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getTokenSupply',
    params: [
      'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="Referência da API" horizontal icon="code" href="/docs/pt-BR/api-reference/rpc/http/gettokensupply">
  getTokenSupply
</Card>

## Maiores detentores de tokens

Identifique as maiores contas que possuem um token:

```typescript theme={"system"}
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getTokenLargestAccounts',
    params: [
      'he1iusmfkpAdwvxLNGV8Y1iSbj4rUy6yMhEA3fotn9A'
    ]
  })
});
const data = await response.json();
console.log(data);
```

<Card title="Referência da API" horizontal icon="code" href="/docs/pt-BR/api-reference/rpc/http/gettokenlargestaccounts">
  getTokenLargestAccounts
</Card>

Retorna até as 20 maiores contas para o mint:

```json theme={"system"}
{
  "context": { "slot": 0 },
  "value": [
    { "address": "...", "amount": "1000000000000", "decimals": 9, "uiAmount": 1000.0, "uiAmountString": "1000" }
  ]
}
```

## Contas de token com a API DAS

O método DAS `getTokenAccounts` retorna contas de token por mint ou proprietário, incluindo saldos, em uma única chamada paginada. Ao contrário de `getTokenAccountsByOwner`, você pode consultar por `mint` sozinho para listar todas as contas que possuem um token em todos os proprietários.

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

const getTokenAccounts = async (params) => {
  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "my-request-id",
      method: "getTokenAccounts",
      params: params,
    }),
  });

  const { result } = await response.json();
  return result;
};

// Example: Get all accounts holding a specific token
getTokenAccounts({
  mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
  page: 1,
  limit: 100
});
```

<Card title="Referência da API" horizontal icon="code" href="/docs/pt-BR/api-reference/das/gettokenaccounts">
  getTokenAccounts
</Card>

Paginada; cada entrada inclui a conta, mint, proprietário e saldo:

```json theme={"system"}
{
  "total": 100,
  "limit": 100,
  "page": 1,
  "token_accounts": [
    { "address": "...", "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "owner": "...", "amount": 12345678 }
  ]
}
```

## Metadados de token e preço com a API DAS

Para metadados de token e preço em USD, chame o método DAS `getAsset` com `showFungible` habilitado. Os preços para tokens verificados são retornados sob `token_info.price_info`.

<Note>
  Os dados de preço de `getAsset` são armazenados em cache por até 600 segundos, então podem ter até 10 minutos de idade.
</Note>

```typescript theme={"system"}
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getAsset',
    params: {
      id: 'DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263', // Bonk
      options: {
        showFungible: true
      }
    }
  })
});
const { result } = await response.json();
console.log(result.token_info.price_info);
```

<Card title="Referência da API" horizontal icon="code" href="/docs/pt-BR/api-reference/das/getasset">
  getAsset
</Card>

A resposta retorna a oferta, decimais e preço sob `token_info`:

```json theme={"system"}
{
  "token_info": {
    "symbol": "Bonk",
    "supply": 8881594973561640000,
    "decimals": 5,
    "token_program": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
    "price_info": {
      "price_per_token": 0.0000192271,
      "currency": "USDC"
    }
  }
}
```

### Calcular valor de mercado

Multiplique o preço pela oferta ajustada por decimais:

```typescript theme={"system"}
const { price_per_token } = result.token_info.price_info;
const { supply, decimals } = result.token_info;
const marketCap = (supply / Math.pow(10, decimals)) * price_per_token;
```

Para listar todos os tokens fungíveis em uma carteira (com saldos e preços) em uma única chamada, use `getAssetsByOwner` ou `searchAssets` com `tokenType: "fungible"`. Veja a [extensão de token fungível](/docs/pt-BR/das/fungible-token-extension) para como `tokenType`, saldos, extensões Token-2022 e dados de preço aparecem na resposta.

## Melhores práticas

* Use paginação para métodos que retornam grandes conjuntos de resultados. Veja o [guia de Paginação](/docs/pt-BR/das/pagination).
* Prefira métodos DAS (`getAsset`, `getAssetsByOwner`, `getTokenAccounts`) quando precisar de metadados ou preços em USD; use métodos RPC padrão para saldos brutos na cadeia e oferta.
* Trate erros graciosamente com blocos try/catch e tentativas de nova execução.
* Armazene respostas em cache quando apropriado para reduzir chamadas de API.

## Próximos passos

<CardGroup cols={3}>
  <Card title="Extensão de Token Fungível" icon="coins" href="/docs/pt-BR/das/fungible-token-extension">
    Como DAS retorna tokens fungíveis, extensões Token-2022 e preços.
  </Card>

  <Card title="Obter Ativos (NFTs)" icon="image" href="/docs/pt-BR/das/get-nfts">
    Recupere NFTs, NFTs comprimidos, edições e provas.
  </Card>

  <Card title="Referência da API DAS" icon="code" href="/docs/pt-BR/api-reference/das">
    Esquemas completos para cada método DAS.
  </Card>
</CardGroup>