api.iamjuliand.com: autonomous services with x402 payments
I just launched api.iamjuliand.com: a public technical-audit API that can be discovered, used, and paid for without creating accounts, generating API keys, or setting up a traditional checkout.
The idea is simple: a service should be able to declare what it does, how much it costs, and how to pay. A client—including an agent—should be able to use it autonomously when needed.
That is what x402 enables: the protocol turns the HTTP 402 Payment Required status into a payment negotiation within an HTTP request.
The payment flow
The first request to a paid endpoint does not run the work right away. The API validates the input and responds with 402, along with the x402 V2 payment requirements.
The client signs the payment and repeats the exact request with the PAYMENT-SIGNATURE header. Once settlement is confirmed, it receives the result and the PAYMENT-RESPONSE header.
There are no forms or redirects between intent and result. Payment is part of the protocol the application already uses.
Production payments run on Base. The API also has a test specification on Base Sepolia, so you can integrate the flow without using real funds.
The first products
The service brings together small, useful tasks for development tools and agents. The first four products are deterministic:
- Scan code or configuration for secrets for $0.005. Returns redacted findings, not exposed credentials.
- Audit OpenAPI documents for $0.012: quality, security, interoperability, and usability for agents.
- Review prompts and
AGENTS.mdfiles for $0.008 to find excessive permissions, contradictions, and operational risks. - Infer or validate JSON Schema for $0.006 from samples or a supplied schema.
I also published agent-workflow-red-team, a red-team review of agent workflows for $0.12. It takes the agent prompt, available tools, their side effects, the operational policy, and scenarios with untrusted content.
It first analyzes the declared capabilities, permissions, and boundaries locally. Then it performs a structured AI adversarial review to identify attacks, findings, mitigations, and regression tests.
This last product is not deterministic: its adversarial review uses AI and returns the model and associated usage as part of the result.
It does not run the supplied tools; it evaluates them as the workflow’s contract to find gaps before production.
Each product defines its input limits and response time. Settlement happens only after the input is valid and the service responds successfully; an invalid request is not charged.
Built for humans and agents to discover
Alongside the product endpoints, I published the contracts that make integration possible without prior conversation:
- OpenAPI for tools and HTTP clients.
- x402 manifest with machine-readable payment information.
- Agent guide with the integration flow.
- Service catalog with current products, prices, and limits.
This matters because an agent should not need a custom integration for every service. If it can read the contract, handle the 402 challenge, pay, and retry the request, it can use the capability on its own.
Why I am interested in this model
Conventional APIs often start with an account, a secret key, plans, invoices, and reconciliation. That model makes sense for ongoing relationships, but adds friction to a one-off, verifiable action.
With x402, a tool can pay for exactly one operation. The provider receives payment after completing useful work; the client does not have to provide a card, create an account, or commit to a subscription.
This is still an early stage, but I am excited about the direction: small, composable, verifiable services that agents can hire just as they call an API.
If you want to try it or integrate a client, start with the public OpenAPI spec or the integration guide.