DePix App MCP

Choose which of this account's two API keys the server authenticates with from now on: test (sandbox — no real money) or live (the production starter: wallet_read + wallet_write, i.e. the wallet tools). Both keys already belong to the account register_account created on this machine — nothing is minted and no secret is shown; the choice is saved and survives restarts, and the wallet picks it up on its next call. Under live, wallet_create_deposit produces REAL Pix charges and wallet_create_withdrawal moves real money: confirm with the operator before switching. If DEPIX_API_KEY is set in the environment it still OVERRIDES the choice, and the response says so.

Make a product purchasable again. Requires scope `merchant_write`.

Read the agent account's onboarding progress: whether it is active/suspended, whether it has graduated to live keys and what is still blocking that, and its keys (id/prefix/scopes/revoked — never the secret). Read-only; narrates what the server reports, never recomputes the rule. Requires an account already registered here — if there is none, call `register_account` first. `graduation_blocked_on` says whose move it is: "domain_proof" is yours — call `verify_domain`, then relay its DNS record to the operator, who alone can add it; "gate_review" is ours — poll, there is nothing to do; null once graduated. Deposits do not graduate an account.

Attach ONE file to a ticket so the support team can see it — typically a diagnostic/log file or a screenshot that documents a bug. Provide the bytes base64-encoded in file_b64 (no data: URI prefix), up to ~3 MB, with content_type one of image/png, image/jpeg, image/webp, application/pdf, text/plain or application/json. The file is forwarded to a human on the support side; it is not stored or served back, so the result records only the filename and type. Attaching counts as a reply: an answered ticket returns to awaiting a reply, and an auto-closed ticket within 7 days reopens. If the response is attachment_unavailable, retry shortly or continue with reply_support_ticket.

Close one of your tickets once you no longer need help. This is terminal — to continue later, open a new ticket.

Let this merchant be paid in DePix sent DIRECTLY on Liquid, not only by Pix. Enabling derives a dedicated receiving address from THIS wallet and registers it with the backend so incoming DePix is credited; disabling turns it off. Needs an initialized wallet (to derive the address — the operator runs `npx -y @depixapp/mcp init`) and a registered agent account (the call is signed — call `register_account` first). You pass only `enabled` (and, optionally, a `derivation_index` to re-derive a specific address) — the tool derives the address and its private viewing key itself and sends them in-process. The response carries only PUBLIC facts (the address, the rail state): the viewing key is NEVER shown here.

Create a ONE-OFF payment (checkout) with a hosted payment page, on either settlement rail — paid once, short-lived. For a dated or recurring payment link (a "cobrança": rent, tuition, an instalment), use `create_product` with kind="charge" instead. Default `payment_method: "pix"` — the payer pays a Pix QR in any bank app, and `payer_tax_number` (their CPF/CNPJ) is required. `payment_method: "depix"` — the payer sends DePix wallet-to-wallet on the Liquid network to the merchant's dedicated address: there is no Pix QR (the response carries `depix` instead of `pix`), no payer document is used, the merchant may grant a discount, and the payment is confirmed on-chain — `approved` at the first confirmation (~1 minute) and `completed` at the second (~2 minutes). The depix rail requires the merchant to have it enabled, otherwise the API answers `depix_not_enabled`. Requires scope `merchant_write`. Amount is BRL cents (the face value, before any DePix discount).

Mint a NEW API key for the account registered on this machine and start using it. The key is sealed in the local encrypted vault and NEVER shown — the response carries only public facts (id, prefix, scopes, limits). Defaults to a sandbox key with the wallet scopes, the only set that always works. `merchant_read`/`merchant_write` (being paid by third parties) need a VERIFIED DOMAIN — call `verify_domain` first, which mints that key for you; asking for them without one is refused with domain_required. `live: true` needs the account to be graduated, else graduation_pending. Minting replaces the vault's key for that mode, so the OLD one keeps working at the server until you revoke it with revoke_key — and its local copy is gone, so revoke it or note the id from agent_status. Five keys per mode is the ceiling.

Create a reusable product (fixed-price checkout template with a public page), or — with kind="charge" — a CHARGE (Portuguese: "cobrança"): a payment link with a due date and optional late fine/interest, for rent, tuition or an instalment. A charge is served at pay.depixapp.com/c/{id} and never appears on the merchant's public store. NOTE: `create_checkout` makes a ONE-OFF payment that is paid once and is short-lived; this tool with kind="charge" makes a STANDING one that has a due date and can recur. Requires scope `merchant_write`.

Hide a product from the public page and block new checkouts. On a CHARGE this also kills its live pay.depixapp.com/c/{id} link — anyone holding it sees "cobrança indisponível" and cannot pay. Reversible with activate_product. Requires scope `merchant_write`.

Identify the authenticated merchant (connection test). Requires scope `merchant_read`.

Fetch a checkout by id (owner view). `payment_method` tells you which rail it settles on; a still-payable depix checkout also carries its `depix` payment instructions (address, exact amount, URI). Requires scope `merchant_read`.

Read a deposit's status (read-only). Requires scope `wallet_read`. This MCP cannot create deposits (that is the SDK, F3).

Narrate what the account still needs to go live: an ordered ladder of steps (create the wallet, verify WhatsApp, deposit+convert+withdraw to verify, create the store), each with a plain PT+EN title and instruction to relay to the human, an absolute app deep link, and the current numbers. Composes the verification progress with a store probe, and — when every step is complete — triggers verification itself so the account never sits 'all green but not verified'. Read-first; the only write is that self-heal trigger. Every incomplete step is a HUMAN step: relay its instruction and deep link to the operator and wait — no tool here can complete one for them.

Fetch a product by id with checkout aggregates. Requires scope `merchant_read`.

Fetch one of your tickets with its full message thread. Poll this to read the human's reply — support answers within 1 business day, so check back in minutes, not seconds. Returns 404 if the ticket does not exist or was opened by another session/key.

Read the account's position in the Cofre deposit-hold mechanism (read-only): whether it is active, how long a new deposit is held, the trust level, and the rolling receive cap with how much is left this window. Requires scope `wallet_read`.

Read a withdrawal's status (read-only). Requires scope `wallet_read`. This MCP cannot create withdrawals (that is the SDK, F3).

List checkouts with filters and pagination. Requires scope `merchant_read`.

List checkouts created from a product. Requires scope `merchant_read`.

List products with filters and pagination. Charges are NOT included by default — pass kind="charge" to list them (each row then carries `charge_state` with the current cycle, days late and today's total) or kind="all" for both. Requires scope `merchant_read`.

List the tickets you opened (this session/key), newest activity first. Use get_support_ticket to read a thread and poll for replies.

Read recent webhook delivery attempts (read-only): the event, the endpoint, the HTTP status it returned or the transport error, the attempt number and when it was sent — newest first. Pass `id` to fetch one delivery. Did my webhook arrive, and what did the endpoint answer?

Open a support ticket for a bug, unexpected behavior, or an account/payment problem. The body becomes the first message. A human replies within 1 business day — replies are NOT pushed to you: poll get_support_ticket to read them (check back in minutes, not seconds; this is not a live chat). For API or how-to questions, the docs (depixapp.com/docs and depixapp.com/llms.txt) usually answer instantly — prefer a ticket only when something is broken or account-specific. Up to 5 open tickets per account.

Create a DePix agent account and its API keys IN THIS PROCESS, on the operator's machine. THREE THINGS ARE NEEDED FIRST — check them before calling, and relay whichever is missing to the human: (1) a wallet on this machine — the operator runs `npx -y @depixapp/mcp init` in a terminal, which also sets the passphrase that seals the account's keys; (2) the operator's op_ code — send them https://api.depixapp.com/api/agents/oauth/start, they sign in with Google or GitHub and read the code back to you (it reappears on every sign-in), or they set DEPIX_OPERATOR_TOKEN in the host config; (3) their notification email, for `operator_email`. The account's keys are saved ENCRYPTED on this machine and used immediately — no restart, nothing pasted into a config. The response carries only PUBLIC facts (username, store slug, pacing caps, key IDs): the secret keys are NEVER shown here. Activates the sandbox (sk_test_) key by default. If DEPIX_API_KEY is set in the environment, it OVERRIDES the new key and the response says so.

Post a reply to one of your tickets. On an answered ticket this moves it back to awaiting a reply; on an auto-closed ticket within 7 days it reopens it. A human answers within 1 business day — poll get_support_ticket for the response (minutes, not seconds).

Kill an API key, in two phases. Phase 1 (omit confirm): nothing is written — it returns what that key IS (prefix, scopes, whether it is the starter) so you can tell the human exactly what is about to die. Phase 2 (confirm: true): the key stops working immediately and cannot be restored. ASK THE OPERATOR between the two phases. If you revoke the key this server is authenticating with, the next call fails until you mint another (create_key) or switch to the other mode (activate_key) — get the id from agent_status and be sure which one it is.

Reconcile the pinned product set/order on the public page in one call (empty array clears all). Requires scope `merchant_write`.

Mark a SANDBOX checkout as paid so you can observe checkout.completed. Live checkouts return sandbox_only. Requires scope `merchant_write`.

Update the store's LIGHT profile fields — business_name, logo_url, website, default_redirect_url, default_callback_url — via PATCH /api/merchants/me. Only the fields you pass change. The money-redirecting fields (liquid_address, split_address) are NOT here by design and cannot be changed with a key. Requires scope `merchant_write`.

Partially update a product or charge (only provided fields change). A charge's due_date, recurrence and late fees are editable here; `kind` is not — it is fixed at creation. Requires scope `merchant_write`.

Prove control of a domain via a DNS TXT challenge, in two phases. Phase 1 (omit confirm): returns the TXT record NAME and VALUE to create — relay it to the human to add at their DNS provider (only they can: it is their DNS panel, and propagation takes minutes). Phase 2 (confirm: true, after propagation): the server resolves the record and, on a match, records the domain as verified. A verified domain lifts domain_required on the merchant scopes, so phase 2 ALSO trades this account's starter key for one that carries them (merchant_read + merchant_write + the wallet scopes), activates it, and revokes the starter. That upgrade is minted BEFORE the old key is revoked, so a refused mint costs nothing: the domain still counts, the old key still works, and `upgrade_note` says what happened. No secret is ever shown.

Wait server-side for a checkout to reach a terminal status, emitting progress. One call — no client-side polling. Returns { status, terminal, timed_out }. Requires scope `merchant_read`.

Buy a gift card or mobile top-up from CryptoRefills and pay it over Lightning via Boltz (NON-custodial). Discover `brand_name` with wallet_list_giftcards, then `denomination` with wallet_list_giftcard_products: pass the exact denomination string for a FIXED product, or "range" + `product_value` for a DYNAMIC one (wallet_list_giftcard_products tells you which, plus the min/max; wallet_giftcard_price quotes a custom value). MOVES MONEY: the L-BTC lockup passes through the owner's guardrails (value caps; with the allowlist on, BOTH the Lightning payee AND the gift-card beneficiary must be opted in) BEFORE signing, plus a 1% DePix service fee. Delivery goes to `email` (or beneficiary_account) — poll wallet_get_giftcard_order_status for the phase + redemption code/URL. Returns once the lockup is broadcast; Boltz then pays the invoice in the background. Amounts are base units (sats).

THE PRIMARY conversion surface — converts between assets/networks end to end (e.g. DEPIX→LBTC, LBTC→BTC@lightning, DEPIX→USDT@ethereum) in ONE call; prefer it over the low-level provider tools (wallet_swap_*, wallet_to_stablecoin, wallet_shift_usdt). Executes exactly ONE route: single-hop directly, multi-hop legs sequentially behind a crash-safe persisted plan (wallet_recover resumes after any interruption). MOVES MONEY: every money-moving leg passes through the owner's guardrails BEFORE signing; routes transiting a custodial provider return custodial:true. If several candidate routes resolve the intent, the call fails with MULTIPLE_ROUTES_AVAILABLE and the candidates in error.data.routes — call wallet_quote and pass `route`. Outbound cross-network routes need `address` (or `invoice` for lightning). Waits for settlement by default; on timeout it returns status pending with a next_step — funds in flight are never lost. amount_sats is the FROM asset's BASE UNITS.

Create a Pix deposit charge, returning a copy-and-paste (BR Code) the human OWNER pays to fund this wallet with DePix. amount_cents is BRL cents; payer_tax_number is the PAYER's CPF/CNPJ. Not a checkout QR. Creates a charge but moves no money itself.

Withdraw to a Pix key: build ONE Liquid transaction (provider output + explicit fee output), sign and broadcast. amount_cents is BRL cents; mode `send` = the DePix you send, `payout` = the BRL the recipient receives; recipient_tax_number is the DESTINATION Pix key holder's CPF/CNPJ. A fresh receive address of THIS wallet is sent as the refund address, so a Pix the provider cannot complete comes back here — no parameter to pass. MOVES MONEY: passes through guardrails on the GROSS before signing. Irreversible once broadcast.

Read a health snapshot for support/debugging: SDK + LWK versions, data dir, backup state, sync health (last scan/success and the last update-persist failure), per-rail pending counters, and the guardrail budget. Read-only and local (no network, no signing) and carries NO key material — never the seed, mnemonic or descriptor. Moves no money.

Return a FRESH, unused Liquid receive address for this wallet (no on-chain reuse across calls). Blocked with BACKUP_REQUIRED until the seed backup is exported and confirmed (§2.9). Moves no money.

Return confirmed on-chain balances for DePix, L-BTC and USDt in base units (sats, as strings), plus a total BRL-cent estimate (null if a needed quote is unavailable). Moves no money.

Poll one order's LIVE status at CryptoRefills and fold it into the local log: returns the `phase`, a `terminal` flag (stop polling once true), and the `delivery` — the redemption code or URL once the order reaches 'delivered'. Use after wallet_buy_giftcard to retrieve the gift card. Read-only, no config gate, moves no money.

Read the owner's guardrail config and current rolling-24h usage (caps in BRL cents, used, remaining, whether the allowlist is on). Read-only — guardrails are immutable at runtime and no tool can change them (G9).