eth_sendRawTransaction — Ethereum JSON-RPC

eth_sendRawTransaction submits an already-signed transaction to the network for inclusion in a block. You sign the transaction locally with your private key, RLP-encode it, hex-encode the result, and pass that single hex string as the only parameter. Triport never sees or holds your key — only the signed payload.

On success the method returns the transaction hash immediately. This hash is returned as soon as the transaction is accepted into the mempool; it does not mean the transaction has been mined. Poll eth_getTransactionReceipt with the returned hash to confirm inclusion and read the final status.

This is the only state-changing method in the eth read namespace, and it sits in its own eth_send_tx rate-limit category with markedly lower limits than read methods (3 RPS on free vs. 10+ RPS for reads). Budget your send rate accordingly and back off on HTTP 429. The method is available from the Free trial upward — no paid tier is required to broadcast transactions.

A single positional parameter:

Response fields

Errors arrive in the standard JSON-RPC error object, with extra fields under error.data. See Errors for both response shapes.

rate_limited (HTTP 429)

{
  "error": "rate_limited",
  "message": "Rate limit reached: your free plan allows 3 requests/s for eth_send_tx. Retry in 1s (see the Retry-After header) or upgrade for a higher limit at https://triport.io/app/pricing",
  "current_tier": "free",
  "category": "eth_send_tx",
  "limit_rps": 3,
  "burst_capacity": 6,
  "retry_after_sec": 1,
  "upgrade_url": "https://triport.io/app/pricing",
  "docs_url": "https://triport.io/errors/http-429-rate-limit"
}

burst_capacity is always 2 × limit_rps. The response also carries Retry-After and X-RateLimit-* headers — see Errors.

JavaScript (fetch)

const signedTx = "0xf86b808504a817c8..."; // produced by your signer


const res = await fetch("https://triport.io/eth", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.TRIPORT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_sendRawTransaction",
    params: [signedTx],
  }),
});


const body = await res.json();
if (!res.ok) {
  // Product errors are plain HTTP: `error` is a string code, fields at top level.
  if (body.error === "rate_limited") {
    const wait = Number(res.headers.get("Retry-After") ?? body.retry_after_sec);
    await new Promise((r) => setTimeout(r, wait * 1000)); // then retry
  } else {
    throw new Error(body.message ?? `HTTP ${res.status}`);
  }
} else if (body.error) {
  throw new Error(body.error.message); // JSON-RPC error from the node, e.g. nonce too low
} else {
  console.log("tx hash:", body.result);
}

• The hash is not confirmation. A returned hash means accepted into the mempool, not mined. Poll eth_getTransactionReceipt until a receipt appears, then check its status field.
• Idempotent re-broadcast. Re-submitting the same signed transaction usually yields the same hash; the network may return an already known execution error (-32000), which is harmless.
• Sign locally. Build and sign with a client library (ethers, viem, web3.py); only the resulting hex string is sent here.
• Low send budget. The eth_send_tx category caps sends well below read methods. For high-throughput or MEV use cases, see the private RPC forwarder (eth_sendBundle is not served on this endpoint).
• See also: Errors · Rate limits · Authentication.