How to Accept TON Payments in a Telegram Bot — 2026 Business Guide

TL;DR. In 2026 there are five working ways to accept TON inside a Telegram bot: Crypto Pay (Crypto Bot), Wallet Pay (Wallet in Telegram), xRocket Pay, custom TON Connect 2.0, and Stars → TON conversion. Each targets a different stage — from 30-minute MVP to production marketplace with seven-figure turnover. Fees range 0-2%, integration time 30 minutes to several weeks. Pick by load profile, currency mix and payout needs — not by UI taste.

Why accept TON when Stars exist

Telegram Stars is the official in-app currency. Convenient for in-platform micro-purchases. But Stars have hard limits:

• Apple/Google take 30% on Stars purchases in-app.
• Stars-to-fiat withdrawal via Fragment is limited and ~30% fee.
• Stars don’t work as a bot-to-user settlement outside of “TG micro-payment” patterns.

TON addresses all of this:

• Network fee 0.05 TON (~$0.20) regardless of amount.
• Direct transfer user → your wallet, no intermediary.
• Accept USDT jetton on TON — stable asset, no volatility.
• No limits, instant withdrawals.

If your service is anything more serious than “5-star sticker pack” — you need TON acceptance.

Path 1: Crypto Pay (via Crypto Bot) — 30 minutes

Fastest option. Crypto Pay is an API wrapper around Crypto Bot, one of the largest custodial wallets in Telegram.

Steps:

1. Open @CryptoBot in Telegram.
2. /start → “Crypto Pay” menu → “Create App”.
3. Get app_id and api_token. Store api_token — it can’t be viewed again, only regenerated.
4. In your bot code:

import axios from 'axios';

const CRYPTO_BOT_TOKEN = process.env.CRYPTO_BOT_TOKEN!;
const API = 'https://pay.crypt.bot/api';

async function createInvoice(amount: string, asset: 'TON' | 'USDT', orderId: string) {
  const { data } = await axios.post(
    `${API}/createInvoice`,
    {
      asset,
      amount,
      description: `Order #${orderId}`,
      payload: orderId,
      paid_btn_name: 'callback',
      paid_btn_url: `https://yourshop.com/order/${orderId}/done`,
      expires_in: 3600,
    },
    { headers: { 'Crypto-Pay-API-Token': CRYPTO_BOT_TOKEN } },
  );
  return data.result; // { invoice_id, pay_url, ... }
}

5. Send pay_url to the client. They open Crypto Bot and pay.
6. Crypto Bot fires a webhook to your /cryptopay/webhook:

import crypto from 'crypto';

app.post('/cryptopay/webhook', (req, res) => {
  const signature = req.headers['crypto-pay-api-signature'] as string;
  const secret = crypto.createHash('sha256').update(CRYPTO_BOT_TOKEN).digest();
  const hmac = crypto.createHmac('sha256', secret)
    .update(JSON.stringify(req.body))
    .digest('hex');

  if (hmac !== signature) return res.status(401).send('Invalid signature');

  const { update_type, payload } = req.body;
  if (update_type === 'invoice_paid') {
    const { invoice_id, status, payload: orderId } = payload;
    // Mark order as paid in your DB
  }
  res.sendStatus(200);
});

7. Withdraw TON from your Crypto Pay balance to any TON wallet — via /transfer API or the bot UI.

Pros: simplicity, instant integration, 7+ currencies (TON, USDT, BTC, ETH and more), docs in English and Russian, used by Russian merchants for years.

Cons: funds sit on Crypto Bot — custodial risk. For >100K USDT/month turnover, withdraw daily. Payment history lives on Crypto Bot, not in your system — back it up via /getInvoices.

Path 2: Wallet Pay (Wallet in Telegram) — for small businesses

Wallet is the native Telegram wallet, formally part of Telegram infrastructure. Wallet Pay is the official gateway for TON/USDT-jetton acceptance.

Steps:

1. Open Wallet Business — a separate bot for business accounts.
2. Verify: brand name, tax ID (or equivalent), service description. Review takes 1-5 business days.
3. After approval — receive WPAY_STORE_API_KEY and WPAY_STORE_API_SECRET.
4. Integration:

async function createWalletPayOrder(amount: number, currency: 'TON' | 'USDT', externalId: string) {
  const res = await fetch('https://pay.wallet.tg/wpay/store-api/v1/order', {
    method: 'POST',
    headers: {
      'Wpay-Store-Api-Key': process.env.WPAY_API_KEY!,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      amount: { amount: amount.toString(), currencyCode: currency },
      description: 'Premium subscription',
      externalId,
      timeoutSeconds: 3600,
      customerTelegramUserId: 0,
      returnUrl: `https://yourshop.com/order/${externalId}/done`,
      failReturnUrl: `https://yourshop.com/order/${externalId}/fail`,
    }),
  });
  return res.json();
}

5. Redirect the client to payLink; webhook handling is similar to Crypto Pay but with a different signature secret.

Pros: one of the highest-converting checkouts in Telegram — the user never leaves the chat. Tight integration with Wallet in Telegram = huge audience. Bank withdrawals available in some regions.

Cons: verification can drag. Russian access — formally Wallet Pay supports Russian merchants, but verification may demand extra documents. Only 2 currencies (TON, USDT-jetton) in the standard API.

Path 3: xRocket Pay — multi-currency + payouts

xRocket is a multi-chain wallet bot with a proprietary payment API supporting mass payouts (important for marketplaces and affiliate programs).

Steps:

1. @xRocket → “Pay” menu → “My API”.
2. Get api_key.
3. Create an invoice:

curl -X POST "https://pay.xrocket.tg/multi-invoice" \
  -H "Rocket-Pay-Key: $XROCKET_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "currency": "TONCOIN",
    "amount": 1.5,
    "description": "VIP access",
    "expiredIn": 3600
  }'

4. Send link to the client.
5. Webhooks arrive at your URL, signature verified by HMAC-SHA256 with api_key.

Payouts (mass payout to winners/partners):

curl -X POST "https://pay.xrocket.tg/multi-transfer" \
  -H "Rocket-Pay-Key: $XROCKET_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "currency": "TONCOIN",
    "transfers": [
      {"tgUserId": 12345, "amount": 0.5, "description": "Daily reward"},
      {"tgUserId": 67890, "amount": 1.2, "description": "Referral bonus"}
    ]
  }'

Pros: 15+ tokens supported (TON, USDT-jetton, BTC, ETH, SOL, BNB), multi-currency invoice, mass payouts.

Cons: 2% fee is higher than competitors. Support a bit slower — replies in 1-2 days vs hours. Brand less known — some clients may distrust an unfamiliar wallet on first payment.

Path 4: Custom acceptance via TON Connect 2.0

Want full ownership — no intermediary, no gateway fee? Build your own using TON Connect.

Architecture:

1. Frontend (Telegram Mini App): TON Connect SDK, “Connect wallet” button.
2. User connects Tonkeeper/MyTonWallet/Wallet.
3. Your server generates an invoice: { orderId, amount, recipientAddress, comment: orderId }.
4. Frontend triggers sendTransaction via TON Connect.
5. User confirms in their wallet.
6. Server watches the blockchain via TON Indexer/Toncenter/TonAPI: looks for incoming transactions to recipientAddress with the orderId comment.
7. On confirmation (TON finality ~5-30 seconds) — order is fulfilled.

// Simplified blockchain polling:
async function watchPayment(orderId: string, recipient: string, amount: bigint, fromLt: bigint) {
  while (true) {
    const txs = await tonapi.accounts.getTransactions(recipient, { after_lt: fromLt });
    for (const tx of txs.transactions) {
      const inMsg = tx.in_msg;
      if (
        inMsg?.value === amount.toString() &&
        inMsg?.decoded_body?.text === orderId
      ) {
        await markOrderAsPaid(orderId, tx.hash);
        return;
      }
    }
    await new Promise(r => setTimeout(r, 3000));
  }
}

Pros: 0% gateway fee (only network gas ~$0.20). Full control. Support for any jetton on TON, including your own. Ideal for DeFi projects.

Cons: you have to build it. Refunds — your problem. Replay-attack protection (unique comment), front-running protection by orderId, amount verification — all on you. Not for a startup without a backend engineer.

Full tutorial: TON Connect 2.0 + TonProof: Sign-in with TON.

Path 5: Telegram Stars + conversion to TON

If your service is inside Telegram (stickers, premium bot features, content) — the most “native” payment is Stars: user buys them in-app, you receive on Telegram account, then convert to TON via Fragment.

Steps:

1. BotFather → your bot → “Payments” → pick Stars.
2. In code, use the standard Telegram Bot API:

bot.sendInvoice(chatId, {
  title: 'Premium subscription',
  description: 'Monthly access to advanced features',
  payload: orderId,
  provider_token: '', // empty for Stars
  currency: 'XTR', // Telegram Stars
  prices: [{ label: 'Subscription', amount: 50 }], // 50 Stars
});

3. Stars auto-credit to the bot owner’s Telegram account.
4. Convert Stars → TON via Fragment (~0.013 TON per Star, mid-2026).

Pros: works out of the box, instant, regulated by Telegram, familiar to users.

Cons: Apple/Google take 30% on in-app Stars purchases. Fiat-off ramp is awkward. Star→TON rate is volatile — you can’t pin a USD price. Fits micro-payments inside Telegram only.

Details: Telegram Stars: conversion to TON and withdrawal.

Comparison table

Legal and tax

Accepting TON in Russia is a grey area. 259-FZ bans using digital currency as a means of settlement between Russian residents, but:

• If your audience is international (Telegram is global) — formally you’re outside the ban.
• If your clients are Russians — risk lies with you as the seller. Alternative — register as IP and accept rubles via YooKassa/QIWI, offering TON as “non-resident payment option”.

On any TON-to-fiat conversion — that’s a property sale, 13% PIT or 6% USN (for IP).

See our Taxes on TON in Russia guide (RU, available in Russian only).

Bottom line — what to pick

• MVP / testing demand: Crypto Pay. 30 minutes to a working checkout.
• Small business, stable turnover: Wallet Pay — best conversion.
• Marketplace / partner program / partner payouts: xRocket Pay — mass payouts built-in.
• DeFi project, custom jettons, zero fee: custom via TON Connect.
• In-Telegram content, fractions per unit: Stars + Fragment conversion.

Most startups in 2026 follow the path: Crypto Pay for MVP → Wallet Pay as turnover grows → custom TON Connect when fine control matters. Don’t pick on one axis — assess what’s critical for your model.