BTCPay Server Alternative for Telegram Mini Apps | recv

Building digital storefronts, paid communities, and decentralized web applications directly inside the Telegram ecosystem has become a standard for modern web3 and SaaS developers. When searching for a non-custodial payment gateway that respects financial sovereignty and charges zero transaction fees, many creators naturally consider BTCPay Server first. However, integrating BTCPay Server into Telegram Mini Apps (TMAs) presents distinct infrastructure bottlenecks and configuration complexities.

Using the recv platform offers a simpler, developer-first alternative that retains the core philosophies of self-custody and 0% transaction fees while completely removing the headache of self-hosted infrastructure.

---

The Challenge: Self-Hosting in the Stablecoin Era

BTCPay Server is an exceptional piece of open-source software, primarily built for Bitcoin and the Lightning Network. It allows merchants to accept payments directly into their own wallets without intermediaries. However, the payment landscape for Telegram Mini Apps is dominated not by Bitcoin, but by high-speed networks and stablecoins—specifically TON, USDT on TON (TON_USDT), and TRON (TRC-20 USDT).

Attempting to run BTCPay Server for these networks introduces several technical challenges:

1. Heavy Node Infrastructure: Supporting TRON or TON on your own self-hosted BTCPay instance requires running full nodes. A TON full node or a TRON node requires massive NVMe storage, significant RAM, and constant maintenance. This creates a high operational cost that defeats the purpose of "free" open-source software.
2. Fragile Altcoin Plugins: Because Bitcoin is the core focus of BTCPay Server, integrations for altcoins and alternative stablecoins are community-maintained. These plugins can frequently break during core software updates, risking downtime for your checkout flows.
3. Complex UX for In-App Browsers: Telegram Mini Apps run inside a specialized mobile web view. Standard web checkouts often fail to trigger deep links correctly for mobile wallets like Tonkeeper, Phantom, or TronLink, leading to poor user conversion.

To bypass these hurdles, many developers resort to custodial processors. Unfortunately, custodial solutions introduce regulatory friction (mandatory KYC) and the persistent risk of frozen funds. This is where a modern BTCPay Server alternative becomes necessary.

---

Introducing recv: The Simpler, Developer-First Alternative

Designed specifically for modern web application architectures, recv serves as a cloud-hosted, non-custodial payment monitor. It offers the absolute financial independence of self-hosting without requiring you to manage a single server node.

The mental model is straightforward:

1. Your Telegram Mini App backend makes a clean API call to generate a payment invoice.
2. The user is redirected to a lightweight, responsive checkout link: https://recv.money/app/checkout/{id}.
3. A real-time blockchain watcher managed by recv monitors the target network for the incoming transfer.
4. Funds settle direct-to-wallet. Crypto goes straight from the customer's wallet to your own designated wallet address. The platform never holds merchant funds, and your private keys never leave your device.
5. Once the watcher detects the transaction, recv fires an HMAC-SHA256 signed webhook to your server with exponential backoff delivery guarantees.

This setup requires no KYC, charges 0% turnover fees on every plan, and supports the networks that Telegram users actually use: TON, TON_USDT, TRON (TRC-20 USDT), Base (Coinbase L2), and BSC. Supported assets include USDT, USDC, TON, SOL, and BNB.

---

Feature Comparison: BTCPay Server vs. recv

---

Optimizing the Payment UX for Telegram Mini Apps

Inside a Telegram Mini App, screen real estate and attention spans are limited. Standard checkouts that display raw wallet addresses force users to copy the address, exit Telegram, open their wallet, paste the address, manually type the amount, and send. This multi-step process introduces significant opportunities for input errors and abandoned carts.

To solve this, the Smart Checkout interface from recv is highly optimized for mobile web views. It features:

• One-Click Deep Linking: Buttons automatically open trusted mobile wallets like Tonkeeper or Phantom directly on the user's phone, pre-filling the exact amount and destination address.
• Underpayment Resolution: If a customer accidentally sends slightly less than the invoice amount (for example, forgetting network fees), the smart system helps resolve the difference in real time without failing the transaction outright.
• No Wallet Connections Required: Because payments are tracked purely via on-chain watchers, users do not need to connect their Web3 wallets to your Mini App, providing a cleaner and safer user experience.

---

Integration Guide: Node.js, Express, and Telegram Mini Apps

Setting up a payment flow with the developer API integration is designed to take minutes rather than hours. Here is a practical example of how to programmatically create an invoice and securely verify incoming payment webhooks inside your Telegram Mini App backend.

1. Generating an Invoice

When your user clicks "Buy" in your Telegram Mini App, your backend requests an invoice from recv.

// backend/paymentService.ts
import fetch from 'node-fetch';

interface InvoiceResponse {
  id: string;
  checkout_url: string;
  status: string;
}

export async function createTelegramPayment(userId: string, orderId: string, amount: number): Promise<string> {
  const apiKey = process.env.RECV_API_KEY;
  if (!apiKey) throw new Error("RECV_API_KEY is not configured");

  const response = await fetch('https://api.recv.money/v1/invoices', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${apiKey}`
    },
    body: JSON.stringify({
      amount: amount.toFixed(2), // e.g. "15.00"
      asset: "USDT",
      network: "TON_USDT", // Settle stablecoin on TON network
      callback_url: "https://yourdomain.com/api/webhooks/payments",
      metadata: {
        userId,
        orderId
      }
    })
  });

  if (!response.ok) {
    const errText = await response.text();
    throw new Error(`Failed to create invoice: ${errText}`);
  }

  const data = (await response.json()) as InvoiceResponse;
  
  // Return checkout URL to redirect the Telegram Mini App view
  // Format: https://recv.money/app/checkout/{id}
  return data.checkout_url;
}

2. Validating the Webhook via HMAC-SHA256

To prevent payment spoofing, recv signs every webhook payload using a secret key. Your server must verify this signature using an HMAC-SHA256 signature check.

// backend/webhookHandler.ts
import express from 'express';
import crypto from 'crypto';

const app = express();

// Ensure the raw body is preserved for signature verification
app.post('/api/webhooks/payments', express.raw({ type: 'application/json' }), (req, res) => {
  const signature = req.headers['x-recv-signature'] as string;
  const webhookSecret = process.env.RECV_WEBHOOK_SECRET;

  if (!signature || !webhookSecret) {
    return res.status(400).send('Missing signing components');
  }

  // Compute the expected HMAC-SHA256 signature
  const hmac = crypto.createHmac('sha256', webhookSecret);
  const rawBody = req.body.toString();
  const computedSignature = hmac.update(rawBody).digest('hex');

  // Securely compare the signatures
  const isVerified = crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(computedSignature, 'hex')
  );

  if (!isVerified) {
    console.warn('Webhook signature mismatch detected');
    return res.status(401).send('Unauthorized');
  }

  // Parse payload once verified
  const payload = JSON.parse(rawBody);

  if (payload.status === 'paid') {
    const { userId, orderId } = payload.metadata;
    console.log(`Payment confirmed for Order: ${orderId}, User: ${userId}`);
    
    // Fulfill the digital asset, activate subscription, or award in-game item
  }

  // Always return a 200 OK to stop webhook retries
  res.status(200).json({ received: true });
});

---

FAQ

Is recv completely non-custodial?

Yes. Just like BTCPay Server, funds go directly to your self-hosted or hardware wallet. The system acts as an automated blockchain transaction monitor (watcher) rather than a temporary holding account. Your private keys never touch any external server.

Does recv require KYC?

No. Because recv is entirely non-custodial and does not touch or manage your money, there is no merchant KYC verification required to start accepting payments.

What are the limits of the free Trial plan?

The Trial plan is free for life and has a cap of 15 live, active invoices. It is designed to help indie developers test their Telegram Mini Apps and build integrations without paying upfront. Upgrading to the Merchant plan costs $9/mo for unlimited invoice volume and 0% transaction fees.

Can I accept payments on EVM networks?

Yes. The platform natively supports Base (Coinbase L2) and Binance Smart Chain (BSC), alongside TON and TRON networks. You can accept stablecoins like USDT and USDC as well as native assets like BNB, SOL, and TON.

---

Streamline Your Mini App Payments

If you love the self-sovereign, 0% fee ethos of BTCPay Server but want to skip the endless cycles of server updates, node sync failures, and complex stablecoin integrations, recv is your ideal development partner.

Start accepting USDT and TON on recv today and deliver a frictionless checkout experience directly to your Telegram audience.