Код

#!/usr/bin/env bash
# BuyUKeSIM Affiliate API. Both endpoints are read only.
set -euo pipefail

BASE="https://buyukesim.com/api"

# Catalogue with your commission per product. Needs the API key from your panel.
curl -s "$BASE/affiliate/catalog" \
  -H "Authorization: Bearer ${BUYUKESIM_AFFILIATE_KEY:?export BUYUKESIM_AFFILIATE_KEY first}"

# One destination only.
curl -s "$BASE/affiliate/catalog?location_code=GB" \
  -H "Authorization: Bearer ${BUYUKESIM_AFFILIATE_KEY}"

# Clicks, orders, earnings. Code plus panel token, not the API key.
curl -s "$BASE/affiliate_panel?code=${AFFILIATE_CODE:?export AFFILIATE_CODE}&token=${AFFILIATE_PANEL_TOKEN:?export AFFILIATE_PANEL_TOKEN}"

#!/usr/bin/env bash
# BuyUKeSIM MCP server over plain curl. JSON-RPC 2.0, POST only.
set -euo pipefail

MCP="https://buyukesim.com/mcp"

# Handshake. Announces the protocol version you speak.
curl -s -X POST "$MCP" -H 'Content-Type: application/json' -d '{
  "jsonrpc":"2.0","id":1,"method":"initialize",
  "params":{"protocolVersion":"2025-06-18","capabilities":{},
            "clientInfo":{"name":"example-client","version":"1.0.0"}}
}'

# Every tool, with its input schema.
curl -s -X POST "$MCP" -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

# A read-only call. No key needed.
curl -s -X POST "$MCP" -H 'Content-Type: application/json' -d '{
  "jsonrpc":"2.0","id":3,"method":"tools/call",
  "params":{"name":"check_uk_coverage","arguments":{"country":"DE"}}
}'

# Another one: what the product actually is, in the words we publish.
curl -s -X POST "$MCP" -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"get_uk_number_info","arguments":{}}}'

# A spending call. Needs an agent key with a funded balance.
curl -s -X POST "$MCP" \
  -H "Authorization: Bearer ${BUYUKESIM_AGENT_KEY:?export BUYUKESIM_AGENT_KEY first}" \
  -H 'Content-Type: application/json' -d '{
  "jsonrpc":"2.0","id":5,"method":"tools/call",
  "params":{"name":"purchase_uk_number","arguments":{"quantity":1}}
}'

#!/usr/bin/env bash
# BuyUKeSIM Partner API - every endpoint, with curl.
# Replace the key with your own. Keep it server side.

set -euo pipefail

BASE="https://buyukesim.com/api/v1"
KEY="${BUYUKESIM_PARTNER_KEY:?export BUYUKESIM_PARTNER_KEY first}"
AUTH="Authorization: Bearer ${KEY}"

# --- Account ---------------------------------------------------------------

# What is left on your prepaid balance, plus your discount rate. Every order returns
# the same figure in its own `balance` block, so this call is for the checks that
# happen away from a purchase - a top-up alarm, a nightly job.
curl -s -H "$AUTH" "$BASE/balance"

# What you bought and what it cost, by product. Dates are UTC calendar days on the
# order date, inclusive at both ends; leave them off for the last 30 days.
curl -s -H "$AUTH" "$BASE/reports?from=2026-08-01&to=2026-08-31"

# Summary only, no itemised rows.
curl -s -H "$AUTH" "$BASE/reports?from=2026-08-01&to=2026-08-31&limit=0"

# --- Catalogue -------------------------------------------------------------

# Everything you can sell, at your partner prices.
curl -s -H "$AUTH" "$BASE/products"

# Narrow it to one destination. Use the ISO code, GB for the United Kingdom.
curl -s -H "$AUTH" "$BASE/products?location_code=GB"

# --- Ordering --------------------------------------------------------------

# Travel data. Take package_code from /products, never hand-compose it.
curl -s -X POST "$BASE/orders" \
  -H "$AUTH" -H 'Content-Type: application/json' \
  -d '{"product_type":"travel_data","package_code":"GB_1GB_7D","reference":"order-1235"}'

# VPN access for a fixed number of days.
curl -s -X POST "$BASE/orders" \
  -H "$AUTH" -H 'Content-Type: application/json' \
  -d '{"product_type":"vpn","vpn_plan":"30d","reference":"order-1236"}'

# --- After the order -------------------------------------------------------

ORDER_ID=98421

# Status plus the delivery payload once it is ready. Each eSIM item carries both
# ways in: `qr_code` for scanning, and `manual_install` with the SM-DP+ address and
# activation code for a customer who is reading your app on the phone the profile
# has to install to and has no second screen to point a camera at.
curl -s -H "$AUTH" "$BASE/orders/$ORDER_ID"

# Data used and remaining. Travel eSIM orders only.
curl -s -H "$AUTH" "$BASE/orders/$ORDER_ID/usage"

# VPN config. protocol is wireguard, openvpn or vless.
curl -s -H "$AUTH" "$BASE/orders/$ORDER_ID/vpn-config?protocol=wireguard&server_id=42"

# --- Applying for access ---------------------------------------------------

# No key yet? This starts an application. No auth header on this one.
curl -s -X POST "$BASE/signup" \
  -H 'Content-Type: application/json' \
  -d '{"company":"Example Ltd","email":"you@example.com","website":"https://example.com"}'

/**
 * BuyUKeSIM Partner API - Node 18+, no dependencies.
 *
 * Run: BUYUKESIM_PARTNER_KEY=... node node.mjs
 */

const BASE = 'https://buyukesim.com/api/v1';
const KEY = process.env.BUYUKESIM_PARTNER_KEY;
if (!KEY) throw new Error('set BUYUKESIM_PARTNER_KEY');

async function api(path, { method = 'GET', body } = {}) {
  const res = await fetch(`${BASE}${path}`, {
    method,
    headers: {
      Authorization: `Bearer ${KEY}`,
      ...(body ? { 'Content-Type': 'application/json' } : {}),
    },
    body: body ? JSON.stringify(body) : undefined,
  });

  const payload = await res.json().catch(() => null);
  if (!res.ok) {
    // Errors are { success: false, error: { code, message } } - the code is the part worth
    // branching on. 402 is a low partner balance, not a malformed request.
    throw new Error(`${res.status} ${payload?.error?.code ?? ''} ${payload?.error?.message ?? res.statusText}`.trim());
  }
  // Every success is wrapped: { success: true, data: { ... } }. Unwrap once, here, so no
  // caller has to remember the envelope.
  return payload?.data ?? payload;
}

/**
 * Everything sellable, at your prices: { discount_pct, travel_data[], vpn }.
 * `travel_data` is the array of destination packages, about 198 of them.
 */
const listProducts = (locationCode) =>
  api(`/products${locationCode ? `?location_code=${encodeURIComponent(locationCode)}` : ''}`);

/** What is left on the prepaid account: { balance_usd, currency, discount_pct, account }. */
const balance = () => api('/balance');

/**
 * What you bought between two dates and what it cost, broken down by product.
 *
 * Dates are UTC calendar days on the order date and inclusive at both ends; omit them
 * for the last 30 days. Paid orders only: a failed order is refunded, so it never cost
 * anything.
 *
 * `limit` caps the itemised `orders` array (default 100, max 500, 0 for summary only).
 */
const report = ({ from, to, limit } = {}) => {
  const q = new URLSearchParams();
  if (from) q.set('from', from);
  if (to) q.set('to', to);
  if (limit !== undefined) q.set('limit', String(limit));
  const qs = q.toString();
  return api(`/reports${qs ? `?${qs}` : ''}`);
};

const createOrder = (payload) => api('/orders', { method: 'POST', body: payload });

const orderStatus = (id) => api(`/orders/${id}`);
const dataUsage = (id) => api(`/orders/${id}/usage`);
const vpnConfig = (id, protocol = 'wireguard', serverId) =>
  api(`/orders/${id}/vpn-config?protocol=${protocol}${serverId ? `&server_id=${serverId}` : ''}`);

/**
 * Wait for the eSIM to exist.
 *
 * `status` is "paid" the moment the balance is taken, which is not the same as delivered -
 * `esim.ready` is what says the QR is there. Anything that is not an explicit failure counts
 * as still in progress: a slow supplier is normal, and treating "not ready yet" as an error
 * is the usual way integrations end up ordering twice.
 */
async function waitForDelivery(id, { timeoutMs = 120000, everyMs = 3000 } = {}) {
  const deadline = Date.now() + timeoutMs;
  for (;;) {
    const order = await orderStatus(id);
    if (order.esim?.ready) return order;
    if (order.status === 'cancelled' || order.status === 'expired') {
      throw new Error(`order ${id} ${order.status}`);
    }
    if (Date.now() > deadline) throw new Error(`order ${id} still ${order.status} after timeout`);
    await new Promise((r) => setTimeout(r, everyMs));
  }
}

// --- Example run -----------------------------------------------------------

const products = await listProducts('GB');
console.log(`${products.travel_data?.length ?? 0} travel packages for GB, your discount ${products.discount_pct}%`);

// Take the code from the catalogue. Hand-composed codes go stale.
const pkg = products.travel_data?.[0];

// The API sells travel data and VPN. Without a package there is nothing to buy, so bail
// rather than falling back to a product this account may not have.
if (!pkg) throw new Error('no travel package available for GB');
const order = await createOrder({
  product_type: 'travel_data',
  package_code: pkg.package_code,
  reference: `order-${Date.now()}`,
});
// Every call that spends money says what it cost and what survived it, so a low balance
// surfaces on the order that caused it rather than on the next one that fails with a 402.
console.log('placed', order.order_id, 'ref', order.reference);
console.log(`charged $${order.balance.charged_usd}, $${order.balance.remaining_usd} left`);

const delivered = await waitForDelivery(order.order_id);
const [first] = delivered.esim?.items ?? [];
console.log('QR:', first?.qr_code, 'ICCID:', first?.iccid);

// Show BOTH routes in your own UI. A customer reading this on the phone the profile has to
// install to cannot scan the QR off their own screen, and the manual fields are the way out
// of that. Leave the phone's "confirmation code" box empty - our profiles do not use one,
// and that blank box is where manual installs stall.
if (first?.manual_install) {
  const m = first.manual_install;
  console.log('SM-DP+:', m.smdp_address);
  console.log('Activation code:', m.activation_code);
  console.log('One-tap:', m.activation_string);
}

// Travel orders only.
if (delivered.product.type === 'travel_data') {
  console.log('usage:', await dataUsage(order.order_id));
}

// VPN orders only. A VPN order carries no eSIM, so it never goes through waitForDelivery:
// the credentials are already on the create response, under data.vpn.
if (order.product.type === 'vpn') {
  console.log('config:', await vpnConfig(order.order_id, 'wireguard'));
}

// Month end: what you bought and what it cost, straight from our ledger rather than yours.
const august = await report({ from: '2026-08-01', to: '2026-08-31' });
console.log(`spent $${august.totals.spend_usd} on ${august.totals.orders} order(s)`);
for (const line of august.products) {
  console.log(`  ${line.units} x ${line.type} = $${line.spend_usd}`);
}
console.log('balance now', (await balance()).balance_usd);

"""
BuyUKeSIM Partner API - Python 3.9+, requests only.

Run: BUYUKESIM_PARTNER_KEY=... python python.py
"""

import os
import time
from typing import Any, Optional

import requests

BASE = "https://buyukesim.com/api/v1"
KEY = os.environ.get("BUYUKESIM_PARTNER_KEY")
if not KEY:
    raise SystemExit("set BUYUKESIM_PARTNER_KEY")

session = requests.Session()
session.headers.update({"Authorization": f"Bearer {KEY}"})


class PartnerApiError(RuntimeError):
    """Carries the HTTP status so 402 (low balance) can be handled on its own."""

    def __init__(self, status: int, message: str, code: str = "") -> None:
        super().__init__(f"{status} {code} {message}".replace("  ", " ").strip())
        self.status = status
        self.code = code


def api(path: str, method: str = "GET", body: Optional[dict] = None) -> Any:
    res = session.request(method, f"{BASE}{path}", json=body, timeout=30)
    try:
        payload = res.json()
    except ValueError:
        payload = None
    if not res.ok:
        # Errors are {"success": false, "error": {"code", "message"}} - the code is the part
        # worth branching on.
        err = (payload or {}).get("error") or {}
        raise PartnerApiError(res.status_code, err.get("message", res.reason), err.get("code", ""))
    # Every success is wrapped: {"success": true, "data": {...}}. Unwrap once, here.
    return (payload or {}).get("data", payload)


def list_products(location_code: Optional[str] = None) -> Any:
    """
    Everything sellable, at your prices: {discount_pct, travel_data[], vpn}.

    `travel_data` is the array of destination packages, about 198 of them.
    """
    query = f"?location_code={location_code}" if location_code else ""
    return api(f"/products{query}")


def balance() -> Any:
    """What is left on the prepaid account: balance_usd, currency, discount_pct, account."""
    return api("/balance")


def report(
    date_from: Optional[str] = None,
    date_to: Optional[str] = None,
    limit: Optional[int] = None,
) -> Any:
    """
    What you bought between two dates and what it cost, broken down by product.

    Dates are UTC calendar days on the order date and inclusive at both ends; omit them
    for the last 30 days. Paid orders only: a failed order is refunded, so it never cost
    anything.

    `limit` caps the itemised `orders` array (default 100, max 500, 0 for summary only).
    """
    parts = []
    if date_from:
        parts.append(f"from={date_from}")
    if date_to:
        parts.append(f"to={date_to}")
    if limit is not None:
        parts.append(f"limit={limit}")
    query = ("?" + "&".join(parts)) if parts else ""
    return api(f"/reports{query}")


def create_order(payload: dict) -> Any:
    return api("/orders", "POST", payload)


def order_status(order_id: int) -> Any:
    return api(f"/orders/{order_id}")


def data_usage(order_id: int) -> Any:
    return api(f"/orders/{order_id}/usage")


def vpn_config(order_id: int, protocol: str = "wireguard", server_id: Optional[int] = None) -> Any:
    query = f"?protocol={protocol}" + (f"&server_id={server_id}" if server_id else "")
    return api(f"/orders/{order_id}/vpn-config{query}")


def wait_for_delivery(order_id: int, timeout: int = 120, every: int = 3) -> Any:
    """
    Poll until the eSIM exists.

    `status` is "paid" the moment the balance is taken, which is not the same as delivered:
    `esim.ready` is what says the QR is there. Only an explicit failure is an error - a slow
    supplier is normal, and treating "not ready yet" as a failure is how integrations end up
    ordering twice.
    """
    deadline = time.time() + timeout
    while True:
        order = order_status(order_id)
        if (order.get("esim") or {}).get("ready"):
            return order
        if order.get("status") in ("cancelled", "expired"):
            raise RuntimeError(f"order {order_id} {order['status']}")
        if time.time() > deadline:
            raise TimeoutError(f"order {order_id} still {order.get('status')}")
        time.sleep(every)


if __name__ == "__main__":
    catalogue = list_products("GB")
    packages = catalogue.get("travel_data", [])
    print(f"{len(packages)} travel packages for GB, your discount {catalogue.get('discount_pct')}%")

    # Always take package_code from the catalogue; codes are retired over time.
    pkg = packages[0] if packages else None
    ref = f"order-{int(time.time())}"

    # The API sells travel data and VPN. Without a package there is nothing to buy, so stop
    # rather than falling back to a product this account may not have.
    if not pkg:
        raise SystemExit("no travel package available for GB")
    payload = {"product_type": "travel_data", "package_code": pkg["package_code"], "reference": ref}

    order = create_order(payload)
    print("placed", order["order_id"], "ref", order["reference"])
    # Every call that spends money reports what it cost and what survived it, so a low
    # balance shows up on the order that caused it, not on the next one that 402s.
    print(f"charged ${order['balance']['charged_usd']}, ${order['balance']['remaining_usd']} left")

    delivered = wait_for_delivery(order["order_id"])
    items = (delivered.get("esim") or {}).get("items") or []
    if items:
        print("QR:", items[0]["qr_code"], "ICCID:", items[0]["iccid"])
        # Show BOTH routes in your own UI. A customer reading this on the phone the profile
        # has to install to cannot scan the QR off their own screen, and these fields are the
        # way out of that. Leave the phone's "confirmation code" box empty - our profiles do
        # not use one, and that blank box is where manual installs stall.
        manual = items[0].get("manual_install")
        if manual:
            print("SM-DP+:", manual["smdp_address"])
            print("Activation code:", manual["activation_code"])
            print("One-tap:", manual["activation_string"])

    if delivered["product"]["type"] == "travel_data":
        print("usage:", data_usage(order["order_id"]))
    # A VPN order carries no eSIM, so it never goes through wait_for_delivery: the
    # credentials are already on the create response, under data.vpn.
    if order["product"]["type"] == "vpn":
        print("config:", vpn_config(order["order_id"]))

    # Month end: what you bought and what it cost, from our ledger rather than yours.
    august = report("2026-08-01", "2026-08-31")
    print(f"spent ${august['totals']['spend_usd']} on {august['totals']['orders']} order(s)")
    for line in august["products"]:
        print(f"  {line['units']} x {line['type']} = ${line['spend_usd']}")
    print("balance now", balance()["balance_usd"])