Build a Telegram Payment Bot with VietQR & AgentPay

pip install agentpay-vn

python -c "from agentpay_vn import create_payment_request; print('✓ AgentPay VN installed')"

export AGENTPAY_ACCOUNT_NAME="Nguyen Van A"
export AGENTPAY_ACCOUNT_NUMBER="0123456789"
export AGENTPAY_BANK_CODE="970418"

from agentpay_vn import create_payment_request, await_settlement
import os
from telegram import Update
from telegram.ext import ContextTypes

# Initialize AgentPay with your merchant details
merchant_account = {
    "account_name": os.getenv("AGENTPAY_ACCOUNT_NAME"),
    "account_number": os.getenv("AGENTPAY_ACCOUNT_NUMBER"),
    "bank_code": os.getenv("AGENTPAY_BANK_CODE"),
}

async def handle_purchase(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """
    User sends /buy command → bot creates payment request → displays QR → awaits settlement
    """

    # STEP 1: Create the payment request
    payment_request = create_payment_request(
        amount=299_000,  # 299,000 VND for example course
        description="Online Python Course - 3 Months Access",
        merchant=merchant_account,
        request_id=f"telegram_{update.effective_user.id}_{update.message.date}",  # Unique ID
    )

    # payment_request contains:
    # - qr_code (PNG bytes)
    # - checkout_url (for sharing outside Telegram)
    # - settlement_reference (to verify later)
    # - expires_at (usually 15 minutes)

    # STEP 2: Send the QR code to user
    await update.message.reply_photo(
        photo=payment_request["qr_code"],
        caption=(
            f"💳 Scan to pay: {payment_request['amount']:,} VND\n"
            f"📝 {payment_request['description']}\n"
            f"⏰ Expires in 15 minutes\n\n"
            f"Your course access unlocks instantly after payment."
        ),
    )

    # Store the settlement reference for later verification
    context.user_data["pending_settlement"] = payment_request["settlement_reference"]

    # STEP 3: Wait for settlement (non-blocking)
    # In production, you'd use a background job queue. For this example:
    try:
        settlement = await_settlement(
            settlement_reference=payment_request["settlement_reference"],
            timeout_seconds=900,  # Wait up to 15 minutes
        )

        # Payment confirmed! Deliver the product
        await update.effective_user.send_message(
            text=(
                f"✅ Payment confirmed!\n\n"
                f"Amount: {settlement['amount']:,} VND\n"
                f"Settled at: {settlement['settled_at']}\n\n"
                f"Your course access is active. Login here: https://example.com/courses"
            )
        )

        # Log the transaction
        print(f"[PAYMENT] User {update.effective_user.id} paid {settlement['amount']} VND")

    except TimeoutError:
        await update.effective_user.send_message(
            "⏱️ Payment window expired. Please try again or contact support."
        )

# Wire this into your telegram.ext.Application

from agentpay_vn import create_payment_request, await_settlement
import asyncio

class CaféOrderBot:
    def __init__(self):
        self.orders = {}  # Track pending orders
        self.merchant = {
            "account_name": "Cafe Nguyen Coffee",
            "account_number": "0987654321",
            "bank_code": "970418",
        }

    async def process_order(self, user_id: str, items: list, total: int):
        """
        Example: user orders 2 iced coffees + 1 pastry = 85,000 VND
        """

        # Create payment
        payment = create_payment_request(
            amount=total,
            description=f"Café Order: {', '.join(items)}",
            merchant=self.merchant,
            request_id=f"cafe_{user_id}_{int(asyncio.get_event_loop().time())}",
        )

        # Store order
        self.orders[payment["settlement_reference"]] = {
            "user_id": user_id,
            "items": items,
            "amount": total,
            "qr_code": payment["qr_code"],
            "status": "awaiting_payment",
        }

        # Return QR for display
        return payment

    async def confirm_and_fulfill(self, settlement_reference: str):
        """
        Called when payment settles—trigger order fulfillment
        """

        order = self.orders[settlement_reference]
        order["status"] = "paid"

        # Send to kitchen
        print(f"🍳 [KITCHEN] Order for {order['user_id']}: {order['items']}")

        # Could integrate with kitchen display system (KDS) here
        # Notify customer
        return {
            "message": f"✅ Order confirmed! Ready in ~10 minutes. Pickup #42",
            "pickup_number": 42,
        }

café = CaféOrderBot()

async def /order(update, context):
    # User selected items in inline menu
    items = ["Iced Americano", "Iced Americano", "Croissant"]
    total = 85_000

    payment = await café.process_order(str(update.effective_user.id), items, total)

    await update.message.reply_photo(
        photo=payment["qr_code"],
        caption=f"Pay {total:,} VND to confirm your order 🍵"
    )

    # Background task: await settlement
    settlement = await_settlement(payment["settlement_reference"], timeout_seconds=600)

    result = await café.confirm_and_fulfill(payment["settlement_reference"])
    await update.effective_user.send_message(result["message"])

pip install agentpay-mcp
agentpay-mcp --port 3001

{
  "mcpServers": {
    "agentpay": {
      "command": "python",
      "args": ["-m", "agentpay_mcp"],
      "env": {
        "AGENTPAY_ACCOUNT_NAME": "Your Business",
        "AGENTPAY_ACCOUNT_NUMBER": "0123456789",
        "AGENTPAY_BANK_CODE": "970418"
      }
    }
  }
}

payment = create_payment_request(
    amount=100_000,
    description="Premium feature unlock",
    merchant=merchant_account,
    request_id="feature_unlock_user_123",
    expires_in_minutes=30,  # Default is 15; extend for high-value items
)

async def safe_await_settlement(settlement_ref: str, max_retries: int = 3):
    for attempt in range(max_retries):
        try:
            return await_settlement(settlement_ref, timeout_seconds=60)
        except TimeoutError:
            if attempt < max_retries - 1:
                await asyncio.sleep(5)  # Wait 5s, then retry
            else:
                raise  # Final timeout

# Monthly subscription bot
async def renew_subscription(user_id: str, tier: str):
    prices = {"starter": 99_000, "pro": 299_000, "enterprise": 999_000}

    payment = create_payment_request(
        amount=prices[tier],
        description=f"{tier.title()} Plan - Monthly Renewal",
        merchant=merchant_account,
        request_id=f"sub_{user_id}_{date.today().isoformat()}",
    )

    # Store subscription state
    subscriptions[user_id] = {
        "tier": tier,
        "settlement_ref": payment["settlement_reference"],
        "expires_at": date.today() + timedelta(days=30),
    }

    return payment["qr_code"]

   pip install agentpay-vn