sendTransaction RPC Method

Protect your transactions from toxic MEV threats like sandwich attacks and front-running, by enabling the Solana MEV Protection & Recovery add-on on your QuickNode endpoint. To learn more about MEV and how to protect your transactions on Solana, check out our guide: What is MEV (Maximum Extractable Value) and How to Protect Your Transactions on Solana.

Parameters

transaction

string

object

skipPreflight

boolean

preflightCommitment

string

encoding

string

maxRetries

usize

minContextSlot

integer

Returns

result

Request

curl https://docs-demo.solana-mainnet.quiknode.pro/ \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{"method":"sendTransaction","params":["ENTER_ENCODED_TRANSACTION_ID"],"id":1,"jsonrpc":"2.0"}'

require "uri"
require "json"
require "net/http"

url = URI("https://docs-demo.solana-mainnet.quiknode.pro/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "method": "sendTransaction",
  "params": [
    "ENTER_ENCODED_TRANSACTION_ID"
  ],
  "id": 1,
  "jsonrpc": "2.0"
})

response = https.request(request)
puts response.read_body

import {
    createSolanaRpc,
    generateKeyPairSigner,
    lamports,
    sendAndConfirmTransactionFactory,
    pipe,
    createTransactionMessage,
    setTransactionMessageFeePayer,
    setTransactionMessageLifetimeUsingBlockhash,
    appendTransactionMessageInstruction,
    signTransactionMessageWithSigners,
    getSignatureFromTransaction,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";

const LAMPORTS_PER_SOL = BigInt(1_000_000_000);

(async () => {
    try {

        const rpc = createSolanaRpc("https://docs-demo.solana-mainnet.quiknode.pro/");

        // 2 - Generate signers
        const user1 = await generateKeyPairSigner();
        console.log(`✅ - New user1 address created: ${user1.address}`);

        const user2 = await generateKeyPairSigner();
        console.log(`✅ - New user2 address created: ${user2.address}`);

        // 3 - Airdrop SOL to user1
        const airdropTx = await rpc.requestAirdrop(
            user1.address,
            lamports(LAMPORTS_PER_SOL),
            { commitment: 'processed' }
        ).send();
        console.log(`✅ - Airdropped 1 SOL to user1. Transaction: ${airdropTx}`);

        // 4 - Create transfer transaction
        const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
        const transactionMessage = pipe(
            createTransactionMessage({ version: 0 }),
            tx => setTransactionMessageFeePayer(user1.address, tx),
            tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
            tx => appendTransactionMessageInstruction(
                getTransferSolInstruction({
                    amount: lamports(LAMPORTS_PER_SOL / BigInt(2)),
                    destination: user2.address,
                    source: user1,
                }),
                tx
            )
        );

        // 5 - Sign and send transaction
        const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
        const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });

        await sendAndConfirmTransaction(
            signedTransaction,
            { commitment: 'confirmed', skipPreflight: true }
        );

        const signature = getSignatureFromTransaction(signedTransaction);
        console.log(`✅ - Transfer transaction signature: ${signature}`);
    } catch (error) {
        console.error('Error occurred:', error);
    }
})();

const web3 = require("@solana/web3.js");
(async () => {
  const solana = new web3.Connection("https://docs-demo.solana-mainnet.quiknode.pro/");
  // Replace fromWallet with your public/secret keypair, wallet must have funds to pay transaction fees.
  const fromWallet = web3.Keypair.generate();
  const toWallet = web3.Keypair.generate();
  const transaction = new web3.Transaction().add(
    web3.SystemProgram.transfer({
      fromPubkey: fromWallet.publicKey,
      toPubkey: toWallet.publicKey,
      lamports: web3.LAMPORTS_PER_SOL / 100,
    })
  );
  console.log(await solana.sendTransaction(transaction, [fromWallet]));
})();

from solana.rpc.api import Client
from solana.account import Account
from solana.system_program import TransferParams, transfer
from solana.transaction import Transaction
#Make sure to paste sender, reciever addresses and public key.
solana_client = Client("https://docs-demo.solana-mainnet.quiknode.pro/")
sender, reciever = Account(1), Account(2)
json_request = solana_client.get_recent_blockhash()
recent_blockhash = json_request["result"]["value"]["blockhash"]
txn = Transaction(fee_payer=sender.public_key(), recent_blockhash=recent_blockhash)
txn.add(
    transfer(
        TransferParams(
            from_pubkey=sender.public_key(),
            to_pubkey=reciever.public_key(), 
            lamports=1000
        )
    )
)
txn.sign(sender)
print(solana_client.send_transaction(txn, sender))

use reqwest::header;
use reqwest::Client;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let mut headers = header::HeaderMap::new();
    headers.insert("Content-Type", "application/json".parse().unwrap());

    let client = Client::new();
    let json_data = r#"
    {
        "method": "sendTransaction",
        "params": [
            "ENTER_ENCODED_TRANSACTION_ID"
        ],
        "id": 1,
        "jsonrpc": "2.0"
    }
    "#;
    let response = client
        .post("https://docs-demo.solana-mainnet.quiknode.pro/")
        .headers(headers)
        .body(json_data)
        .send()
        .await?; 

    let body = response.text().await?;
    println!("{}", body);

    Ok(())
}

Response

{
  "jsonrpc": "2.0",
  "result": "2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb",
  "id": 1
}

Don't have an account yet?

Create your QuickNode endpoint in seconds and start building

Get started for free

sendTransaction RPC Method

Loading...

Parameters

Returns