Your first connection

This guide takes you from the access request to your first streamed message and your first transaction sent through Private TPU Send. It takes about 15 minutes once you have your API key.

Before you start

• A server close to our infrastructure. Latency is dominated by physical distance. We run in 7 regions: Frankfurt, Amsterdam, London, Dublin, New York, Tokyo and Singapore. Host your strategy in the region of your endpoints. See Regions & endpoints.
• A synchronized clock. Use NTP, or PTP if your provider offers it, so that latency measurements based on timestamps are meaningful.
• Your own Solana RPC endpoint. Our services provide early data and direct execution. You still need an RPC endpoint for state reads such as getLatestBlockhash, account data and address lookup tables, and for checking transaction status.
• A runtime of your choice. The examples use TypeScript (Node.js 18 or later) and Rust. Any language with gRPC, WebSocket and HTTP support works.

Step 1: Request access

Contact our support on Telegram: @ZoriDev. Describe:

• your strategy type (for example backrunning, arbitrage, liquidations or sniping)
• the services you are interested in
• your expected volume, for example the throughput you need for Private TPU Send
• your preferred region and, if you use IP allowlisting, the public IP addresses of your servers
• for Private Orderflow over gRPC, the address of the gRPC server our relayer should push to (see gRPC push)

We tailor the services to your needs and agree on the price and trial terms individually.

Step 2: Receive your credentials

After activation, which takes a maximum of 24 hours from payment, you receive:

• an API key, for example mev_live_3f9a2c7e1b8d4f60a5c9e2b7d1f4a8c3
• the endpoints of the products in your offer, for your region
• the protocol definitions (.proto files) for gRPC
• for Private Orderflow over gRPC, the identity key of our relayer, to allow in your auth service

Endpoints are not published in these docs. Treat them like your API key and never share them publicly.

Store the key and the endpoints in environment variables. The examples in these docs read them from the names below. Set only the ones for the products in your offer.

export MEV_ALPHA_KEY="mev_live_3f9a2c7e1b8d4f60a5c9e2b7d1f4a8c3"

# Endpoints from your credentials. gRPC endpoints include https:// and the port.
export MEV_ORDERFLOW_WS="..."    # Private Orderflow, WebSocket
export MEV_SEND_URL="..."        # Private TPU Send
export MEV_SHREDS_GRPC="..."     # Shreds, gRPC
export MEV_SHREDS_WS="..."       # Shreds, WebSocket

Step 3: Test the connection

Before writing code, check that your key and network path work.

Private Orderflow over WebSocket (requires wscat, installed with npm install -g wscat):

wscat -c "$MEV_ORDERFLOW_WS" -H "x-api-key: $MEV_ALPHA_KEY"

After the connection opens, messages start arriving. Each message is one JSON object describing a pending transaction. See Private Orderflow for the message format.

Private Orderflow over gRPC: once our support has registered your server, check its logs. You should see our relayer sign in through your auth service, subscribe to your accounts and programs of interest, and start StartExpiringPacketStream. See gRPC push.

Private TPU Send health check:

curl -s "$MEV_SEND_URL" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $MEV_ALPHA_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getHealth"}'

A healthy endpoint responds with {"jsonrpc":"2.0","id":1,"result":"ok"}.

Shreds over WebSocket:

wscat -c "$MEV_SHREDS_WS" -H "x-api-key: $MEV_ALPHA_KEY"

Batches of entries arrive several times per slot while the network is active. See Shreds for the message format.

Step 4: Connect from code

The example below subscribes to Private Orderflow over WebSocket and prints the signature of every new pending transaction.

import WebSocket from "ws";

const ws = new WebSocket(process.env.MEV_ORDERFLOW_WS!, {
  headers: { "x-api-key": process.env.MEV_ALPHA_KEY! },
});

ws.on("open", () => console.log("connected"));
ws.on("message", (data) => {
  const msg = JSON.parse(data.toString());
  console.log(msg.slot, msg.signature);
});
ws.on("close", (code, reason) => console.log("closed", code, reason.toString()));

For production-grade clients with reconnection and deduplication, and for gRPC delivery to your own server, see Private Orderflow. To send transactions, see Private TPU Send. For block data, see Shreds.

Step 5: Verify

• The connection is established and stays open, with keepalive configured.
• Messages arrive continuously while the network is active.
• Your consumer keeps up with the stream: the internal queue does not grow over time.
• Transactions sent through Private TPU Send reach the expected commitment level when checked through your RPC.
• Latency measured from your server matches your expectations. See Latency & benchmarking.

If something does not work as expected, see Troubleshooting and Errors.

Next steps

• Read How it works to understand where each service sits in the life of a transaction.
• Go through the Production checklist before going live.