Solana Payment Integration for High-Volume Marketplaces

We help businesses with Solana payment integration for high-volume marketplaces, enabling fast, low-fee crypto payments. Solana Pay is the key tool, but its integration requires understanding transaction mechanics, finality, and security. Let's dive into a real project: setting up a Solana payment g

Blockchain Development Services

Frequently Asked Questions

Latest works

  • image_website-b2b-advance_0.webp
    B2B ADVANCE company website development
    1450
  • image_web-applications_feedme_466_0.webp
    Development of a web application for FEEDME
    1308
  • image_websites_belfingroup_462_0.webp
    Website development for BELFINGROUP
    1003
  • image_ecommerce_furnoro_435_0.webp
    Development of an online store for the company FURNORO
    1269
  • image_logo-advance_0.webp
    B2B Advance company logo design
    717
  • image_crm_enviok_479_0.webp
    Development of a web application for Enviok
    1008

We help businesses with Solana payment integration for high-volume marketplaces, enabling fast, low-fee crypto payments. Solana Pay is the key tool, but its integration requires understanding transaction mechanics, finality, and security. Let's dive into a real project: setting up a Solana payment gateway for a marketplace with over $50,000 monthly turnover. Since 2019, we have integrated Solana Pay for 30+ projects, gaining experience in high-load systems.

If you want to accept Solana on your website, the specificity of Solana payments is that there is no native "payment request" standard like BIP-21 (Bitcoin) or EIP-681 (Ethereum). Instead, there is Solana Pay — an open protocol developed by Solana Labs that covers most payment use cases: simple SOL transfers, SPL token payments, and transactional requests with arbitrary backend logic.

How Solana Pay Works

Solana Pay uses the solana: URL scheme encoded in a QR code. The wallet recognizes the URL and shows the user details: recipient, amount, token. For integration, you only need to generate such a URL on the backend and display the QR. Payment verification is done by searching for a reference public key in the blockchain.

Solana Pay: Transfer Request

The simplest scenario is a request to transfer a fixed amount of SOL or SPL token. The URL scheme:

solana:<recipient>?amount=<value>&label=<label>&message=<message>&memo=<memo> 

Example for paying 10 USDC:

solana:7Np41RSSZFkBmBUkVBntbRMzEnbZBqVkjFEf3BQnkGTi?amount=10&spl-token=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&label=MyShop&message=Order%20%2312345&memo=ORDER-12345 

spl-token is the mint address of USDC on mainnet. memo is an arbitrary string recorded on-chain via the Memo program, used for order reconciliation.

This URL is encoded into a QR code. Wallets supporting Solana Pay (Phantom, Solflare, Backpack) automatically parse it and show the payment details. The generated Solana Pay QR code is embedded in your checkout page for seamless scanning.

Generating QR on the Backend

import { encodeURL, createQR, TransferRequestURLFields, } from "@solana/pay"; import { PublicKey } from "@solana/web3.js"; import BigNumber from "bignumber.js"; function createPaymentRequest(orderId: string, amountUSDC: number) { const recipient = new PublicKey("YOUR_MERCHANT_WALLET"); const splToken = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); const urlFields: TransferRequestURLFields = { recipient, amount: new BigNumber(amountUSDC), splToken, label: "MyShop", message: `Order #${orderId}`, memo: orderId, }; const url = encodeURL(urlFields); const qrCode = createQR(url, 360, "transparent"); return { url: url.toString(), qrCode }; } 

Payment Verification

After displaying the QR, you need to confirm payment. The Solana Pay API (SDK) provides findReference — a function to search for a transaction by reference public key (a unique key added to each payment):

import { findReference, validateTransfer } from "@solana/pay"; import { Connection, clusterApiUrl, Keypair } from "@solana/web3.js"; const connection = new Connection(clusterApiUrl("mainnet-beta"), "confirmed"); // reference — unique keypair for each order const reference = Keypair.generate().publicKey; // Polling every 2 seconds async function pollForPayment(reference: PublicKey, expectedAmount: BigNumber) { while (true) { try { const signatureInfo = await findReference(connection, reference, { finality: "confirmed", }); await validateTransfer(connection, signatureInfo.signature, { recipient: MERCHANT_WALLET, amount: expectedAmount, splToken: USDC_MINT, reference, }); return signatureInfo.signature; // payment confirmed } catch (e) { // FindReferenceError — transaction not yet seen await new Promise((r) => setTimeout(r, 2000)); } } } 

validateTransfer checks: correct recipient, correct amount, correct token. If anything mismatches, it throws an exception. This protects against paying with a "similar" transaction.

Why Solana Suits Merchants?

Transactions confirm in 2–3 seconds, with fees around $0.00025. This makes Solana ideal for micro-payments and high-load systems like NFT marketplaces or gaming platforms. With proper configuration, failures are nearly eliminated. Solana crypto payments for business are fast and cheap. Solana Pay supports SPL token payments for a variety of digital assets. Compared to traditional bank gateways, Solana Pay integrates 5 times faster and saves up to 95% on fees. As a Solana merchant, you can leverage the Solana Pay API for efficient transaction processing.

Choosing the Right Finality Level

Solana does not have probabilistic finality like Bitcoin. Here are the levels:

See Finality Levels Comparison
Level Time Description When to Use
processed <0.5 sec Transaction included in block, possible rollback Never for payments
confirmed 1-3 sec Block has >66% supermajority votes Default for amounts up to $10,000
finalized 10-15 sec Block is in rooted chain, no rollback possible Large amounts or legal requirements

According to the Solana documentation, 'confirmed' finality is achieved in 1-3 seconds.

For payments, use confirmed — it balances speed and security. Understanding Solana transaction finality helps select the right level for your needs.

Comparison with Other Solutions

Criterion Solana Pay Tron USDT (TRC-20) Stripe Crypto
Confirmation time 2-3 seconds ~1 min up to 5 min
Fee ~$0.00025 $0.5-1 ~$0.75 + 1%
Token support Any SPL USDT/USDC BTC/ETH/USDC
Integration complexity Low (SDK) Medium (API) Medium (API)

Solana Pay confirms transactions 5 times faster than Tron USDT and 100 times cheaper than Stripe. For efficient Solana payment processing, choose confirmed finality.

Process and Timelines

What's Included in a Turnkey Solution

  • Architecture design: choosing RPC (Helius, QuickNode), setting up merchant wallet (hardware or multisig).
  • API development for generating payment requests with unique references.
  • Integration of polling or WebSocket for confirmation monitoring.
  • Storing transaction signatures in a database for audit and reconciliation.
  • Handling timeouts (we recommend 2 minutes, then show an error).
  • Documentation and team training.

Work Process

  1. Analysis: understand business requirements, select tokens and tech stack.
  2. Design: payment flow scheme, RPC selection, security configuration.
  3. Implementation: integrate Solana Pay, generate QR, implement verification.
  4. Testing: simulate payments, test all edge cases.
  5. Deployment: configure production RPC, monitoring, documentation.

Timelines

Typically, integration takes 3 to 10 business days, depending on complexity (number of tokens, need for multisig, security level). We can estimate your project for free.

How We Ensure Security?

We guarantee that all outgoing transactions are signed only after verification via validateTransfer. A unique reference is generated for each order, preventing reuse. The merchant wallet is isolated from the server — only confirmed payment transactions are signed.

Common Pitfalls (Checklist)

  • Unique references: never reuse a reference keypair across orders — it breaks reconciliation and can lead to double-spending.
  • Memo handling: always include a memo field that uniquely identifies the order; without it, matching payments to orders becomes fragile.
  • RPC throttling: in production, use a dedicated RPC provider with high rate limits; shared public RPCs can timeout or drop requests.
  • Signature verification: always call validateTransfer; trusting only findReference can miss malformed transactions.
  • Timeout strategy: set a reasonable timeout (2 minutes) and display a clear error; don't let users wonder.

Tell us about your tasks — our Solana-certified engineers can set up payment acceptance in 1-2 weeks. Contact us for a free consultation. Order your Solana Pay integration today.