Reseller API

Build it with your AI agent

Put your sandbox key in your project's environment as AURASTACK_API_KEY, then paste this prompt into Claude Code, Cursor, Codex or any agent that can read a web page. The agent is told never to use a live key unless you say so.

Integrate the AuraStack Reseller API into this project.

1. First read https://aurastack.link/llms.txt and follow the links it gives: the guide (https://aurastack.link/docs/api.md), the OpenAPI contract (https://aurastack.link/api/v1/openapi.json) and the agent skill (https://aurastack.link/skills/aurastack-reseller/SKILL.md). Follow the skill's rules.
2. Use only the sandbox key in the AURASTACK_API_KEY environment variable (it starts with sk_sandbox_). Never use or ask for a live key, and never place a live order, unless I say so.
3. Build: product list, quote before checkout, order creation with one Idempotency-Key per purchase, delivery of the credentials to the buyer, and handling of every order status and error.
4. Add end-to-end tests against the sandbox: call POST /sandbox/reset first, then cover each AuraStack-Sandbox-Outcome value.
5. Never log or print delivery.items or the API key.

When you are done, tell me what you built, how to run the tests, and what I must do to go live.

The agent starts from https://aurastack.link/llms.txt, a short map written for agents. It links this guide as plain markdown (/docs/api.md), the OpenAPI contract (/api/v1/openapi.json) and the AuraStack skill. Building by hand? Start with the Quickstart, or try every endpoint in the API reference.

mkdir -p ~/.claude/skills/aurastack-reseller && \
curl -fsSL https://aurastack.link/skills/aurastack-reseller/SKILL.md \
  -o ~/.claude/skills/aurastack-reseller/SKILL.md

Quickstart

1. Sign in and open your dashboard. In the Sandbox panel, click Create sandbox key. The key is shown once: store it in a secret manager.
2. List products, quote the one you want, then create the order with the quoted unit price. Sandbox orders are never charged.
3. Read the credentials from the order response, or poll the order until it is delivered.
4. When your integration works, create a live key under Live API Keys, top up your balance, and switch the key.

export AURASTACK_API_KEY=sk_sandbox_...

curl https://aurastack.link/api/v1/balance \
  -H "Authorization: Bearer $AURASTACK_API_KEY"

{
  "client_id": "...",
  "available_balance": "1000.00",
  "reserved_balance": "0.00",
  "currency": "EUR",
  "sandbox": true
}

Base URL: https://aurastack.link/api/v1. Requests and responses are JSON. Amounts are strings with two decimals, in the currency of the response: euros for everything since October 2026 (older orders show USD and vat: null).

Authentication

Send your key as a bearer token on every request: Authorization: Bearer <key>. A missing or unknown key returns 401; do not retry it.

Sandbox

A full copy of the live API that never costs money. Build your integration and run your end-to-end tests against it, then switch one key to go live.

Sandbox writes (quotes, orders, resets) are limited to 120 per minute per account, and sandbox orders to 2000 per 24 hours (a reset does not lift it). A quantity outside the product's limits fails like live (500).

Force an outcome

A sandbox order is delivered at once, unless your sandbox balance is too low (then 402, like live). To test the other cases, send the AuraStack-Sandbox-Outcome header when you create the order. It is read on creation only (not on replays), and live keys ignore it.

End-to-end tests

Put your sandbox key in your CI secrets and run your real code paths against the sandbox (it follows real stock: use a product your catalog shows in stock). Start each run with POST /sandbox/reset: it puts the sandbox balance back to 1000.00 EUR and clears your sandbox orders, so every run starts from the same state. Live keys get 403 on it.

const API = 'https://aurastack.link/api/v1';
const H = { Authorization: `Bearer ${process.env.AURASTACK_SANDBOX_KEY}`, 'Content-Type': 'application/json' };
const call = (path, init = {}) => fetch(API + path, { ...init, headers: { ...H, ...init.headers } });
const quote = async () => (await call('/quotes', { method: 'POST',
  body: JSON.stringify({ product_id: 'prd_IQCRJMV8ww5aozXi', quantity: 1 }) })).json();
const order = (q, headers) => call('/orders', { method: 'POST', headers,
  body: JSON.stringify({ product_id: q.product_id, quantity: 1,
    expected_unit_price: q.unit_price, billing: { country: 'FR' } }) });

beforeAll(() => call('/sandbox/reset', { method: 'POST' }));

test('a paid order is delivered and charged', async () => {
  const res = await order(await quote(), { 'Idempotency-Key': 'e2e-1' });
  const placed = await res.json();
  expect(placed.status).toBe('delivered');
  const balance = await (await call('/balance')).json();
  expect(balance.available_balance).toBe((1000 - Number(placed.total_amount)).toFixed(2));
});

test('my shop handles an order on hold', async () => {
  const res = await order(await quote(), { 'Idempotency-Key': 'e2e-2', 'AuraStack-Sandbox-Outcome': 'on_hold' });
  expect(res.status).toBe(502);
  expect((await res.json()).failure_code).toBe('NEEDS_REVIEW');
});

Balance

Products

{
  "items": [
    {
      "id": "prd_8Kq2mZt4Wb7xLn3R",
      "name": "Gemini Google One AI Pro 5TB, 18 months",
      "description": "...",
      "unit_price": "21.50",
      "currency": "EUR",
      "available_stock": 296,
      "minimum_quantity": 1,
      "maximum_quantity": 100,
      "updated_at": "2026-10-06T11:31:03.131Z"
    }
  ],
  "next_cursor": "..."
}

Quotes

curl -X POST https://aurastack.link/api/v1/quotes \
  -H "Authorization: Bearer $AURASTACK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "product_id": "prd_8Kq2mZt4Wb7xLn3R", "quantity": 2 }'

{
  "product_id": "prd_8Kq2mZt4Wb7xLn3R",
  "quantity": 2,
  "unit_price": "21.50",
  "total_amount": "43.00",
  "currency": "EUR",
  "available_stock": 296,
  "can_purchase": true,
  "quoted_at": "2026-10-06T12:00:00.000Z"
}

Orders

curl -X POST https://aurastack.link/api/v1/orders \
  -H "Authorization: Bearer $AURASTACK_API_KEY" \
  -H "Idempotency-Key: my-order-1001" \
  -H "Content-Type: application/json" \
  -d '{
    "product_id": "prd_8Kq2mZt4Wb7xLn3R",
    "quantity": 2,
    "expected_unit_price": "21.50",
    "billing": { "country": "FR" }
  }'

{
  "id": "api_3f9c2a71d0b84e6a5c1d7e02",
  "product_id": "prd_8Kq2mZt4Wb7xLn3R",
  "quantity": 2,
  "status": "delivered",
  "unit_price": "21.50",
  "total_amount": "51.60",
  "vat": { "rate": 20, "amount": "8.60", "country": "FR" },
  "currency": "EUR",
  "delivery": { "items": ["XXXX-XXXX-XXXX-XXXX", "YYYY-YYYY-YYYY-YYYY"] },
  "failure_code": null,
  "failure_message": null,
  "created_at": "2026-10-06T12:00:01.000Z",
  "delivered_at": "2026-10-06T12:00:03.000Z"
}

VAT

VAT is decided from your billing and, when your billing country is outside the EU, from the country your server calls us from. The order's vat shows what was applied.

If the EU register (VIES) is unavailable when you order, the order goes through with VAT; contact us to reclaim it. A VAT number the register rejects returns 400.

Order statuses

Idempotency and retries

Send an Idempotency-Key header on every order: one unique key per customer purchase, for example your own order number. If the connection drops or you get a 503, retry the identical request with the same key. You are never charged twice: the retry returns the existing order. Without a key, a retry can create a second order.

Only product_id and quantity are compared: reusing a key with a different product or quantity returns 422 idempotency_error, and with any other change it returns the original order. A key whose order failed for insufficient balance keeps returning that result: use a new key after topping up.

Errors

Errors return { "error": { "message": "...", "type": "..." } }. Branch on the HTTP status and type.