Authentication & Setup

Get your Solana Tracker Yellowstone gRPC credentials, configure your client with x-token authentication, and connect to the streaming endpoint.

Getting Your API Key

1. Subscribe to Service

   Subscribe to the standalone gRPC service at €200/month, or get it bundled free with RPC Business and Professional plans. See Pricing & Limits for details.

   You get access to:

   • EU endpoint: https://grpc.solanatracker.io
   • US endpoint: https://grpc-us.solanatracker.io
   • Accelerated by Jito Shreds
   • No bandwidth charges
2. Receive Credentials

   After subscription, you’ll receive:

   • Your API token
   • Endpoint URLs
   • Configuration guidelines
3. Test Connection

   Verify your credentials work by creating a simple test connection

Authentication Methods

Header-Based Authentication

Add your API token to the request headers:

x-token · string · required

Your API token for authenticating gRPC requests

Client Configuration

TypeScript/JavaScript

npm install @triton-one/yellowstone-grpc

import Client from "@triton-one/yellowstone-grpc";

const client = new Client(
  "https://grpc.solanatracker.io",  // or https://grpc-us.solanatracker.io
  "your-api-token",
  {
    // Recommended settings
    "grpc.max_receive_message_length": 64 * 1024 * 1024,  // 64MB
    "grpc.max_send_message_length": 64 * 1024 * 1024,     // 64MB
    "grpc.keepalive_time_ms": 30000,                      // 30 seconds
    "grpc.keepalive_timeout_ms": 5000,                    // 5 seconds
  }
);

Rust

[dependencies]
yellowstone-grpc-client = "9.0.1"
yellowstone-grpc-proto = "9.0.1"
tokio = { version = "1.0", features = ["full"] }
tonic = "0.10"

use yellowstone_grpc_client::GeyserGrpcClient;
use std::time::Duration;

let endpoint = "https://grpc.solanatracker.io";
let token = Some("your-api-token".to_string());

let client = GeyserGrpcClient::build_from_shared(endpoint)?
    .x_token(token)?
    .connect_timeout(Duration::from_secs(10))
    .timeout(Duration::from_secs(10))
    .max_decoding_message_size(64 * 1024 * 1024)
    .connect()
    .await?;

Go

go get github.com/rpcpool/yellowstone-grpc/examples/golang@latest
go get google.golang.org/grpc@v1.67.1

import (
    "google.golang.org/grpc"
    "google.golang.org/grpc/metadata"
)

conn, err := grpc.Dial(
    "grpc.solanatracker.io:443",
    grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")),
    grpc.WithDefaultCallOptions(
        grpc.MaxCallRecvMsgSize(64 * 1024 * 1024),
        grpc.MaxCallSendMsgSize(64 * 1024 * 1024),
    ),
)

// Add authentication
ctx := metadata.AppendToOutgoingContext(context.Background(), "x-token", "your-api-token")

Endpoint Selection

Choose the endpoint that provides the best latency for your infrastructure:

Primary Endpoint

https://grpc.solanatracker.io

• Best for global applications
• Automatic routing
• High availability

US Endpoint

https://grpc-us.solanatracker.io

• Optimized for North America
• Lower latency for US-based apps
• Direct US routing

Test both endpoints and use the one with lower latency from your deployment region.

Configuration Best Practices

Message Size Limits

Set appropriate message size limits to handle large blocks and transaction batches:

{
  "grpc.max_receive_message_length": 64 * 1024 * 1024,  // 64MB
  "grpc.max_send_message_length": 64 * 1024 * 1024      // 64MB
}

Keepalive Settings

Configure keepalive to maintain persistent connections:

{
  "grpc.keepalive_time_ms": 30000,        // Send keepalive every 30s
  "grpc.keepalive_timeout_ms": 5000,      // Wait 5s for keepalive response
  "grpc.keepalive_permit_without_calls": 1 // Allow keepalive without active calls
}

Connection Timeouts

Set reasonable timeout values:

{
  "grpc.initial_reconnect_backoff_ms": 1000,  // Start with 1s backoff
  "grpc.max_reconnect_backoff_ms": 30000,     // Max 30s backoff
  "grpc.min_reconnect_backoff_ms": 1000       // Min 1s backoff
}

Testing Your Connection

Create a simple test to verify your setup:

import Client, { CommitmentLevel } from "@triton-one/yellowstone-grpc";

async function testConnection() {
  const client = new Client(
    "https://grpc.solanatracker.io",
    "your-api-token",
    {
      "grpc.max_receive_message_length": 64 * 1024 * 1024
    }
  );

  try {
    const stream = await client.subscribe();
    
    stream.on("data", (data) => {
      console.log("Connection successful! Received data:", data);
      stream.end();
      client.close();
      process.exit(0);
    });

    stream.on("error", (error) => {
      console.error("Connection error:", error);
      process.exit(1);
    });

    // Subscribe to slot updates (lightweight test)
    const request = {
      slots: { slotSubscribe: {} },
      commitment: CommitmentLevel.CONFIRMED
    };

    stream.write(request);

    console.log("Testing connection...");
  } catch (error) {
    console.error("Failed to connect:", error);
    process.exit(1);
  }
}

testConnection();

Troubleshooting

Authentication Failed

Error: UNAUTHENTICATED or Invalid token

Solutions:

• Verify your API token is correct
• Check token is properly set in headers
• Ensure subscription is active

Connection Timeout

Error: Connection times out or fails to establish

Solutions:

• Verify endpoint URL is correct (include https://)
• Check firewall allows outbound gRPC connections
• Try alternative endpoint
• Increase connection timeout settings

Message Size Errors

Error: RESOURCE_EXHAUSTED or message size errors

Solutions:

• Increase max_receive_message_length to 64MB
• Increase max_send_message_length to 64MB
• Use data slicing to reduce message sizes
• Apply more specific filters

Security Best Practices

Protect Your API Token

• Never commit tokens to version control
• Use environment variables for tokens
• Rotate tokens periodically
• Implement token management system

Environment Variables

Store your credentials securely:

# .env file
GRPC_ENDPOINT=https://grpc.solanatracker.io
GRPC_API_TOKEN=your-api-token

import * as dotenv from 'dotenv';
dotenv.config();

const client = new Client(
  process.env.GRPC_ENDPOINT!,
  process.env.GRPC_API_TOKEN!,
  { /* ... */ }
);

Next Steps

Quickstart Guide

Build your first streaming application

Account Monitoring

Learn to monitor account changes