Submit a Transaction

Use this endpoint to send a single transaction faster than the p2p network using the BDN.

REQUEST

Method: blxr_tx

Parameters

Parameter

Description

Instructions & Notes

transaction

Raw transactions bytes without 0x prefix.

Mandatory. Learn more about constructing the transaction here.

blockchain_network

Blockchain network name.

Optional. Default: Mainnet

Available options are: Mainnet for ETH Mainnet, BSC-Mainnet for BSC Mainnet

*Use with Cloud-API when working with BSC.

node_validation

Transaction is sent to the blockchain node for validation, and the Gateway returns any error message received in response.

Available only with Gateway API

Optional

Default: False

backrunme_reward_address

String; valid ETH address which defines the address with which backrun rewards should be shared

Optional; this param is only for BSC

Cloud-API

WebSocket endpoint for sending transactions: wss://api.blxrbdn.com/ws All users sending transactions via WebSocket should use this endpoint.
HTTP/HTTPS POST endpoints:
- HTTPS: https://api.blxrbdn.com
- HTTP: http://api.blxrbdn.com
See Cloud-API IPs to work directly with IP addresses:
- WebSocket: wss://<IP>/ws
- HTTP/HTTPS: http://<IP> or https://<IP>

For latency-sensitive orderflow, WebSocket is recommended and can provide latency improvement over HTTP/HTTPS. If you prefer to short-lived connections, use HTTP over HTTPS for improved latency.

Examples

# ETH Example
wscat -c wss://api.blxrbdn.com/ws --header "Authorization: <YOUR-AUTHORIZATION-HEADER>"
> {"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params":
   {"transaction": "f86b0184...e0b58219"}}
< ......

# BSC Example
wscat -c wss://api.blxrbdn.com/ws --header "Authorization: <YOUR-AUTHORIZATION-HEADER>"
> {"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": 
  {"transaction": "f86b0184...e0b58219",
   "blockchain_network": "BSC-Mainnet"}}
< ....

const WebSocket = require('ws');

const ws = new WebSocket(
  "wss://api.blxrbdn.com/ws", 
  {
    headers: { 
      "Authorization" : <YOUR-AUTHORIZATION-HEADER>  
    },
    rejectUnauthorized: false,
  }
);

function proceed() {
    // ETH Example
    ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}}`);
    // BSC Example
    // ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}}`);
    //
    // or use a variable for the transaction string:
    // rawTx = "f86b0184...e0b58219";
    // ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "${rawTx}"}}`);
}


function handle(response) {
    console.log(response.toString()); // or process it generally
}

ws.on('open', proceed);
ws.on('message', handle);

# Python 3.7 or higher required due to the use of asyncio.run()
import asyncio, json, ssl
from websocket import create_connection

async def main():
    try:
        ws = create_connection('wss://api.blxrbdn.com/ws',
                               header=["Authorization:{}".format("YOUR_AUTHORIZATION_HEADER")],
                               sslopt={"cert_reqs": ssl.CERT_NONE})
        # ETH Example
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}})
        
        # BSC Example
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}})
        
        ws.send(str(request))
        while True:
            response = json.loads(ws.recv())
            print(response) # or process it generally
    except Exception as e:
        print(f'Connection failed, Reason: {e}')


if __name__ == '__main__':
    asyncio.run(main()

package main

import (
	"crypto/tls"
	"fmt"
	"github.com/gorilla/websocket"
	"net/http"
)

func main() {
	tlsConfig := &tls.Config{
		InsecureSkipVerify: true,
	}
	dialer := websocket.DefaultDialer
	dialer.TLSClientConfig = tlsConfig
	wsSubscriber, _, err := dialer.Dial("wss://api.blxrbdn.com/ws", http.Header{"Authorization": []string{<YOUR-AUTHORIZATION-HEADER>}})

	if err != nil {
		fmt.Println(err)
		return
	}

        // ETH Example
	request := `{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}}`
        // BSC Example
        // request := `{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}}`
	err = wsSubscriber.WriteMessage(websocket.TextMessage, []byte(request))
	if err != nil {
		fmt.Println(err)
		return
	}

	_, response, err := wsSubscriber.ReadMessage()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(response)) // or process it generally
}

# ETH Example
curl https://api.blxrbdn.com \
    -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: <YOUR-AUTHORIZATION-HEADER>" \
    -d '{"method": "blxr_tx", "id": "1", "params": {"transaction": "f86b0184...e0b58219"}}'

# BSC Example
curl https://api.blxrbdn.com \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: <YOUR-AUTHORIZATION-HEADER>" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "blxr_tx",
    "params": {
      "transaction": "f86b0184...e0b58219",
      "blockchain_network": "BSC-Mainnet",
      "backrunme_reward_address": "0xYourRewardAddressHere"
    }
  }'

Gateway-API:

Gateway WebSocket endpoint: ws://127.0.0.1:28333/ws
We assume the WebSocket port 28333.
Please check Authorization Headers examples to reconstruct the header.

Examples

# ETH Example
wscat -c ws://127.0.0.1:28333/ws --header "Authorization: <YOUR-AUTHORIZATION-HEADER>"
> {"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params":
   {"transaction": "f86b0184...e0b58219"}}
< ......

# BSC Example
wscat -c ws://127.0.0.1:28333/ws --header "Authorization: <YOUR-AUTHORIZATION-HEADER>"
> {"jsonrpc":"2.0","id":1,"method":"blxr_tx","params":{"transaction":"f86b0184...e0b58219","blockchain_network":"BSC-Mainnet","backrunme_reward_address":"0xYourRewardAddressHere"}}

const WebSocket = require('ws');

const ws = new WebSocket(
  "ws://127.0.0.1:28333/ws", 
  {
    headers: { 
      "Authorization" : <YOUR-AUTHORIZATION-HEADER>
    },
    rejectUnauthorized: false,
  }
);

function proceed() {
    // ETH Example
    ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}}`);
    // BSC Example
    // ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}}`);
    //
    // or use a variable for the transaction string:
    // rawTx = "f86b0184...e0b58219";
    // ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "${rawTx}"}}`);
}


function handle(response) {
    console.log(response.toString()); // or process it generally
}

ws.on('open', proceed);
ws.on('message', handle);

# Python 3.7 or higher required due to the use of asyncio.run()
import asyncio, json, ssl
from websocket import create_connection

async def main():
    try:
        ws = create_connection('ws://127.0.0.1:28333/ws',
                               header=["Authorization:{}".format("YOUR_AUTHORIZATION_HEADER")],
                               sslopt={"cert_reqs": ssl.CERT_NONE})
        # ETH Example
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}})
        
        # BSC Example
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}})
        
        ws.send(str(request))
        while True:
            response = json.loads(ws.recv())
            print(response) # or process it generally
    except Exception as e:
        print(f'Connection failed, Reason: {e}')

package main

import (
	"crypto/tls"
	"fmt"
	"github.com/gorilla/websocket"
	"net/http"
)

func main() {
	tlsConfig := &tls.Config{
		InsecureSkipVerify: true,
	}
	dialer := websocket.DefaultDialer
	dialer.TLSClientConfig = tlsConfig
	wsSubscriber, _, err := dialer.Dial("ws://127.0.0.1:28333/ws", http.Header{"Authorization": []string{<YOUR-AUTHORIZATION-HEADER>}})

	if err != nil {
		fmt.Println(err)
		return
	}

  // ETH Example
	request := `{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}}`
  // BSC Example
  // request := `{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}}`
	err = wsSubscriber.WriteMessage(websocket.TextMessage, []byte(request))
	if err != nil {
		fmt.Println(err)
		return
	}

	_, response, err := wsSubscriber.ReadMessage()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(response)) // or process it generally
}

RESPONSE

Result Fields

Result Field

Description

tx_hash

Transaction hash

Examples

{
    "jsonrpc": "2.0", 
    "id": "1", 
    "result": {
        "tx_hash": "ffd59870844e5...bfa54a69"
    }
}

Example - gRPC

package main

import (
	"context"
	"fmt"
	"time"
	
	pb "github.com/bloXroute-Labs/bxgateway-private-go/bxgateway/v2/protobuf"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
)

func main() {
	// gRPC server default values
	gatewayHostIP := "127.0.0.1"
	gatewayGRPCPort := 5001
	
	// this will use localhost CA to verify the certificate
	creds := credentials.NewClientTLSFromCert(nil, "")

	// Open gRPC connection to Gateway.
	conn, _ := grpc.Dial(
		fmt.Sprintf("%v:%v", gatewayHostIP, gatewayGRPCPort), 
		grpc.WithTransportCredentials(creds),
	)

	// Use the Gateway client connection interface. 
	client := pb.NewGatewayClient(conn)
	
	// create context and defer cancel of context
	callContext, cancel := context.WithTimeout(context.Background(), 24*time.Hour)
	defer cancel()
	
	// send tx
	reply, err := client.BlxrTx(callContext, &pb.BlxrTxRequest{AuthHeader: "<YOUR-AUTHORIZATION-HEADER>", Transaction: "f86b0184...e0b58219"})
	if err != nil {
		print(err)
		return
	}
	
	txHash := reply.TxHash
	print(txHash) // or process it generally
}

NOTES

All Users

Sending Transactions to the Cloud-API or Gateway-API requires you to register an account on the bloXroute portal. During the registration process, a certificate, private key, and secret hash will be generated for your account. The certificate and key will be used to authenticate your account.

The bloXroute best practice is for users to send transactions to both the Gateway-API and to their blockchain node. You should send transactions in parallel to the Gateway and to your blockchain node as a backup.

Users should not send transactions to the transactions streams WebSocket endpoint wss://<REGION>.<NETWORK>.blxrbdn.com/ws(e.g.wss://virginia.eth.blxrbdn.com/ws) which is for streaming only and doesn't support sending transactions.

Rate Limit

Plan

Request Rate Limit

Ultra

200 transactions every 5 second

Enterprise-Elite

100 transactions every 5 second

Enterprise

50 transactions every 5 second

Professional

10 transaction every 5 seconds

Introductory

10 transaction every 5 seconds

PreviousCheck Transaction Quota NextRaw Transaction Construction

Last updated 2 days ago