Hilt Pay API

Let agents add stablecoin-paid access to your product.

Hilt Pay API turns a stablecoin payment into an operational access record: payment session, proof, receipt, entitlement, webhook, renewal state, support context, and audit trail. Launch settlement is Solana USDC, with x402 as the HTTP 402 protected-resource protocol and a full agent-readable developer surface around it.

View the FastAPI proof demo Open API docs View API pricing

Hero proof

Protect /ai/pro in 20 minutes.

Check Hilt entitlement before serving the paid endpoint.

Return HTTP 402 with a Hilt-created x402 payment requirement when unpaid.

Let the buyer or agent pay over Solana USDC at launch.

Retry only after Hilt returns has_access: true.

Open the protected-resource example

Agent bootstrap and setup intents

Let an agent prepare the setup, test the protected-resource loop, recommend the right API tier, then hand live approval back to the owner.

Payment-to-access API

Create apps, products, sessions, receipts, entitlements, webhooks, and denied -> HTTP 402 -> access checks through code.

SDKs, GitHub, npm, PyPI

Use the TypeScript SDK, Python SDK, Postman collection, and example apps as the supported agent/developer surface.

Agent-first setup

Agents can prepare the integration. Owners keep the live controls.

An agent can propose the app, product, protected resource, webhook, entitlement check, and x402 over Solana USDC payment path. Hilt returns readiness, blockers, and the next API actions; the owner approves billing, live keys, payout wallets, and emergency control.

Agent setup guide

Discover

An agent finds Hilt through docs, llms.txt, OpenAPI, SDKs, Postman, npm, PyPI, or GitHub developer assets.

Bootstrap

It creates a sandbox setup intent and submits a manifest for the app, product, protected resource, webhook, and Solana USDC settlement rail.

Approve

The owner approves live control from Hilt, adds billing and payout settings, and receives scoped API credentials.

Run

The product uses Hilt for payment sessions, x402 HTTP 402 requirements, receipts, entitlements, webhooks, support context, and audit history.

Official developer surface

Everything an agent, builder, or engineering team should reach for first.

The public API, SDKs, Postman collection, CLI, examples, and docs are the supported way to build on Hilt Pay API. The dashboard still exists for approval, audit, support, and human control.

FastAPI protected-resource demo

Copy the denied -> HTTP 402 -> payment -> proof -> entitlement loop for a paid AI/API endpoint.

Open demo

Official SDKs

Install the TypeScript SDK from npm or the Python SDK from PyPI. Both expose the Hilt Pay API alias and agent setup helpers.

Open npm

CLI and Postman

Use the CLI for repeatable operator checks and Postman collections when a team wants to inspect the supported API surface before writing code.

Open Postman

Webhooks and operations

Treat webhooks, receipt lookups, entitlement checks, support context, audit events, and recovery playbooks as part of the integration from day one.

Open webhooks

Agent Discovery Standard

Check the public discovery contract that keeps llms.txt, OpenAPI, SDKs, Postman, GitHub, npm, PyPI, docs, and examples aligned.

Open standard

Integrations

Keep the workspace integrations, then automate the serious parts.

Hilt Pay Workspace and Hilt Pay API share the same payment-to-access operating layer, so WooCommerce, Zapier, receipts, memberships, support, and webhooks do not become separate islands.

WooCommerce

Route eligible WooCommerce orders into hosted Hilt checkout and keep the order trail readable.

View WooCommerce

Zapier

Send Hilt events to the tools merchants already use for follow-up, support, and CRM work.

View Zapier

API example

Bootstrap an agent setup intent before a human creates keys

curl -X POST https://api.hilt.so/v1/access/agent-bootstrap \
  -H "Content-Type: application/json" \
  -d '{
    "agent_name": "Acme API Builder",
    "agent_platform": "cursor",
    "requested_use_case": "Protect /ai/pro with Hilt Pay API",
    "requested_permissions": ["access:read", "access:write", "access:webhooks"],
    "ttl_hours": 24
  }'

CLI example

Submit a setup manifest the owner can approve

curl -X POST https://api.hilt.so/v1/access/agent-bootstrap/{intent_id}/manifest \
  -H "Content-Type: application/json" \
  -d '{
    "setup_token": "hst_...",
    "manifest": {
      "app": { "name": "Acme AI" },
      "product": {
        "external_product_id": "pro-api",
        "title": "Pro API access",
        "amount_minor_units": 79000000,
        "default_rail": "solana_usdc"
      },
      "payment_protocol": "x402",
      "settlement_rail": "solana_usdc",
      "protected_resource": { "url": "https://api.acme.test/ai/pro" }
    }
  }'

The setup manifest gives an agent a precise way to say what it plans to create. Hilt returns sandbox readiness, live blockers, and the next API calls instead of asking the owner to wire everything manually.

npm install -g https://www.hilt.so/downloads/hilt-cli-latest.tgz

Official packages and assets

Install the SDKs or import Postman without generating your own client first

TypeScript SDK

Install from npm, inspect the source on GitHub, and use the developer-assets repo for approved public snapshots.

npm install @hiltpay/sdk

Open npm package Open GitHub repo

Python SDK

Install from PyPI, inspect the source on GitHub, and use the direct wheel only as a controlled fallback.

pip install hilt-sdk

Open PyPI package Open GitHub repo Fallback wheel

Developer assets and Postman

Use the supported docs, SDKs, Postman imports, and approved developer-assets snapshots rather than building against internal surfaces.

Open developer-assets repo Fallback Postman collection Fallback Postman environment

API coverage

What you can automate

Create agent setup intents and submit manifests before the owner approves live mode.

Create apps, products, sessions, protected resources, receipts, and entitlements through code.

Return x402 HTTP 402 requirements that settle over Solana USDC at launch.

Receive signed webhooks for payments, receipts, entitlements, delivery, and support changes.

Check access by entitlement before serving paid software, API routes, bots, datasets, or private tools.

Fetch receipts, entitlements, support context, audit state, and webhook history without asking the merchant to log in.

The public API should be enough for software and agents to build the integration. The dashboard remains the control plane for owner approval, billing, rail settings, emergency disable, support review, and audit history.

Hilt Pay API

Agent-ready payment sessions, receipts, entitlements, webhooks, and x402 protected-resource protocol infrastructure over Solana USDC.

Open

Agent setup

Use setup intents, manifests, sandbox keys, and owner approval to let agents configure Hilt safely.

Open

x402 for agents

Understand how Hilt uses HTTP 402 requirements over Solana USDC settlement for protected APIs.

Open

Protected API example

Copy the denied -> 402 -> payment -> proof -> entitlement flow for an AI/API endpoint.

Open

SDKs and Postman

Install the official Hilt TypeScript SDK, Python SDK, and Postman assets.

Open

Checkout and products

Create products, generate hosted checkout links, and resolve checkout state.

Open

Webhooks

Receive signed Hilt events for payments, receipts, memberships, delivery failures, and support changes without building your own relay first.

Open

Zapier

Connect Hilt events, checkout links, and membership lookup to Zapier with a read and execute API key.

Open

Testing and playbooks

Run sandbox sessions, then use launch playbooks for webhooks, delivery recovery, receipts, and renewals.

Open

Direct answers

What technical teams usually want answered before they wire Hilt in.

The strongest integrations answer the operational questions directly: what Hilt owns, what your backend owns, and where to find the supported API, SDK, Postman, and webhook guidance.

Can an agent set up Hilt Pay API without the owner clicking through every step?

Yes. Agent Bootstrap lets an agent create a sandbox setup intent, submit a setup manifest, create the proposed app/product/webhook shape, and then hand live approval back to the owner. The owner still controls billing, live keys, payout settings, and production enablement.

What is the fastest way to integrate Hilt?

Use Agent Bootstrap to create a sandbox setup intent, submit a setup manifest, test the protected-resource flow, then let the owner approve live mode from the dashboard.

Is Hilt Pay API the same as the merchant workspace?

No. Hilt Pay Workspace is for humans operating checkout from the dashboard. Hilt Pay API is for software and agents that need payment sessions, receipts, entitlements, webhooks, and audit state through code.

Should I poll or rely on webhooks?

Webhooks are the primary backend path for confirmed payment, receipt, membership, delivery, and support events. Polling still helps while a buyer is actively waiting in checkout or when you want explicit defensive reconciliation.

Where are the official developer assets?

Use the Hilt docs, official TypeScript SDK on npm, Python SDK on PyPI, public GitHub repos, Postman assets, CLI, and approved developer-assets snapshots as the supported public developer surface.