FazerCards API Cookbook

# 1. Browse the catalog
curl -s "https://api.fzr.cards/api/v2/catalog" \
  -H "X-Api-Key: $FAZER_API_KEY" | jq '.items[0]'

# 2. Place an order (Amazon $10, US storefront)
curl -s -X POST "https://api.fzr.cards/api/v2/order" \
  -H "X-Api-Key: $FAZER_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{"sku_id":"amazon-us-10","quantity":1}'

# 3. Retrieve order status + code
curl -s "https://api.fzr.cards/api/v2/order/<ORDER_ID>" \
  -H "X-Api-Key: $FAZER_API_KEY" | jq

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 signature = req.header("X-FazerCards-Signature") ?? "";
  const expected = crypto.createHmac("sha256", secret).update(req.body).digest("hex");
  if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    return res.status(401).send("bad signature");
  }

  const event = JSON.parse(req.body.toString("utf8"));

  switch (event.type) {
    case "order.completed":
      // event.order.id, event.order.code → deliver to customer
      enqueueDelivery(event.order);
      break;
    case "order.failed":
      enqueueRetry(event.order, event.reason);
      break;
    case "order.refunded":
      enqueueCustomerRefund(event.order);
      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 headers = {
  "X-Api-Key": process.env.FAZER_API_KEY!,
  "Content-Type": "application/json",
};

// /buy_uc 60 5123456789
bot.command("buy_uc", async (ctx) => {
  const [ucAmount, playerId] = ctx.match.split(" ");
  if (!ucAmount || !playerId) return ctx.reply("Usage: /buy_uc <amount> <player_id>");

  // (omitted: collect payment from customer first)

  const order = await fetch(`${FAZER}/order`, {
    method: "POST",
    headers: { ...headers, "Idempotency-Key": randomUUID() },
    body: JSON.stringify({
      sku_id: `pubg-uc-${ucAmount}`,
      quantity: 1,
      metadata: { player_id: playerId },
    }),
  }).then(r => r.json());

  if (order.status === "completed") {
    await ctx.reply(`✓ ${ucAmount} UC 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(sku: string, qty: number) {
  const idempotencyKey = randomUUID();
  const body = JSON.stringify({ sku_id: sku, quantity: qty });

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

# First page
curl -s "https://api.fzr.cards/api/v2/catalog?category=gift-cards&limit=100" \
  -H "X-Api-Key: $FAZER_API_KEY" | jq

# Next page (use cursor from previous response)
curl -s "https://api.fzr.cards/api/v2/catalog?category=gift-cards&limit=100&cursor=eyJpZCI6IjAwYWE..." \
  -H "X-Api-Key: $FAZER_API_KEY"

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_usd } = await res.json();

  if (balance_usd < 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_usd.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(category: string) {
    const r = await fetch(`${this.api}/catalog?category=${category}`, { headers: this.headers() });
    return (await r.json()).items;
  }

  async placeOrder(sku: string, qty: number, metadata: Record<string, string> = {}) {
    const r = await fetch(`${this.api}/order`, {
      method: "POST",
      headers: this.headers({ "Idempotency-Key": randomUUID() }),
      body: JSON.stringify({ sku_id: sku, quantity: qty, metadata }),
    });
    return r.json();
  }

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