LaserStream gRPC Quickstart

Visão Geral

LaserStream é um serviço gerenciado de streaming Solana gRPC. É compatível com o protocolo Yellowstone gRPC aberto — então qualquer cliente Yellowstone funciona imediatamente — e adiciona recursos de produção como reprodução histórica, failover multiponto e um ambiente totalmente gerenciado. LaserStream usa o protocolo gRPC de código aberto, garantindo que não haja bloqueio de fornecedor e a máxima compatibilidade com implementações gRPC existentes. Você pode se conectar tanto com o cliente padrão @triton-one/yellowstone-grpc quanto usar o Helius LaserStream SDK otimizado para desempenho para benefícios adicionais, incluindo maior throughput, reconexões automáticas, gerenciamento de assinaturas, tratamento de erros e mais.

LaserStream SDK é 40x mais rápido em relação a clientes Yellowstone JavaScript

Saiba como usamos Rust Core com bindings NAPI zero-copy para maximizar o desempenho do SDK JavaScript

Aviso de Desempenho: Se você experimentar qualquer atraso ou problema de desempenho com sua conexão LaserStream, consulte a seção de Solução de Problemas para causas comuns e soluções.

Sem Compressão: Para minimizar a latência, o LaserStream não comprime mensagens de resposta gRPC. Configurar Accept-Encoding com gzip ou zstd não terá efeito — as respostas são sempre retornadas sem compressão.

Endpoints & Regiões

LaserStream está disponível em várias regiões ao redor do mundo. Escolha o endpoint mais próximo de sua aplicação para um desempenho ideal:

Endpoints Mainnet

Região	Localização	Endpoint
ewr	Newark, NJ (próximo a Nova York)	`https://laserstream-mainnet-ewr.helius-rpc.com`
pitt	Pittsburgh, US (Central)	`https://laserstream-mainnet-pitt.helius-rpc.com`
slc	Salt Lake City, US (Costa Oeste)	`https://laserstream-mainnet-slc.helius-rpc.com`
lax	Los Angeles, US (Costa Oeste)	`https://laserstream-mainnet-lax.helius-rpc.com`
lon	Londres, Europa	`https://laserstream-mainnet-lon.helius-rpc.com`
ams	Amsterdã, Europa	`https://laserstream-mainnet-ams.helius-rpc.com`
fra	Frankfurt, Europa	`https://laserstream-mainnet-fra.helius-rpc.com`
tyo	Tóquio, Ásia	`https://laserstream-mainnet-tyo.helius-rpc.com`
sgp	Singapura, Ásia	`https://laserstream-mainnet-sgp.helius-rpc.com`

Endpoint Devnet

Rede	Localização	Endpoint
Devnet	Newark, NJ (próximo a Nova York)	`https://laserstream-devnet-ewr.helius-rpc.com`

Seleção de Rede & Região:

Para apps em produção, escolha o endpoint mainnet mais próximo de seu servidor para um melhor desempenho (ex.: se implantando na Europa, use Amsterdã (ams) ou Frankfurt (fra))
Para testes, use: https://laserstream-devnet-ewr.helius-rpc.com.

Truncamento de Logs

Por padrão, o LaserStream trunca mensagens de log de transação para 10 KB para melhor velocidade e desempenho. Se você precisar de logs completos, endpoints dedicados não truncados estão disponíveis — veja Truncamento de Logs.

Início Rápido

Comece com o LaserStream a partir do seu Painel Helius. O Mainnet requer um plano Business ou Professional; o Devnet está disponível no Developer e acima. Veja Planos & Preços para detalhes.

Crie um Novo Projeto

mkdir laserstream-grpc-demo
cd laserstream-grpc-demo
npm init -y

Instale Dependências

npm install helius-laserstream
npm install --save-dev typescript tsx @types/node

Usamos tsx porque o padrão npx tsc --init no TypeScript 5.x define verbatimModuleSyntax, module: "nodenext", e types: [], que quebram uma execução rápida ts-node index.ts. tsx executa arquivos .ts sem um tsconfig.

Obtenha Sua Chave API

Gere uma chave a partir do Painel Helius.Esta chave servirá como seu token de autenticação para o LaserStream.

Requisitos de Plano: O LaserStream devnet está disponível em todos os planos. O LaserStream mainnet requer um plano Business ou Professional.

Crie um Script de Assinatura

Crie index.ts com o seguinte conteúdo:

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

async function main() {
  const subscriptionRequest: SubscribeRequest = {
    transactions: {
      "token-filter": { // user-defined label for this filter
        accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {},
    slots: {},
    transactionsStatus: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    accountsDataSlice: [],
    // Optionally, you can replay missed data by specifying a `fromSlot` (u64 number):
    // fromSlot: currentSlot - 1000,
    // Note: replay is currently limited to the last ~216,000 slots (≈24 hours).
  };

// Replace the values below with your actual LaserStream API key and endpoint
const config: LaserstreamConfig = {
  apiKey: 'YOUR_API_KEY', // Replace with your key from https://dashboard.helius.dev/
  endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
}

  await subscribe(config, subscriptionRequest, async (data) => {
    
    console.log(data);

  }, async (error) => {
    console.error(error);
  });
}

main().catch(console.error);

Substitua Sua Chave API e Escolha Sua Região

No index.ts, atualize o objeto config com:

Sua chave API real do Painel Helius
O endpoint LaserStream mais próximo da localização do seu servidor

const config: LaserstreamConfig = {
  apiKey: 'YOUR_ACTUAL_API_KEY', // Replace with your key from Helius Dashboard
  endpoint: 'https://laserstream-mainnet-fra.helius-rpc.com', // Example: Frankfurt mainnet
  // For devnet: endpoint: 'https://laserstream-devnet-ewr.helius-rpc.com'
}

Exemplos de Seleção de Rede & Região:

Para Produção (Mainnet):
- Europa: Use fra (Frankfurt), ams (Amsterdã), ou lon (Londres)
- US Leste: Use ewr (Nova York)
- US Oeste: Use slc (Salt Lake City) ou lax (Los Angeles)
- Ásia: Use tyo (Tóquio) ou sgp (Singapura)
Para Desenvolvimento (Devnet):
- Use https://laserstream-devnet-ewr.helius-rpc.com

Execute e Veja os Resultados

npx tsx index.ts

Sempre que uma transação de token confirmed envolver TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA, você verá os dados no seu console.

Fluxos de Trabalho Comuns

Guias passo-a-passo para os fluxos de trabalho que mais vemos. Cada guia usa o helius-laserstream SDK com reconexão automática e reprodução histórica integrada.

Assinaturas de Conta

Monitore alterações de saldo, dados e propriedade em contas específicas com filtros.

Monitoramento de Transações

Transmita transações envolvendo contas-alvo, filtre por programa, voto ou status de falha.

Monitoramento de Slot & Bloco

Acompanhe o consenso da rede, produção de blocos e transições de nível de compromisso.

Decodificação de Dados de Transação

Parseie cargas úteis transactionUpdate binárias em transações Solana legíveis.

Dados de Pump AMM em Stream

Exemplo do mundo real: monitore trades de Pump AMM com filtros seguros para reconexão.

O cliente @triton-one/yellowstone-grpc funciona contra os mesmos endpoints se você preferir o protocolo Yellowstone bruto. Veja a referência Yellowstone gRPC para detalhes do protocolo.

Solicitação de Assinatura

Na solicitação de assinatura, você precisa incluir os seguintes parâmetros gerais:

Reprodução Histórica: Você pode incluir opcionalmente um campo fromSlot (um número u64) no objeto principal SubscribeRequest para reproduzir dados a partir de um slot específico. A reprodução atualmente é limitada aos últimos 216.000 slots (≈24 horas); note que reproduções mais antigas que ~20 minutos retornam apenas dados finalizados.

const subscriptionRequest: SubscribeRequest = {
  commitment: CommitmentLevel.CONFIRMED,
  accountsDataSlice: [],
  transactions: {},
  accounts: {},
  slots: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
}

Em seguida, você precisará especificar os filtros para os dados aos quais deseja se inscrever, como contas, blocos, slots ou transações.

Slots

Defina filtros para atualizações de slots. A chave que você usa (ex.: mySlotLabel) é uma etiqueta definida pelo usuário para esta configuração de filtro específica, permitindo potencialmente definir múltiplas configurações nomeadas, se necessário (embora normalmente uma seja suficiente).

slots: {
  // mySlotLabel is a user-defined name for this slot update filter configuration
  mySlotLabel: {
    // filterByCommitment: true => Only broadcast slot updates at the specified subscribeRequest commitment
    filterByCommitment: true
    // interslotUpdates: true allows receiving updates for changes occurring within a slot, not just new slots.
    interslotUpdates: true
  }
},

Accounts

Defina filtros para atualizações de dados de contas. A chave que você usa (ex.: tokenAccounts) é uma etiqueta definida pelo usuário para esta configuração de filtro.Se todos os campos estiverem vazios, todas as contas serão transmitidas. Caso contrário:

Os campos operam como um E lógico.
Os valores dentro das matrizes agem como um OU lógico (exceto dentro de filters, que operam como um E lógico).

accounts: {
  // tokenAccounts is a user-defined label for this account filter configuration
  tokenAccounts: {
    // Matches any of these public keys (logical OR)
    account: ["9SHQTA66Ekh7ZgMnKWsjxXk6DwXku8przs45E8bcEe38"],
    // Matches owners that are any of these public keys
    owner: ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
    // Filters - all must match (AND logic)
    filters: [
      { datasize: 165 },
      {
        memcmp: {
          offset: 0,
          base58: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
        }
      }
    ]
  }
},

Rastreamento de mais de ~10.000 contas? Em vez de uma lista explícita de chaves públicas (32 bytes por conta), use um filtro cuckoo comprimido (~3–4 bytes por conta) para assinar centenas de milhares de contas em uma única transmissão. Disponível nos SDK Rust e JavaScript.

Transaction

Defina filtros para atualizações de transações. A chave que você usa (ex.: myTxSubscription) é uma etiqueta definida pelo usuário para esta configuração de filtro.Se todos os campos forem deixados vazios, todas as transações serão transmitidas. Caso contrário:

Os campos operam como um E lógico.
Os valores dentro das matrizes são tratados como um OU lógico (exceto para accountRequired, onde todos devem corresponder).

transactions: {
  // myTxSubscription is a user-defined label for this transaction filter configuration
  myTxSubscription: {
    vote: false,
    failed: false,
    signature: "",
    // Transaction must include at least one of these public keys (OR)
    accountInclude: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"],
    // Exclude if it matches any of these
    accountExclude: [],
    // Require all accounts in this array (AND)
    accountRequired: []
  }
},

Block

Defina filtros para atualizações de blocos. A chave que você usa (ex.: myBlockLabel) é uma etiqueta definida pelo usuário para esta configuração de filtro específico.

blocks: {
  // myBlockLabel is a user-defined label for this block filter configuration
  myBlockLabel: {
    // Only broadcast blocks referencing these accounts
    accountInclude: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"],
    includeTransactions: true,
    includeAccounts: false,
    includeEntries: false
  }
},

Blocks Meta

Isto funciona de maneira semelhante aos Blocos, mas exclui transações, contas e entradas. A chave que você usa (ex.: blockmetadata) é uma etiqueta definida pelo usuário para esta assinatura. Atualmente, não há filtros disponíveis para metadados de bloco — todas as mensagens são transmitidas por padrão.

blocksMeta: {
  blockmetadata: {}
},

Entries

Assine entradas no livro razão. A chave que você usa (ex.: entrySubscribe) é uma etiqueta definida pelo usuário para esta assinatura. Atualmente, não há filtros disponíveis para entradas; todas as entradas são transmitidas.

entry: {
  entrySubscribe: {}
},

Exemplos de Código (LaserStream SDK)

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        transactions: {},
        commitment: CommitmentLevel.CONFIRMED,
        accounts: {},
        slots: {
            slot: { filterByCommitment: true },
        },
        transactionsStatus: {},
        blocks: {},
        blocksMeta: {},
        entry: {},
        accountsDataSlice: [],
    };

    const config: LaserstreamConfig = {
        apiKey: 'YOUR_API_KEY', // Replace with your key
        endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
    }

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        accounts: {
            "usdc-account": { // user-defined label for this filter
                account: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"], // USDC mint account
                owner: [],
                filters: []
            }
        },
        accountsDataSlice: [],
        commitment: CommitmentLevel.CONFIRMED,
        slots: {},
        transactions: {},
        transactionsStatus: {},
        blocks: {},
        blocksMeta: {},
        entry: {}
    };

    const config: LaserstreamConfig = {
        apiKey: 'YOUR_API_KEY', // Replace with your key
        endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
    }

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        transactions: {
            "token-filter": { // user-defined label for this filter
                accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
                accountExclude: [],
                accountRequired: [],
                vote: false,
                failed: false
            }
        },
        commitment: CommitmentLevel.CONFIRMED,
        accounts: {},
        slots: {},
        transactionsStatus: {},
        blocks: {},
        blocksMeta: {},
        entry: {},
        accountsDataSlice: [],
    };

    const config: LaserstreamConfig = {
        apiKey: 'YOUR_API_KEY', // Replace with your key
        endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
    }

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        entry: {},
        accounts: {},
        accountsDataSlice: [],
        slots: {},
        blocks: {
            blocks: {
                accountInclude: []
            }
        },
        blocksMeta: {},
        transactions: {},
        transactionsStatus: {},
        commitment: CommitmentLevel.CONFIRMED,
    };

    const config: LaserstreamConfig = {
        apiKey: 'YOUR_API_KEY', // Replace with your key
        endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
    }

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        entry: {},
        accounts: {},
        accountsDataSlice: [],
        slots: {},
        blocks: {},
        blocksMeta: {
            blockmetadata: {}
        },
        transactions: {},
        transactionsStatus: {},
        commitment: CommitmentLevel.CONFIRMED,
    };

    const config: LaserstreamConfig = {
        apiKey: 'YOUR_API_KEY', // Replace with your key
        endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
    }

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

async function main() {
    const subscriptionRequest: SubscribeRequest = {
        entry: {
            entrySubscribe: {}  // Subscribe to all entries
        },
        accounts: {},
        accountsDataSlice: [],
        slots: {},
        blocks: {},
        blocksMeta: {},
        transactions: {},
        transactionsStatus: {},
        commitment: CommitmentLevel.CONFIRMED,
    };

    const config: LaserstreamConfig = {
        apiKey: 'YOUR_API_KEY', // Replace with your key
        endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
    }

    await subscribe(config, subscriptionRequest, async (data) => {
        console.log(data);
    }, async (error) => {
        console.error(error);
    });
}

main().catch(console.error);

Opções de SDK

Fornecemos SDKs oficiais para várias linguagens de programação:

TypeScript: LaserStream TypeScript SDK
Rust: LaserStream Rust SDK
Go: LaserStream Go SDK

Para outras linguagens ou implementações personalizadas, você pode usar os arquivos proto gRPC Yellowstone diretamente para gerar clientes gRPC para sua linguagem preferida.

Solução de Problemas / FAQ

Q: Estou experenciando atraso ou desempenho lento com minha conexão LaserStream. O que poderia estar causando isso?

A: Problemas de desempenho com conexões LaserStream normalmente são causados por:

Lentidão do Cliente JavaScript: O cliente JavaScript pode ficar para trás ao processar muitas mensagens ou consumir muita largura de banda. Considere filtrar suas assinaturas de maneira mais estreita para reduzir o volume de mensagens, mudar para o LaserStream JavaScript SDK, ou tentar usar outra linguagem.
Largura de banda local limitada: Assinaturas pesadas podem sobrecarregar clientes com largura de banda de rede limitada. Monitore o uso da rede e considere atualizar sua conexão ou reduzir o escopo da assinatura.
Distância geográfica: Rotas de rede longas aumentam a latência e a perda de pacotes. Use o endpoint mais próximo de seu servidor. Para conexões de alta latência, aumente os tamanhos dos buffers de leitura de rede (pode melhorar a largura de banda em mais de 5x):
sudo sysctl -w net.core.rmem_max=67108864 net.ipv4.tcp_rmem="4096 87380 67108864"
Para persistir após reinicializações, adicione ao /etc/sysctl.conf:
net.core.rmem_max=67108864 net.ipv4.tcp_rmem=4096 87380 67108864
Aumente os tamanhos da janela de stream e conexão HTTP/2 para 64MB para evitar gargalos de controle de fluxo. Ambos são necessários — elevar apenas a janela do stream deixa a janela de nível de conexão como a restrição de ligação:
// Rust (tonic) Channel::from_static("https://laserstream-mainnet-ewr.helius-rpc.com") .initial_stream_window_size(1024 * 1024 * 64) // 64MB stream window .initial_connection_window_size(1024 * 1024 * 64) // 64MB connection window .connect() .await?;
Gargalos de processamento do lado do cliente: Certifique-se de que sua lógica de processamento de mensagens esteja otimizada e não bloqueie a thread principal por longos períodos.

Debugging de Atrasos no Cliente: Para ajudá-lo a depurar o cliente, criamos uma ferramenta para testar a largura de banda máxima do seu nó para um servidor Laserstream gRPC. Para usá-la execute:

cargo install helius-laserstream-bandwidth
helius-laserstream-bandwidth --laserstream-url $LASERSTREAM_URL --api-key $API_KEY

A saída retorna a capacidade de rede máxima entre seu servidor e o servidor Laserstream. No mínimo, você precisa de 10MB/s para assinar todos os dados de transação e 80MB/s para assinar todos os dados de conta. Recomendamos ter pelo menos 2x a capacidade necessária para um desempenho ideal.

Q: Estou recebendo erros de conexão. O que devo verificar?

A: Verifique se sua chave API e endpoint estão corretos e se sua rede permite conexões gRPC de saída para o endpoint especificado. Verifique a página de status do Helius para quaisquer incidentes em andamento.

Q: Por que meus filtros não estão funcionando como esperado?

A: Verifique novamente os operadores lógicos (AND/OR) descritos nas seções de filtro. Certifique-se de que as chaves públicas estão corretas. Revise o nível de compromisso especificado na sua solicitação.

Q: Posso assinar vários tipos de dados (ex.: contas e transações) em uma única solicitação?

A: Sim, você pode definir configurações de filtro sob várias chaves (ex.: accounts, transactions) dentro do mesmo objeto SubscribeRequest.

Q: O LaserStream suporta grupos de consumo?

A: Nós não implementamos grupos de consumo. Em vez disso, o LaserStream entrega os mesmos resultados que as equipes desejam: retomar, reproduzir e confiabilidade multiponto sem uma camada de coordenação (e a latência/sobrecarga que acompanha). Acreditamos que grupos de consumo não são necessários para a maioria das cargas de trabalho e adicionam latência e sobrecarga operacional. Por exemplo, uma única conexão LaserStream gRPC pode emitir até 10× os dados de transações + contas do Solana, e a maioria dos clientes assina uma fatia pequena e filtrada. Usar grupos de consumo neste caso consome desempenho e introduz outro ponto de falha.

Q: Por que minhas mensagens de log de transação estão sendo cortadas?

A: O LaserStream trunca mensagens de log de transação para 10 KB por padrão para melhor velocidade e desempenho. Se você precisar de logs completos, conecte-se a um endpoint dedicado não truncado — veja Truncamento de Logs para a lista.

Q: Por que estou recebendo apenas respostas Pong sem dados de conta ou slot?

A: Incluir um campo ping em sua solicitação inicial SubscribeRequest faz com que o LaserStream ignore silenciosamente todos os filtros de assinatura — apenas um Pong é retornado sem dados de conta, transação ou slot. Para corrigir isso, remova ping da solicitação inicial de assinatura e em vez disso envie pings separadamente via saída do stream após a assinatura ser estabelecida. Isso mantém a conexão ativa sem interferir nos seus filtros.

Primeiros Passos

Transmissão de Dados & Escuta de Eventos

APIs de Dados & RPCs

Negociação

Envio de Transações

Carteira como Serviço

Guias

Recursos

LaserStream gRPC Quickstart

Visão Geral

LaserStream SDK é 40x mais rápido em relação a clientes Yellowstone JavaScript

Endpoints & Regiões

Endpoints Mainnet

Endpoint Devnet

Truncamento de Logs

Início Rápido

Fluxos de Trabalho Comuns

Assinaturas de Conta

Monitoramento de Transações

Monitoramento de Slot & Bloco

Decodificação de Dados de Transação

Dados de Pump AMM em Stream

Solicitação de Assinatura

Exemplos de Código (LaserStream SDK)

Opções de SDK

Solução de Problemas / FAQ

​Visão Geral

LaserStream SDK é 40x mais rápido em relação a clientes Yellowstone JavaScript

​Endpoints & Regiões

​Endpoints Mainnet

​Endpoint Devnet

​Truncamento de Logs

​Início Rápido

​Fluxos de Trabalho Comuns

Assinaturas de Conta

Monitoramento de Transações

Monitoramento de Slot & Bloco

Decodificação de Dados de Transação

Dados de Pump AMM em Stream

​Solicitação de Assinatura

​Exemplos de Código (LaserStream SDK)

​Opções de SDK

​Solução de Problemas / FAQ

Visão Geral

Endpoints & Regiões

Endpoints Mainnet

Endpoint Devnet

Truncamento de Logs

Início Rápido

Fluxos de Trabalho Comuns

Solicitação de Assinatura

Exemplos de Código (LaserStream SDK)

Opções de SDK

Solução de Problemas / FAQ