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

# Cómo obtener tokens SPL de Solana: guía completa de la API

> Recupera y consulta datos de tokens SPL de Solana con Helius: saldos, cuentas de tokens, suministro, titulares y la extensión de tokens fungibles, con ejemplos de código.

## Descripción general

Esta guía explica cómo leer tokens fungibles en Solana: saldos de cuentas, cuentas de tokens por propietario o mint, suministro total, principales titulares y la extensión de tokens fungibles de DAS. Helius ofrece métodos estándar de tokens mediante RPC de Solana y métodos de DAS que agregan metadatos y precios en USD.

Para consultar NFT, NFT comprimidos, ediciones y pruebas, consulta la [guía para obtener activos](/docs/es/das/get-nfts). Esta página se centra en tokens fungibles (SPL y Token-2022).

## Cuándo usar esto

Usa los métodos de esta página cuando necesites:

* Consultar el saldo de una sola cuenta de tokens
* Enumerar todas las cuentas de tokens que tiene una billetera
* Buscar todas las cuentas que tienen un mint específico
* Consultar el suministro total de un token o sus principales titulares
* Obtener los metadatos y el precio en USD del token junto con los saldos

## Saldo de una cuenta de tokens

Obtén el saldo de una cuenta de tokens específica mediante RPC estándar:

```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="API Reference" horizontal icon="code" href="/docs/es/api-reference/rpc/http/gettokenaccountbalance">
  getTokenAccountBalance
</Card>

## Cuentas de tokens por propietario

Enumera todas las cuentas de tokens que pertenecen a una billetera:

```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="API Reference" horizontal icon="code" href="/docs/es/api-reference/rpc/http/gettokenaccountsbyowner">
  getTokenAccountsByOwner
</Card>

## Cuentas de tokens por mint

Enumera todas las cuentas que tienen un 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="API Reference" horizontal icon="code" href="/docs/es/api-reference/rpc/http/gettokenaccountsbyowner">
  getTokenAccountsByOwner
</Card>

Para buscar todas las cuentas que tienen un mint entre todos los propietarios (no solo uno), usa el método de DAS `getTokenAccounts` descrito a continuación.

## Suministro del token

Consulta el suministro total de un 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="API Reference" horizontal icon="code" href="/docs/es/api-reference/rpc/http/gettokensupply">
  getTokenSupply
</Card>

## Principales titulares del token

Identifica las cuentas más grandes que tienen un 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="API Reference" horizontal icon="code" href="/docs/es/api-reference/rpc/http/gettokenlargestaccounts">
  getTokenLargestAccounts
</Card>

Devuelve hasta las 20 cuentas más grandes del mint:

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

## Cuentas de tokens con la API de DAS

El método de DAS `getTokenAccounts` devuelve cuentas de tokens por mint o propietario, incluidos los saldos, en una sola llamada paginada. A diferencia de `getTokenAccountsByOwner`, puedes consultar solo por `mint` para enumerar todas las cuentas que tienen un token entre todos los propietarios.

```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="API Reference" horizontal icon="code" href="/docs/es/api-reference/das/gettokenaccounts">
  getTokenAccounts
</Card>

El resultado está paginado; cada entrada incluye la cuenta, el mint, el propietario y el saldo:

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

## Metadatos y precio del token con la API de DAS

Para obtener los metadatos y el precio en USD de un token, llama al método de DAS `getAsset` con `showFungible` habilitado. Los precios de los tokens verificados se devuelven en `token_info.price_info`.

<Note>
  Los datos de precios de `getAsset` se almacenan en caché hasta por 600 segundos, por lo que pueden tener hasta 10 minutos de antigüedad.
</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="API Reference" horizontal icon="code" href="/docs/es/api-reference/das/getasset">
  getAsset
</Card>

La respuesta devuelve el suministro, los decimales y el precio en `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 la capitalización de mercado

Multiplica el precio por el suministro ajustado según los decimales:

```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 enumerar en una sola llamada todos los tokens fungibles de una billetera (con saldos y precios), usa `getAssetsByOwner` o `searchAssets` con `tokenType: "fungible"`. Consulta la [extensión de tokens fungibles](/docs/es/das/fungible-token-extension) para saber cómo aparecen `tokenType`, los saldos, las extensiones de Token-2022 y los datos de precios en la respuesta.

## Prácticas recomendadas

* Usa la paginación para los métodos que devuelven conjuntos grandes de resultados. Consulta la [guía de paginación](/docs/es/das/pagination).
* Prefiere los métodos de DAS (`getAsset`, `getAssetsByOwner`, `getTokenAccounts`) cuando necesites metadatos o precios en USD; usa los métodos RPC estándar para obtener saldos y suministros sin procesar desde la cadena.
* Gestiona los errores correctamente con bloques try/catch y reintentos.
* Almacena las respuestas en caché cuando corresponda para reducir las llamadas a la API.

## Próximos pasos

<CardGroup cols={3}>
  <Card title="Fungible Token Extension" icon="coins" href="/docs/es/das/fungible-token-extension">
    Cómo devuelve DAS los tokens fungibles, las extensiones de Token-2022 y los precios.
  </Card>

  <Card title="Get Assets (NFTs)" icon="image" href="/docs/es/das/get-nfts">
    Recupera NFT, NFT comprimidos, ediciones y pruebas.
  </Card>

  <Card title="DAS API reference" icon="code" href="/docs/es/api-reference/das">
    Esquemas completos de cada método de DAS.
  </Card>
</CardGroup>