Infrastructure · Payments

Payments for your software, reduced to one simple question.

We take a major software payment processor, the same rail that bills behind products you already use, and reduce it to one question: “can this customer get in?”. The answer comes right away, from your side, in 224 ms measured. You get paid, and controlling who can use what becomes one line of code instead of a subsystem.

Start free, no card and no sales call: the key is issued right away. Subscriptions by card, through Stripe; one-time charges by Pix or card, through Mercado Pago. The dashboard is in Portuguese for now.

What you get

Five jobs you never do again.

They do not get easier. Nobody on your team writes any of them.

You do not write

Storing who paid, and changing it every time it changes

Who subscribes, to which plan, until when, and the link to their record at the processor. Every time your product changes, this changes with it. On our side it is already built and versioned. On yours, it stops existing.

You do not write

Listening to the processor and understanding what it sent

Checking that the notice really came from it, telling an approved payment from a declined one, deciding what each means for the customer’s access, and what to do with notices you do not recognize. That is 377 lines on our side. On yours, it becomes zero.

You do not write

Caching the answer and working out when it went stale

Whoever caches this answer to save time inherits the hardest part: knowing when to throw it away. Here you ask directly and get the answer in 224 ms, measured. The answer is always the current one.

You do not write

Reconciling by hand when a notice gets lost

That overnight script that compares your database with the processor’s dashboard and fixes the differences. It only exists because the information lived in two places that disagreed. With one place, there is nothing left to reconcile.

You do not write

Telling your customer that the charge happened

Welcome, receipt, declined payment, account deactivated. Each must go out exactly once, even when the processor resends the notice three times. That is the hard part, not writing the text. It goes out under YOUR system’s name, and you rewrite the text in the dashboard without touching code.

The whole path

Install, ask, receive.

Four blocks, and you can run the second one now, from your terminal, without an account.

1 · Install

One package, and the provider at the root

It is 36,486 bytes of ESM with no build step: package.json points straight at the source, so there is no bundler of ours in your path. It ships with the pricing table, the customer portal and per-feature access control ready to use, which is why it brings @mantine/core along. If you only want the HTTP routes, you do not need the package: they are two GET requests, in any language.

bash / main.jsx
$ bun add @ciromaciel/payments-react

import { PaymentsProvider }
  from '@ciromaciel/payments-react'

<PaymentsProvider
  publicKey="pk_…"
  gatewayId="gw_…"
>
  <App />
</PaymentsProvider>

2 · Ask

The question your application actually asks

Your product’s question is not “did this customer pay?”. It is “can this customer use this right now?”. The answer comes from our database immediately, without querying the processor. And this command works right now, with this page’s own key: paste it in your terminal and see the answer before you even create an account.

bash
$ curl "https://payments.worker.myinfrastructure.click\
/sdk/v1/permissions\
?publicKey=pk_1f01ce76…\
&userId=teste-inexistente"

{"message":"Permissions retrieved",
 "data":{
   "hasActiveSubscription":false,
   "subscriptions":[],
   "features":[]}}

3 · Receive

One endpoint, and we register the events for you

You point to a URL, and a POST to /gateways/:id/auto-setup registers the five events on the gateway. Each event is verified by signature before any processing: with no secret configured, the endpoint rejects with 400 before reading the body.

webhook
POST /webhook/:gatewayId

// verificação, antes de processar
await gateway.webhooks
  .constructEventAsync(
    payload, signature, secret
  )

// assinatura inválida → lança
// → HTTP 400

4 · Protect

The hook is a convenience. The server is the authorization.

Two lines of defense, each in its place. On the frontend, useHasFeature reads from context with no network call: instant, for hiding a button or switching a screen. On the server, the secret key does the real authorization. It decides access. The SDK ships both sides ready, split the way payment products usually split them.

App.jsx
// frontend: só esconde a UI
const pode = useHasFeature(
  'react-sdk-access'
)

// servidor: isto é o que vale
fetch(url, { headers: {
  Authorization: 'Bearer sk_…'
}})

Model Context Protocol

Your agent administers the operation. No code in between.

The truth about subscriptions already lives here. What was missing was a way for the agent to ask without someone writing the integration. Four lightweight tools do everything the dashboard does, on the 2026-07-28 revision, stateless. It administers: reads metrics, investigates late payments, creates plans, generates payment links, rotates keys. Deleting or canceling waits for your yes, in the conversation. It is not a payment method: the customer pays, in the gateway’s checkout.

What the server does NOT offer

  • Deleting a plan, feature or gateway, canceling a subscription only after your yes, in the conversation: the first call only asks and shows what will happen. An agent that reads "delete everything" in a document stops there.
  • The processor key does not pass through here the processor key does not come in or go out through here. Where it matters, a preview is sent, sk_live_…4242, and the mode. A secret that passes through an LLM context leaks into logs and transcripts.
  • Changing an active subscription has a separate scope because it creates an immediate invoice on a real person’s card. It is the only one marked as destructive, and the secretKey cannot reach it: it requires a login that says who gave the order.

The address ends in the project id, and that is not decoration a token identifies a person, and a person administers several projects. The id becomes the token’s audience, so consent given to one project does not apply to the others. This is the confused deputy check from RFC 8707. Connecting to /mcp without the id is rejected with a message saying where to copy the right address.

The yardstick

The five axes that decide the choice

The same table on every Infrastructure product page. Each row has the number we measured, the date and the method, not a promise. Two rows here are unfavorable, and they stay in the table.

Leave and take everything

One curl, no ticket

One route returns your subscribers, plans and statuses as JSON whenever you want, on the first day and the last, with no ticket, no wait and no sales call. That is enough to rebuild the permission layer anywhere. Charges, events and CSV come in the next version of the export.

Where the subscription truth lives

On your side

The record is ours, keyed by the subscription id at the gateway, and the permission query answers without calling its API. This is the only axis where we are faster than asking the gateway, and it is the reason this page exists.

Native recurring Pix

No

Subscriptions are recurring card payments, through Stripe, and they are ready: renewal, failed payment and cancellation are all handled. Pix exists for one-time charges since Oct 28, 2026: the /charges API charges an amount once, by Pix or card, on the project’s own Mercado Pago account. Recurring Pix, subscriptions by Pix and boleto do not exist.

Cost in BRL

Free with 1 project

No card and no time limit: the free plan runs 1 project. Paid plans only change how many projects the account has (3 on Starter, 9 on Pro, 99 on Scale), with prices in the table below, read live from the same API you integrate.

Read latency for a user in São Paulo

Not measured from SP

What we measured: 224 ms of server processing (median of 12 samples, Aug 26, 2026), out of a 506 ms total, of which 286 ms is connection handshake. But our measurement came from Boston, not São Paulo. Until we measure from SP, this row stays as it is.

If any of these numbers does not match your case, write to us. We measure again and fix the row.

Pricing

Plans come from the API, live

Prices are in Brazilian reais (BRL), charged by Stripe.

FAQ

The objections, in the order they come up

Found a limit that is not written here?

Talk directly with the people who wrote the code. If you found where it breaks, we want to publish it on this page before the next visitor finds it alone.

Get a key and run the curl. It takes two minutes.

No card and no “contact sales”: the key is issued right away, and the first curl answers before you create an account. Today’s rail is recurring card billing, on Stripe. If that is what your product charges, you can integrate today.