PIX ↔ Stablecoins.
One API.

Money moves both ways.

Lunium connects PIX and stablecoins in a single programmable infrastructure.

Integrate without waiting on us.

The infrastructure was built for developers to start from the API — not from a sales call.

No manual credential provisioning. No waiting for someone to create your first key.

From PIX to stablecoin in one integration.

const response = await fetch(
  "https://api.luniumpay.com/cashin/charge",
  {
    method: "POST",
    headers: {
      "X-API-Key": process.env.LUNIUM_API_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      amount_cents: 25000,
      payer_tax_number: "12345678901",
      payout_address: "0x…",
      asset: "usdt",
      external_id: "order_8812"
    })
  }
);

const charge = await response.json();

{
  "cashin_id": "ci_b3f9d2a41c6e…",
  "status": "pending",
  "amount_cents": 25000,
  "chain": "polygon",
  "asset": "usdt",
  "qr_copypaste": "00020126…",
  "qr_image_url": "https://…",
  "external_id": "order_8812",
  "expires_at": "2026-…"
}

Your application receives the PIX. Lunium handles the rest of the path.

Built for developers.
Designed for production.

Cash-out on the networks your customers already use.

Lunium's catalog exposes the assets and networks available for cash-out — live, not in a stale table.

The quote first.
Then the money.

Financial infrastructure should never require your application to guess the final amount.

The API returns the values the transaction will use.
Your system displays the quote. Lunium remains the source of truth.

Every transaction has a lifecycle.

Your application follows state through the API — and receives every transition by webhook.

Built so a retry never becomes a double payment.

Financial APIs fail differently from ordinary ones.

Connections drop. Servers restart. Responses time out.
And your application retries the call.

Lunium's idempotency model lets the same external_id safely reference the same financial operation — including to recover it after an ambiguous error.

Your operation. Live.

An API for your software.
An agent for your team.

An API for machines. An agent for humans.

Test the failure before the failure tests you.

Lunium's cash-out sandbox uses the same API shape and the same lifecycle as production. Each scenario has a deterministic trigger — good for CI, not just for curiosity.

For people building financial products.

What the API does is stated by the API itself.

Not a sales deck. Not a PDF. It is the API.

Your integration reads the current configuration instead of relying on assumptions.

Don't take our word for it.
Read the API.

Infrastructure you inspect before you buy.

Most payment companies ask you to talk to sales before you can understand the product. Lunium does the opposite.

• 01Read the documentation.
• 02Inspect the endpoints.
• 03Create a sandbox key.
• 04Understand the lifecycle.
• 05Test your integration.

Then talk to us — when you need production limits, commercial terms or enterprise support.

Built for developers. Ready for agents.

Integrate through the same simple API you already know — or let software discover and integrate it on its own. Both doors lead to the same infrastructure.

It is the same API. The agent layer is additive — anyone who does not need it never runs into it.