Send Transaction

Submit any signed Solana transaction through Venum's landing fan-out. No quote required.

Requires API key.

Similar to a hosted sendTransaction surface, but routed through Venum's configured landing channels rather than a single RPC endpoint.

POST /v1/send

/v1/send accepts either JSON or raw signed transaction bytes.

JSON request:

{
  "transaction": "AQAAAA...base64-encoded-signed-transaction...=="
}

Binary request:

POST /v1/send
Content-Type: application/octet-stream
x-api-key: YOUR_API_KEY

<raw signed transaction bytes>

X-Senders — channel filter

By default, /v1/send fans your transaction out across every configured landing channel for maximum landing rate. If you need stricter routing — e.g. private send (skip every channel that lets RPC operators see your transaction) — pass an X-Senders header.

Channels (4): tpu, jito, secondary, rpc.

• tpu — direct submission to the current slot leader. RPC operators are not on this path.
• jito — submission via Jito's block engine.
• secondary — specialized low-latency sender path.
• rpc — standard JSON-RPC sendTransaction via Venum RPC.

Inclusion form — only the listed channels are used:

X-Senders: tpu                # only direct-to-leader (private send)
X-Senders: tpu,jito           # direct-to-leader + Jito
X-Senders: jito,helius,rpc    # everything except TPU

Exclusion form — every channel except the ones prefixed with -:

X-Senders: -rpc               # everything except RPC operators (broadest "private send")
X-Senders: -rpc,-secondary    # only TPU + Jito

Rules:

• Empty / missing header → all channels (default fan-out).
• Mixing inclusion and exclusion tokens in the same header is rejected with 400 Invalid X-Senders.
• Unknown channel names are rejected with 400 Invalid X-Senders.

The trade-off for narrowing the channel set is landing rate: fewer channels means fewer chances for a single submission to land. Use the default fan-out for high-availability flows; use X-Senders: tpu (or -rpc) for private-send flows where keeping the transaction off RPC-operator-watched paths matters more than redundancy.

Response (success):

{
  "signature": "5Kx9abc...3nF",
  "status": "submitted",
  "jito": false,
  "rpc": true,
  "submittedAt": 1712000000000
}

Response (unsigned):

{
  "error": "Transaction is not signed"
}

Fields:

Field	Description
signature	Transaction signature (base58)
status	Always "submitted" — does not wait for confirmation
jito	Whether the response includes a synchronous Jito acknowledgement. This may be false when no synchronous acknowledgement is returned.
rpc	Whether the submit path returned a local RPC-side signature
submittedAt	UNIX millisecond timestamp at which submission completed

vs /v1/swap and /v1/bundle

	/v1/swap	/v1/send	/v1/bundle
Requires quoteId	Yes	No	No
Quote-bound validation	Yes	No	No
Accepts any TX	No (must match quote)	Yes	Yes (1–5 atomic)
Landing path	Quote-bound fan-out	Raw fan-out	Jito atomic bundle
Atomicity across multiple txs	n/a (single tx)	n/a (single tx)	All-or-nothing
Use case	Venum-built swap TXs	Any single transaction	Atomic multi-leg flows

For atomic multi-tx submission (sandwich-resistant ordering, multi-step DeFi flows that must commit together), use /v1/bundle — it routes the bundle through Jito's block engine and returns a bundleId plus per-tx signatures.

Use Cases

• Bot builders: Build your own transactions, use Venum for a single submission surface
• CEX-DEX arb: Build swap via /v1/swap/build, sign locally, submit via /v1/send
• Custom TXs: Multi-instruction transactions, CPI calls, anything that needs frontrun protection

Example

// Build a swap
const { transaction } = await fetch('https://api.venum.dev/v1/swap/build', {
  method: 'POST',
  headers: { 'x-api-key': key, 'Content-Type': 'application/json' },
  body: JSON.stringify({ inputMint, outputMint, amount, slippageBps: 50, userPublicKey }),
}).then(r => r.json());

// Sign locally
const tx = VersionedTransaction.deserialize(Buffer.from(transaction, 'base64'));
tx.sign([wallet]);

// Submit via Venum
const result = await fetch('https://api.venum.dev/v1/send', {
  method: 'POST',
  headers: { 'x-api-key': key, 'Content-Type': 'application/json' },
  body: JSON.stringify({ transaction: Buffer.from(tx.serialize()).toString('base64') }),
}).then(r => r.json());

console.log(result.signature); // Track on-chain

Binary Example

const tx = VersionedTransaction.deserialize(unsignedBytes)
const signed = await wallet.signTransaction(tx)

const result = await fetch('https://api.venum.dev/v1/send', {
  method: 'POST',
  headers: {
    'content-type': 'application/octet-stream',
    'x-api-key': key,
  },
  body: signed.serialize(),
}).then((r) => r.json())

Rate Limit

See Plans & Rate Limits for the current per-tier limits.