FazerCards API Cookbook

# 1. Gift card categories (cursor-paginated)
curl -s "https://api.fzr.cards/api/v2/giftcards?limit=50" \
  -H "X-Api-Key: $FAZER_API_KEY" | jq '.items[0]'

# 2. Offers of one category: card_id, price_usd, stock
curl -s "https://api.fzr.cards/api/v2/giftcards/cards?category_id=$CATEGORY_ID" \
  -H "X-Api-Key: $FAZER_API_KEY" | jq '.offers[0]'

# 3. Place the order
curl -s -X POST "https://api.fzr.cards/api/v2/giftcards/order" \
  -H "X-Api-Key: $FAZER_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d "{\"category_id\":\"$CATEGORY_ID\",\"card_id\":\"$CARD_ID\",\"quantity\":1}"

# 4. Order status + codes
curl -s "https://api.fzr.cards/api/v2/orders/$ORDER_ID" \
  -H "X-Api-Key: $FAZER_API_KEY" | jq '.order | {status, cards}'

import express from "express";
import crypto from "crypto";

const app = express();
const secret = process.env.FAZER_WEBHOOK_SECRET!;

app.post("/webhooks/fazercards", express.raw({ type: "application/json" }), (req, res) => {
  const received = Buffer.from(req.header("X-Webhook-Signature") ?? "");
  const expected = Buffer.from(
    "sha256=" + crypto.createHmac("sha256", secret).update(req.body).digest("hex")
  );
  if (received.length !== expected.length || !crypto.timingSafeEqual(received, expected)) {
    return res.status(401).send("bad signature");
  }

  const { event, event_id, data } = JSON.parse(req.body.toString("utf8"));
  if (alreadyProcessed(event_id)) return res.sendStatus(200); // retries reuse event_id

  if (event === "order.status_changed") {
    switch (data.status) {
      case "completed":
        // worker: GET /orders/{order_id} → order.cards → customer
        enqueueDelivery(data.order_id);
        break;
      case "failed":
      case "refund":
        enqueueCustomerRefund(data.order_id, data.status);
        break;
    }
  }

  res.sendStatus(200);
});

app.listen(8080);

import { Bot } from "grammy";
import { randomUUID } from "crypto";

const bot = new Bot(process.env.BOT_TOKEN!);
const FAZER = "https://api.fzr.cards/api/v2";
const PUBG_CATEGORY_ID = process.env.PUBG_CATEGORY_ID!; // from GET /topups
const headers = {
  "X-Api-Key": process.env.FAZER_API_KEY!,
  "Content-Type": "application/json",
};

// /buy_uc <offer_id> <player_id>   (offer_id from GET /topups/offers)
bot.command("buy_uc", async (ctx) => {
  const [offerId, playerId] = ctx.match.split(" ");
  if (!offerId || !playerId) return ctx.reply("Usage: /buy_uc <offer_id> <player_id>");

  // (omitted: collect payment from customer first)

  const { order } = await fetch(`${FAZER}/topups/order`, {
    method: "POST",
    headers: { ...headers, "Idempotency-Key": randomUUID() },
    body: JSON.stringify({
      category_id: PUBG_CATEGORY_ID,
      offer_id: offerId,
      fields: { player_id: playerId },
    }),
  }).then(r => r.json());

  if (order.status === "completed") {
    await ctx.reply(`✓ ${order.offer_name} delivered to ${playerId}`);
  } else {
    await ctx.reply(`Order ${order.id} in progress — you'll get a confirmation in a minute.`);
    // The webhook handler (previous recipe) sends the confirmation
  }
});

bot.start();

import { randomUUID } from "crypto";

async function placeOrderWithRetry(categoryId: string, cardId: string, qty: number) {
  const idempotencyKey = randomUUID(); // same key across retries
  const body = JSON.stringify({ category_id: categoryId, card_id: cardId, quantity: qty });

  for (let attempt = 0; attempt < 5; attempt++) {
    try {
      const res = await fetch("https://api.fzr.cards/api/v2/giftcards/order", {
        method: "POST",
        headers: {
          "X-Api-Key": process.env.FAZER_API_KEY!,
          "Idempotency-Key": idempotencyKey,
          "Content-Type": "application/json",
        },
        body,
      });
      if (res.status >= 500) throw new Error(`5xx ${res.status}`);
      return await res.json(); // same order on every successful retry
    } catch (err) {
      const wait = 2 ** attempt * 250;
      await new Promise(r => setTimeout(r, wait));
    }
  }
  throw new Error("all retries exhausted");
}

# First page of categories
curl -s "https://api.fzr.cards/api/v2/giftcards?limit=200" \
  -H "X-Api-Key: $FAZER_API_KEY" | jq '{items: .items | length, meta}'

# Next page (cursor from meta.next_cursor)
curl -s "https://api.fzr.cards/api/v2/giftcards?limit=200&cursor=$NEXT_CURSOR" \
  -H "X-Api-Key: $FAZER_API_KEY"

# Offers and prices of one category
curl -s "https://api.fzr.cards/api/v2/giftcards/cards?category_id=$CATEGORY_ID" \
  -H "X-Api-Key: $FAZER_API_KEY" | jq '.offers[] | {card_id, name, price_usd, stock}'

import cron from "node-cron";

const THRESHOLD = 100; // USD
let lastAlertAt = 0;

cron.schedule("* * * * *", async () => {
  const res = await fetch("https://api.fzr.cards/api/v2/balance", {
    headers: { "X-Api-Key": process.env.FAZER_API_KEY! },
  });
  const balance = Number((await res.json()).balance); // "100.0000" → 100

  if (balance < THRESHOLD && Date.now() - lastAlertAt > 30 * 60 * 1000) {
    await fetch(`https://api.telegram.org/bot${process.env.BOT_TOKEN}/sendMessage`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        chat_id: process.env.ADMIN_CHAT_ID,
        text: `⚠️ FazerCards balance low: $${balance.toFixed(2)}`,
      }),
    });
    lastAlertAt = Date.now();
  }
});

async function callWith429Handling(input: string, init?: RequestInit) {
  for (let attempt = 0; attempt < 5; attempt++) {
    const res = await fetch(input, init);
    if (res.status !== 429) return res;

    const retryAfterSec = Number(res.headers.get("Retry-After") ?? 1);
    const jitter = Math.random() * 0.3 + 0.85; // 0.85x .. 1.15x
    await new Promise(r => setTimeout(r, retryAfterSec * 1000 * jitter));
  }
  throw new Error("rate-limited beyond retry budget");
}

// Adapter that mimics a generic "ResellerSupplier" interface used by your app.
// Swap this for a Reloadly / Bitrefill implementation without touching callers.

import { randomUUID } from "crypto";

export class FazerCardsSupplier {
  private api = "https://api.fzr.cards/api/v2";
  constructor(private apiKey: string) {}

  private headers(extra: Record<string, string> = {}) {
    return { "X-Api-Key": this.apiKey, "Content-Type": "application/json", ...extra };
  }

  async listProducts(categoryId: string) {
    const url = new URL(`${this.api}/giftcards/cards`);
    url.searchParams.set("category_id", categoryId);
    const r = await fetch(url, { headers: this.headers() });
    return (await r.json()).offers; // [{ card_id, name, price_usd, stock, ... }]
  }

  async placeOrder(categoryId: string, cardId: string, qty: number) {
    const r = await fetch(`${this.api}/giftcards/order`, {
      method: "POST",
      headers: this.headers({ "Idempotency-Key": randomUUID() }),
      body: JSON.stringify({ category_id: categoryId, card_id: cardId, quantity: qty }),
    });
    return (await r.json()).order; // { id, status, cards, ... }
  }

  async getOrder(orderId: string) {
    const r = await fetch(`${this.api}/orders/${orderId}`, { headers: this.headers() });
    return (await r.json()).order;
  }
}