API & Error Handling

Endpoint

Path	Method	Format
/	POST	JSON-RPC

Request

• Query parameter: api-key (string, required)

POST /?api-key=YOUR_API_KEY
Content-Type: application/json

Body: Standard Solana JSON-RPC request

Response format

Responses follow the Solana JSON-RPC format.

Success

{
  "jsonrpc": "2.0",
  "result": "5KtPn1LGuxhFiwjxErkxTb7XxtLVYUBe6Cn33ej7ATNQy...",
  "id": 1
}

result is the transaction signature (Base58).

Error

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32005,
    "message": "Rate limit exceeded"
  },
  "id": null
}

Supported methods

Method	Description
sendTransaction	Submit a transaction
getHealth	Health check / keepalive

Keepalive (recommended)

Call getHealth every 60 seconds to keep the connection warm:

{"jsonrpc":"2.0","id":1,"method":"getHealth"}

Examples

cURL

curl -X POST 'http://fra1.blockgo.trade/?api-key=YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": ["YOUR_BASE64_TX", {"encoding": "base64"}]
  }'

TypeScript

import { Connection, VersionedTransaction } from '@solana/web3.js';

// Option 1: @solana/web3.js
const connection = new Connection(
  'http://fra1.blockgo.trade?api-key=YOUR_API_KEY'
);

const signature = await connection.sendTransaction(transaction);

// Option 2: raw JSON-RPC
async function sendViaJsonRpc(
  endpoint: string,
  apiKey: string,
  transaction: VersionedTransaction
): Promise<string> {
  const serialized = transaction.serialize();
  const base64Tx = Buffer.from(serialized).toString('base64');

  const response = await fetch(`${endpoint}/?api-key=${apiKey}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'sendTransaction',
      params: [base64Tx, { encoding: 'base64' }],
    }),
  });

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

Rust

use solana_client::rpc_client::RpcClient;
use solana_sdk::transaction::VersionedTransaction;

fn send_via_jsonrpc(
    tx: &VersionedTransaction,
    api_key: &str,
) -> Result<String, Box<dyn std::error::Error>> {
    let endpoint = format!("http://fra1.blockgo.trade?api-key={}", api_key);
    let client = RpcClient::new(endpoint);

    let signature = client.send_transaction(tx)?;
    Ok(signature.to_string())
}

Error handling

Most errors are returned in the JSON-RPC error object. For auth/rate-limit/ban scenarios, you may also see an HTTP status code.

Error codes (sorted by HTTP status)

HTTP 200

• -32600 Invalid Request (HTTP 200)
• -32601 Method not found (HTTP 200)
• -32602 Invalid params (HTTP 200)
• -32010 Tip too low (HTTP 200)
• -32013 Public key is blocked (HTTP 200)
• -32099 Request too large (HTTP 200)
• -32099 Service unavailable (HTTP 200)

HTTP 400

• -32602 Invalid transaction (HTTP 400)
• -32003 Duplicate transaction (HTTP 400)

HTTP 401

• -32001 Missing API key (HTTP 401)
• -32002 Invalid API key (HTTP 401)

HTTP 429

• -32005 Rate limit exceeded (HTTP 429)
• -32006 Too many in-flight requests (HTTP 429)
• -32014 Public key rate limit exceeded (HTTP 429)

HTTP 503

• -32099 Maintenance in progress (HTTP 503)
• -32099 Service unavailable (HTTP 503)

Retry guidance

• Retry: 429, 503 (exponential backoff, cap retries)
• Do not retry: 400/401, and clear transaction business errors (e.g. invalid signature, insufficient funds)