# Charge for an API in one line

Point any x402 server SDK at `https://pay.neuronto.com` and advertise a wallet you control. That is the whole
integration: your server never holds a key and never talks to a chain.

```js
new HTTPFacilitatorClient({ url: "https://pay.neuronto.com" })
```

Live right now: `eip155:8453`. [/supported](https://pay.neuronto.com/supported) lists every network, scheme and version this
facilitator settles at this moment, and a network that cannot settle disappears from it before it
starts refusing, so a server that reads it never advertises a price it cannot take.

## Node, Express

```js
import express from "express";
import { paymentMiddleware, x402ResourceServer } from "@x402/express";
import { ExactEvmScheme } from "@x402/evm/exact/server";
import { HTTPFacilitatorClient } from "@x402/core/server";

const server = new x402ResourceServer(
  new HTTPFacilitatorClient({ url: "https://pay.neuronto.com" }),
).register("eip155:8453", new ExactEvmScheme());

const app = express();
app.use(paymentMiddleware({
  "GET /premium": {
    accepts: { scheme: "exact", price: "$0.001", network: "eip155:8453", payTo: "0xYourWallet" },
    description: "One premium answer",
    mimeType: "application/json",
  },
}, server));
app.get("/premium", (req, res) => res.json({ ok: true }));
app.listen(3000);
```

## Python, FastAPI

```python
from fastapi import FastAPI, Request
from x402 import x402ResourceServer
from x402.http import FacilitatorConfig, HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import register_exact_evm_server

server = x402ResourceServer(HTTPFacilitatorClient(FacilitatorConfig(url="https://pay.neuronto.com")))
register_exact_evm_server(server, "eip155:8453")

middleware = payment_middleware({
    "GET /premium": {
        "accepts": {"scheme": "exact", "payTo": "0xYourWallet", "price": "$0.001",
                    "network": "eip155:8453"},
        "description": "One premium answer",
        "mimeType": "application/json",
    }
}, server)

app = FastAPI()


@app.middleware("http")
async def x402(request: Request, call_next):
    return await middleware(request, call_next)


@app.get("/premium")
def premium():
    return {"ok": True}
```

Hono and Next.js versions, and paying clients in Node and Python, are in [https://github.com/neuronto/x402-starters](https://github.com/neuronto/x402-starters).

## Test it without spending anything

[`/echo`](https://pay.neuronto.com/echo) is a live merchant on this origin: it charges $0.001 and sends it straight
back in the same request, and the gas is ours.

```bash
curl -i https://pay.neuronto.com/echo
```

Point any x402 client at that URL. A replayed payment is answered from the record rather than
charged again, and [`/echo/status`](https://pay.neuronto.com/echo/status) says whether it is serving.

## For agents

`POST https://pay.neuronto.com/mcp` is an MCP server with four tools: `facilitator_status`, `settlement_price`,
`find_paid_resource` and `integration_snippet`. It needs no key. `GET` and `DELETE` on that path
answer 405, never 404, so a client that probes it can tell the difference between a wrong verb
and a server that is not there.

Agent-readable copies of everything: [/llms.txt](https://pay.neuronto.com/llms.txt), [/openapi.json](https://pay.neuronto.com/openapi.json),
[/.well-known/ard.json](https://pay.neuronto.com/.well-known/ard.json), [/.well-known/api-catalog](https://pay.neuronto.com/.well-known/api-catalog).

## What to read next

- [Developer reference](https://pay.neuronto.com/developers): every endpoint, the settlement semantics, the errors.
- [Pricing](https://pay.neuronto.com/pricing): what a settlement costs and how the figure is computed.
- [Status](https://pay.neuronto.com/status): observed availability, screening, and what is settling right now.