---

Choose Your Path

Pick the most suitable entry point based on your needs and technical background:

• New Users - First time using FlashBlock (best for first-time visitors)
• Developers - Integrate FlashBlock into your app (best for users starting with code)
• Advanced Users - Optimize transaction processing and performance (for experienced users)
• Business Users - Business cooperation, technical support, and emergency contact guide

About FlashBlock (Why Us)

Why choose FlashBlock? We provide high-performance, low-latency, enterprise-grade reliable transaction services so you can focus on building your business:

• Robust infrastructure: the largest SWQoS staking pool on Solana, a professional transaction dispatch team, and a global node network
• Outstanding performance: high throughput, low latency, and smart transaction routing
• Enterprise reliability: 99.9% availability, real-time monitoring and alerting, professional support

Read more:

• Why Choose FlashBlock (EN)

---

New Users

1. Create an account

Visit https://www.flashblock.trade/ to register and sign in. Then retrieve your API key from the dashboard.

2. Choose the closest endpoint

• New York, USA: http://ny.flashblock.trade
• Salt Lake City, USA: http://slc.flashblock.trade
• Amsterdam, Netherlands: http://ams.flashblock.trade
• Frankfurt, Germany: http://fra.flashblock.trade
• Singapore: http://singapore.flashblock.trade
• London, UK: http://london.flashblock.trade

3. Prepare your transaction

Ensure your transaction includes at least a 0.001 SOL tip to one of our tip wallets (10 addresses available below). Pick a random address from the list to distribute load and improve overall efficiency.

FLaShB3iXXTWE1vu9wQsChUKq3HFtpMAhb8kAh1pf1wi
FLashhsorBmM9dLpuq6qATawcpqk1Y2aqaZfkd48iT3W
FLaSHJNm5dWYzEgnHJWWJP5ccu128Mu61NJLxUf7mUXU
FLaSHR4Vv7sttd6TyDF4yR1bJyAxRwWKbohDytEMu3wL
FLASHRzANfcAKDuQ3RXv9hbkBy4WVEKDzoAgxJ56DiE4
FLasHstqx11M8W56zrSEqkCyhMCCpr6ze6Mjdvqope5s
FLAShWTjcweNT4NSotpjpxAkwxUr2we3eXQGhpTVzRwy
FLasHXTqrbNvpWFB6grN47HGZfK6pze9HLNTgbukfPSk
FLAshyAyBcKb39KPxSzXcepiS8iDYUhDGwJcJDPX4g2B
FLAsHZTRcf3Dy1APaz6j74ebdMC6Xx4g6i9YxjyrDybR

4. Send your first transaction

curl -sS -X POST 'http://ny.flashblock.trade/api/v2/submit-batch' \
  -H "Authorization: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  --connect-timeout 5 --max-time 15 \
  -d '{
    "transactions": [
      "your-base64-encoded-transaction"
    ]
  }'

Pricing

We removed monthly fees. A uniform tip of 0.001 SOL is charged. Base users have a fixed 10 TPS. Contact support for higher limits or additional needs.

---

Developers

More examples can be found in our GitHub repo: https://github.com/FlashBlocktrade/submit-examples

Choose your language

• JavaScript/Node.js
• Python
• Rust
• Go

JavaScript/Node.js

const axios = require('axios');

async function sendTransaction(transaction, apiKey) {
  const endpoint = 'http://ny.flashblock.trade/api/v2/submit-batch';
  
  try {
    const response = await axios.post(endpoint, {
      transactions: [transaction] // base64-encoded transaction
    }, {
      headers: {
        'Authorization': apiKey,
        'Content-Type': 'application/json'
      }
    });
    
    return response.data;
  } catch (error) {
    console.error('Failed to send transaction:', error.response?.data || error.message);
    throw error;
  }
}

// Example usage
sendTransaction('your-base64-encoded-transaction', 'YOUR_API_KEY')
  .then(result => console.log('Result:', result))
  .catch(err => console.error('Error:', err));

Python

import requests

def send_transaction(transaction, api_key):
    endpoint = 'http://ny.flashblock.trade/api/v2/submit-batch'
    
    headers = {
        'Authorization': api_key,
        'Content-Type': 'application/json'
    }
    
    payload = {
        'transactions': [transaction]  # base64-encoded transaction
    }
    
    try:
        response = requests.post(endpoint, json=payload, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Failed to send transaction: {e}')
        raise

# Example usage
try:
    result = send_transaction('your-base64-encoded-transaction', 'YOUR_API_KEY')
    print(f'Result: {result}')
except Exception as e:
    print(f'Error: {e}')

Rust

use reqwest::Client;
use serde::{Deserialize, Serialize};
use anyhow::Result;

#[derive(Serialize)]
struct TransactionRequest {
    transactions: Vec<String>,
}

#[derive(Deserialize, Debug)]
struct TransactionResponse {
    success: bool,
    code: u32,
    message: String,
    data: ResponseData,
}

#[derive(Deserialize, Debug)]
struct ResponseData {
    signatures: Vec<String>,
}

async fn send_transaction(transaction: &str, api_key: &str) -> Result<TransactionResponse> {
    let endpoint = "http://ny.flashblock.trade/api/v2/submit-batch";
    
    let client = Client::new();
    let request = TransactionRequest {
        transactions: vec![transaction.to_string()],
    };
    
    let response = client.post(endpoint)
        .header("Authorization", api_key)
        .header("Content-Type", "application/json")
        .json(&request)
        .send()
        .await?
        .json::<TransactionResponse>()
        .await?;
    
    Ok(response)
}

// Example usage
#[tokio::main]
async fn main() -> Result<()> {
    match send_transaction("your-base64-encoded-transaction", "YOUR_API_KEY").await {
        Ok(result) => println!("Result: {:?}", result),
        Err(e) => println!("Error: {}", e),
    }
    
    Ok(())
}

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type TransactionRequest struct {
    Transactions []string `json:"transactions"`
}

type ResponseData struct {
    Signatures []string `json:"signatures"`
}

type TransactionResponse struct {
    Success bool         `json:"success"`
    Code    int          `json:"code"`
    Message string       `json:"message"`
    Data    ResponseData `json:"data"`
}

func sendTransaction(transaction, apiKey string) (*TransactionResponse, error) {
    endpoint := "http://ny.flashblock.trade/api/v2/submit-batch"
    
    request := TransactionRequest{
        Transactions: []string{transaction},
    }
    
    requestBody, err := json.Marshal(request)
    if err != nil {
        return nil, err
    }
    
    client := &http.Client{}
    req, err := http.NewRequest("POST", endpoint, bytes.NewBuffer(requestBody))
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Authorization", apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    var response TransactionResponse
    err = json.Unmarshal(body, &response)
    if err != nil {
        return nil, err
    }
    
    return &response, nil
}

func main() {
    result, err := sendTransaction("your-base64-encoded-transaction", "YOUR_API_KEY")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    fmt.Printf("Result: %+v\n", result)
}

• Further Reading (EN)

• API Usage Guide (EN)

• Error Codes (EN)

• Tip Floor (EN)

---

Advanced Users

Optimize Transaction Handling

• Tip optimization: Higher tips get higher processing priority
• Connection reuse: Use HTTP keep-alive to improve performance

Further Reading (EN)

• FlashBlock API Integrated Guide (EN): Overview of API basics, error codes, connection management, and error handling
• Transaction Optimization Guide (EN): Endpoint selection, tip strategies, network monitoring, and architecture best practices

Performance Monitoring

• Use transaction signatures with the error details API to locate failure reasons
• Monitor submit latency and confirmation time in real time (recommend collecting submit_latency_ms, confirmation_time_ms)
• Analyze success rate and error distribution (success_rate, error_breakdown), and watch P95 confirmation time

Further Reading (EN)

• Performance Monitoring and Advanced Configuration (EN): Metrics, collection suggestions, and overview of retry/timeout/tip strategies
• Get Transaction Error Details (EN): Query failure reasons and messages by transaction signature
• Error Codes (EN): Platform error codes and meanings to locate common problems
• Transaction Optimization Guide (EN): Reduce latency, improve success rate, and optimize costs

Advanced Configuration

• Configure adaptive tip strategy
• Implement retry mechanism
• Set timeout handling

Further Reading (EN)

• Adaptive Tip Strategy (EN): Use Tip Floor and real-time metrics as the baseline to dynamically adjust tips

• Retry Strategy (EN): Exponential backoff, idempotency, and circuit breaking

• Timeout Handling (EN): Recommended connection/overall timeouts and anti-duplication after timeout

• Troubleshooting (EN): Common error diagnosis steps and checklists

• Best Practices (EN): Submission optimization, tip strategies, and connection reuse

• Accelerator Node Benchmark (Rust): Send the same transaction concurrently to multiple accelerators to compare confirmation speed/success rate/latency and output a report to objectively evaluate endpoint performance

• OKX Swap Integration Example (JavaScript): Fetch OKX v0 transactions, parse LUT, prepend tip instructions, recompile and submit to FlashBlock, with configurable TIP_LAMPORTS

• Further Reading (EN)

• API Usage Guide (EN)

• Developer Integration (EN)

• Keep-Alive (EN)

• Error Codes (EN)

• Tip Floor (EN)

---

FAQ

• Q: What is the minimum tip amount?

  • A: 0.001 SOL.

• Q: Why provide multiple tip addresses?

  • A: Multiple addresses help distribute system load and improve processing efficiency. Randomly choose one in your app for best performance.

• Q: How do I get an API key?

  • A: Register and sign in at https://www.flashblock.trade/, then create and retrieve your API key in the dashboard.

• Q: How do I choose the best endpoint?

  • A: Choose the geographically closest endpoint for the lowest latency. See API Usage Guide (EN) for more.

• Q: What should I do if a transaction fails?

  • A: See:
    • Error Codes (EN)
    • Transaction Optimization Guide (EN)
    • API Usage Guide (EN)

  Further Reading

  FAQ