Dokumentasi API

// npm install telegraf        (butuh Node.js 18 ke atas)
const { Telegraf } = require('telegraf');

const API = 'https://kodebayar.id/api/v1';
const KEY = process.env.QRIS_API_KEY;              // sk_live_... atau sk_test_...
const bot = new Telegraf(process.env.BOT_TOKEN);

// Pesanan yang menunggu pembayaran: reference_id -> { chatId, messageId, expiresAt }.
// Di bot sungguhan simpan di database, supaya tidak hilang saat bot dinyalakan ulang.
const waiting = new Map();

async function api(method, path, body) {
  const res = await fetch(API + path, {
    method,
    headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
    body: body ? JSON.stringify(body) : undefined,
  });
  const json = await res.json();
  if (!res.ok) throw new Error(json.message || `HTTP ${res.status}`);
  return json.data;
}

// 1. Pembeli memesan: buat transaksi, lalu kirim QR sebagai foto.
bot.command('beli', async (ctx) => {
  const reference = `TG-${ctx.chat.id}-${Date.now()}`;
  try {
    const trx = await api('POST', '/transactions', { amount: 25000, reference_id: reference, expires_in: 15 });
    const photo = await ctx.replyWithPhoto(trx.qr_png_url, {
      caption: `Scan QRIS ini untuk membayar Rp ${trx.total_amount.toLocaleString('id-ID')}.\nBerlaku 15 menit.`,
    });
    waiting.set(reference, { chatId: ctx.chat.id, messageId: photo.message_id, expiresAt: Date.parse(trx.expires_at) });
  } catch (err) {
    console.error(err);
    await ctx.reply('Pembayaran sedang tidak tersedia. Coba lagi sebentar.');
  }
});

// 2. Pesanan selesai: hapus foto QR dan kabari pembeli.
async function selesai(reference, pesan) {
  const order = waiting.get(reference);
  if (!order) return;
  waiting.delete(reference);                       // hapus dulu, supaya tidak diproses dua kali
  await bot.telegram.deleteMessage(order.chatId, order.messageId).catch(() => {});
  await bot.telegram.sendMessage(order.chatId, pesan);
}

// 3. Satu panggilan tiap 5 detik untuk SEMUA pesanan, bukan satu panggilan per pesanan.
setInterval(async () => {
  if (waiting.size === 0) return;
  try {
    const paid = await api('GET', '/transactions?status=paid&per_page=50');
    for (const trx of paid) {
      if (waiting.has(trx.reference_id)) {
        await selesai(trx.reference_id, 'Pembayaran diterima. Pesanan Anda diproses.');
        // Kirim produk ke pembeli di sini.
      }
    }

    for (const [reference, order] of waiting) {
      if (Date.now() < order.expiresAt) continue;
      // Cek sekali lagi sebelum menyatakan kedaluwarsa: pembeli bisa saja membayar di detik terakhir.
      const last = await api('GET', `/transactions/${reference}`);
      await selesai(reference, last.status === 'paid'
        ? 'Pembayaran diterima. Pesanan Anda diproses.'
        : 'Waktu pembayaran habis. Ketik /beli untuk membuat QR baru.');
    }
  } catch (err) {
    console.error(err);
  }
}, 5000);

bot.launch();

# pip install "python-telegram-bot[job-queue]" httpx
import os
import time
from datetime import datetime

import httpx
from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes

API = "https://kodebayar.id/api/v1"
KEY = os.environ["QRIS_API_KEY"]                   # sk_live_... atau sk_test_...
client = httpx.AsyncClient(headers={"Authorization": f"Bearer {KEY}"}, timeout=20)

# Pesanan yang menunggu pembayaran: reference_id -> {chat_id, message_id, expires_at}.
# Di bot sungguhan simpan di database, supaya tidak hilang saat bot dinyalakan ulang.
waiting = {}


async def api(method, path, body=None):
    res = await client.request(method, API + path, json=body)
    data = res.json()
    if res.is_error:
        raise RuntimeError(data.get("message", f"HTTP {res.status_code}"))
    return data["data"]


# 1. Pembeli memesan: buat transaksi, lalu kirim QR sebagai foto.
async def beli(update: Update, context: ContextTypes.DEFAULT_TYPE):
    chat_id = update.effective_chat.id
    reference = f"TG-{chat_id}-{int(time.time() * 1000)}"
    try:
        trx = await api("POST", "/transactions", {"amount": 25000, "reference_id": reference, "expires_in": 15})
    except Exception as err:
        print(err)
        await update.message.reply_text("Pembayaran sedang tidak tersedia. Coba lagi sebentar.")
        return

    total = f"{trx['total_amount']:,}".replace(",", ".")
    photo = await update.message.reply_photo(
        trx["qr_png_url"], caption=f"Scan QRIS ini untuk membayar Rp {total}.\nBerlaku 15 menit."
    )
    waiting[reference] = {
        "chat_id": chat_id,
        "message_id": photo.message_id,
        "expires_at": datetime.fromisoformat(trx["expires_at"]).timestamp(),
    }


# 2. Pesanan selesai: hapus foto QR dan kabari pembeli.
async def selesai(bot, reference, pesan):
    order = waiting.pop(reference, None)           # diambil dulu, supaya tidak diproses dua kali
    if not order:
        return
    try:
        await bot.delete_message(order["chat_id"], order["message_id"])
    except Exception:
        pass
    await bot.send_message(order["chat_id"], pesan)


# 3. Satu panggilan tiap 5 detik untuk SEMUA pesanan, bukan satu panggilan per pesanan.
async def cek(context: ContextTypes.DEFAULT_TYPE):
    if not waiting:
        return
    try:
        for trx in await api("GET", "/transactions?status=paid&per_page=50"):
            if trx["reference_id"] in waiting:
                await selesai(context.bot, trx["reference_id"], "Pembayaran diterima. Pesanan Anda diproses.")
                # Kirim produk ke pembeli di sini.

        for reference, order in list(waiting.items()):
            if time.time() < order["expires_at"]:
                continue
            # Cek sekali lagi sebelum menyatakan kedaluwarsa: pembeli bisa saja membayar di detik terakhir.
            last = await api("GET", f"/transactions/{reference}")
            await selesai(
                context.bot,
                reference,
                "Pembayaran diterima. Pesanan Anda diproses."
                if last["status"] == "paid"
                else "Waktu pembayaran habis. Ketik /beli untuk membuat QR baru.",
            )
    except Exception as err:
        print(err)


app = Application.builder().token(os.environ["BOT_TOKEN"]).build()
app.add_handler(CommandHandler("beli", beli))
app.job_queue.run_repeating(cek, interval=5)
app.run_polling()

// Lanjutan contoh QRIS di atas. Binance memakai kunci dan alamat sendiri.
const { Markup } = require('telegraf');
const BINANCE_KEY = process.env.BINANCE_API_KEY;   // bk_live_... atau bk_test_...

async function binance(method, path, body) {
  const res = await fetch(API + '/binance' + path, {
    method,
    headers: { Authorization: `Bearer ${BINANCE_KEY}`, 'Content-Type': 'application/json' },
    body: body ? JSON.stringify(body) : undefined,
  });
  const json = await res.json();
  if (!res.ok) throw new Error(json.message || `HTTP ${res.status}`);
  return json.data;
}

// 1. Kirim Binance ID dan nominal sebagai teks. Isi tag <code> tersalin dengan sekali ketuk.
bot.command('usdt', async (ctx) => {
  const reference = `TG-${ctx.chat.id}-${Date.now()}`;
  try {
    const bill = await binance('POST', '/transactions', { amount: 25000, reference_id: reference, expires_in: 30 });
    await ctx.replyWithHTML(
      'Kirim lewat <b>Binance Pay</b>:\n\n' +
        `Binance ID: <code>${bill.binance_pay_id}</code>\n` +
        `Nominal: <code>${bill.pay_amount_usdt}</code> USDT\n\n` +
        'Ketuk angkanya untuk menyalin. Nominal harus persis, jangan dibulatkan.',
      Markup.inlineKeyboard([Markup.button.callback('Saya sudah bayar', `cek:${reference}`)]),
    );
  } catch (err) {
    console.error(err);
    await ctx.reply('Pembayaran USDT sedang tidak tersedia. Coba lagi sebentar.');
  }
});

// 2. Tombol "Saya sudah bayar": minta pengecekan saat itu juga.
bot.action(/^cek:(.+)$/, async (ctx) => {
  try {
    const bill = await binance('POST', '/payment/check', { trx_id: ctx.match[1] });
    if (bill.status === 'paid') {
      await ctx.answerCbQuery();
      await ctx.editMessageText('Pembayaran USDT diterima. Pesanan Anda diproses.');
      // Kirim produk ke pembeli di sini (pastikan hanya sekali per reference_id).
      return;
    }
    await ctx.answerCbQuery('Belum terlihat. Tunggu 15 sampai 30 detik, lalu coba lagi.', { show_alert: true });
  } catch (err) {
    console.error(err);
    await ctx.answerCbQuery('Belum bisa dicek. Coba lagi sebentar.', { show_alert: true });
  }
});

# Lanjutan contoh QRIS di atas. Binance memakai kunci dan alamat sendiri.
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import CallbackQueryHandler

BINANCE_KEY = os.environ["BINANCE_API_KEY"]        # bk_live_... atau bk_test_...


async def binance(method, path, body=None):
    res = await client.request(
        method, API + "/binance" + path, json=body, headers={"Authorization": f"Bearer {BINANCE_KEY}"}
    )
    data = res.json()
    if res.is_error:
        raise RuntimeError(data.get("message", f"HTTP {res.status_code}"))
    return data["data"]


# 1. Kirim Binance ID dan nominal sebagai teks. Isi tag <code> tersalin dengan sekali ketuk.
async def usdt(update: Update, context: ContextTypes.DEFAULT_TYPE):
    reference = f"TG-{update.effective_chat.id}-{int(time.time() * 1000)}"
    try:
        bill = await binance("POST", "/transactions", {"amount": 25000, "reference_id": reference, "expires_in": 30})
    except Exception as err:
        print(err)
        await update.message.reply_text("Pembayaran USDT sedang tidak tersedia. Coba lagi sebentar.")
        return

    await update.message.reply_html(
        "Kirim lewat <b>Binance Pay</b>:\n\n"
        f"Binance ID: <code>{bill['binance_pay_id']}</code>\n"
        f"Nominal: <code>{bill['pay_amount_usdt']}</code> USDT\n\n"
        "Ketuk angkanya untuk menyalin. Nominal harus persis, jangan dibulatkan.",
        reply_markup=InlineKeyboardMarkup(
            [[InlineKeyboardButton("Saya sudah bayar", callback_data=f"cek:{reference}")]]
        ),
    )


# 2. Tombol "Saya sudah bayar": minta pengecekan saat itu juga.
async def cek_usdt(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    try:
        bill = await binance("POST", "/payment/check", {"trx_id": query.data.split(":", 1)[1]})
    except Exception as err:
        print(err)
        await query.answer("Belum bisa dicek. Coba lagi sebentar.", show_alert=True)
        return

    if bill["status"] == "paid":
        await query.answer()
        await query.edit_message_text("Pembayaran USDT diterima. Pesanan Anda diproses.")
        # Kirim produk ke pembeli di sini (pastikan hanya sekali per reference_id).
    else:
        await query.answer("Belum terlihat. Tunggu 15 sampai 30 detik, lalu coba lagi.", show_alert=True)


# Daftarkan sebelum app.run_polling():
app.add_handler(CommandHandler("usdt", usdt))
app.add_handler(CallbackQueryHandler(cek_usdt, pattern=r"^cek:"))

// npm install express        Dijalankan di proses yang sama dengan bot.
const crypto = require('crypto');
const express = require('express');
const app = express();

app.post('/webhook/qris', express.raw({ type: 'application/json' }), async (req, res) => {
  const payload = req.body.toString();
  const expected = crypto
    .createHmac('sha256', process.env.QRIS_WEBHOOK_SECRET)
    .update(`${req.headers['x-digitals-timestamp']}.${payload}`)
    .digest('hex');
  const given = String(req.headers['x-digitals-signature'] || '');

  if (given.length !== expected.length || !crypto.timingSafeEqual(Buffer.from(given), Buffer.from(expected))) {
    return res.sendStatus(401);
  }

  res.sendStatus(200);                             // jawab dulu, baru kabari pembeli

  const data = JSON.parse(payload);
  if (data.status === 'paid') {
    await selesai(data.reference_id, 'Pembayaran diterima. Pesanan Anda diproses.');
  } else if (data.status === 'expired') {
    await selesai(data.reference_id, 'Waktu pembayaran habis. Ketik /beli untuk membuat QR baru.');
  }
});

app.listen(3000);

# pip install flask requests        Layanan kecil terpisah dari proses bot.
import hashlib
import hmac
import os

import requests
from flask import Flask, request

app = Flask(__name__)
SECRET = os.environ["QRIS_WEBHOOK_SECRET"].encode()
TELEGRAM = f"https://api.telegram.org/bot{os.environ['BOT_TOKEN']}"


@app.post("/webhook/qris")
def webhook():
    payload = request.get_data()
    timestamp = request.headers.get("X-Digitals-Timestamp", "").encode()
    expected = hmac.new(SECRET, timestamp + b"." + payload, hashlib.sha256).hexdigest()

    if not hmac.compare_digest(expected, request.headers.get("X-Digitals-Signature", "")):
        return "", 401

    data = request.get_json()
    if data["status"] == "paid":
        # Ambil chat_id dari pesanan yang Anda simpan saat membuat transaksi,
        # dan pastikan pesanan ini belum pernah diproses.
        chat_id = cari_chat_id(data["reference_id"])
        requests.post(f"{TELEGRAM}/sendMessage", json={"chat_id": chat_id, "text": "Pembayaran diterima. Pesanan Anda diproses."})

    return "", 200