1 of 7

Block0 Docs

Introduction

Execute Blazing Fast Solana Transactions

This service provides exceptional transaction speed, reliability, and efficiency for a variety of blockchain participants. Below is a comprehensive breakdown of who can benefit most from these capabilities.

Sniper Bot Operators

Advanced traders utilizing sniper bots can gain a critical competitive edge by leveraging our infrastructure to execute transactions with minimal latency. This enables them to secure tokens and participate in mints before competitors, maximizing opportunities in fast-moving markets where milliseconds matter.

Active Traders

For traders focused on capturing market opportunities with precision timing, our service delivers the execution speed necessary to capitalize on momentary price discrepancies. This enhanced performance allows traders to enter and exit positions with greater confidence, reducing the risk of missed opportunities due to network congestion.

DeFi Protocol Developers

User Experience Optimization

DeFi application developers can significantly enhance their user experience by integrating our service. By reducing transaction stalls and failures, your application can provide a smoother, more reliable experience that builds user trust and satisfaction. This reliability is particularly crucial during high network activity periods when standard connections may become overwhelmed.

Specialized Market Participants

Liquidation Specialists

For participants focused on liquidation opportunities, being first to execute a liquidation transaction can mean the difference between profit and missed opportunity. Our service provides the speed advantage necessary to consistently be at the front of the queue when liquidation events occur.

Conclusion

Our high-performance infrastructure is specifically designed for blockchain participants who require exceptional transaction speed, reliability, and efficiency. By eliminating common points of failure and optimizing transaction pathways, we provide the competitive edge necessary for success in the fast-paced blockchain ecosystem.

Integration

Direct HTTP:

London, England: http://lon.block0.wtf Frankfurt, Germany: http://fra.block0.wtf New York City, USA: http://ny.block0.wtf

HTTP Post Body:

Transaction Tips:

Every transaction on Solana must include a system transfer instruction to the Block0 tip address, with a minimum tip of 0.001 SOL. Adding a higher tip increases your transaction's priority in the queue, meaning it will be processed faster.

Tip Addresses:

Send your tip to any one of these 11 addresses below.

Tip Minimum: 0.001 SOL. Higher Tip = Land Faster.

Rate Limit:

The Standard Rate limit is 5 TPS, if you require higher rate limit please contact us via .

RUST

async fn submit_solana_transaction(base64_tx: &str) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
    let client = reqwest::Client::new();
    
    let response = client
        .post("http://lon.block0.wtf/")
        .header("Content-Type", "application/json")
        .json(&serde_json::json!({
            "base64_tx": base64_tx
        }))
        .send()
        .await?;
    
    if !response.status().is_success() {
        return Err(format!("Request failed with status {}", response.status()).into());
    }
    
    let response_text = response.text().await?;
    Ok(response_text)
}

Python

def make_request(base64_tx: str) -> Dict[str, Any]:
    url = "http://lon.block0.wtf/"
    headers = {"Content-Type": "application/json"}
    payload = {
        "base64_tx": base64_tx
    }
    
    try:
        response = requests.post(url, headers=headers, json=payload)
        return {
            "status_code": response.status_code,
            "text": response.text,
            "success": True
        }
    except Exception as e:
        return {
            "error": str(e),
            "success": False
        }

Typescript

Javascript

JavaScript (using fetch)

async function makeRequest() {
  const url = "http://lon.block0.wtf/";
  const payload = {
    base64_tx: "<BASE64_ENCODED_TRANSACTION>"
  };
  
  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify(payload)
    });
    
    const data = await response.text();
    console.log(`Status: ${response.status}`);
    console.log(`Response: ${data}`);
  } catch (error) {
    console.error("Error:", error);
  }
}

Javascript (using axios)

const axios = require('axios');

async function makeRequestWithAxios() {
  const url = "http://lon.block0.wtf/";
  const payload = {
    base64_tx: "<BASE64_ENCODED_TRANSACTION>"
  };
  
  try {
    const response = await axios.post(url, payload, {
      headers: {
        "Content-Type": "application/json"
      }
    });
    
    console.log(`Status: ${response.status}`);
    console.log(`Response: ${response.data}`);
  } catch (error) {
    console.error("Error:", error.message);
  }
}

CURL

curl http://lon.block0.wtf/ \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "base64_tx": "<BASE64_ENCODED_TRANSACTION>"
  }'

Javascript

JavaScript (using fetch)

async function makeRequest() {
  const url = "http://lon.block0.wtf/";
  const payload = {
    base64_tx: "<BASE64_ENCODED_TRANSACTION>"
  };
  
  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify(payload)
    });
    
    const data = await response.text();
    console.log(`Status: ${response.status}`);
    console.log(`Response: ${data}`);
  } catch (error) {
    console.error("Error:", error);
  }
}

Javascript (using axios)

const axios = require('axios');

async function makeRequestWithAxios() {
  const url = "http://lon.block0.wtf/";
  const payload = {
    base64_tx: "<BASE64_ENCODED_TRANSACTION>"
  };
  
  try {
    const response = await axios.post(url, payload, {
      headers: {
        "Content-Type": "application/json"
      }
    });
    
    console.log(`Status: ${response.status}`);
    console.log(`Response: ${response.data}`);
  } catch (error) {
    console.error("Error:", error.message);
  }
}