Register a Plan & AI Agent

Have an agent publish an AI agent and a priced payment plan on Nevermined — fiat or crypto, fixed credits or time-based — so others can discover and buy it.

Before anyone can pay for your service, it has to exist on Nevermined: an agent (what you sell) linked to a plan (how it’s priced). An agent can do this for you in one call — the SDK builds the on-chain price and credits configuration, registers both, and returns the IDs you’ll reference everywhere else.

This is a seller task. If you only want to buy or use an agent, you don’t register one — see Buy & Call a Paid Agent.

Useful for

• Going to market: publishing a new AI agent or API and pricing access in one step.
• Choosing a pricing model — fixed credits, time-based, pay-as-you-go, or a free trial — without learning the on-chain details.
• Selling in fiat or crypto: priced in USD (Stripe / Braintree / Visa) or in USDC / EURC.

Try it yourself

You are my autonomous payments agent. Register a new AI agent and a payment plan on Nevermined sandbox using the @nevermined-io/payments SDK. Follow the Nevermined `nevermined-payments` skill (https://github.com/nevermined-io/docs/tree/main/skills/nevermined-payments) (section A6) for method signatures.

- Agent: "Weather Agent" — description "On-demand weather forecasts", endpoint POST https://my-agent.example.com/forecast
- Plan: "Weather Starter" — 100 credits for $10, paid by card (fiat, Stripe default), 1 credit per request
- My builder wallet (receives payments): <your-builder-wallet>
- Environment: sandbox (NVM_API_KEY is set — never print it)

Build the config with the SDK helpers, then call payments.agents.registerAgentAndPlan(agentMetadata, agentApi, planMetadata, priceConfig, creditsConfig):
- Price: payments.plans.getFiatPriceConfig(amount, builderAddress, 'USD'). The fiat amount is in 6-decimal units (USDC convention), NOT cents — so $10 = 10_000_000n. Arg order is (amount, receiver, currency). All helper numeric args are BigInt — use the n suffix.
- Credits: payments.plans.getFixedCreditsConfig(100n, 1n) (100 granted, 1 per request).
- agentApi = { endpoints: [{ POST: 'https://my-agent.example.com/forecast' }] }.

Print the agentId and planId, then confirm with real REST calls:
1. GET /api/v1/protocol/plans/{planId} (public) → check metadata.curation.isListed === true, registry.price.isCrypto === false (fiat), registry.credits.amount === "100", and that the SUM of registry.price.amounts equals "10000000" ($10). Note: Nevermined takes a ~2% platform fee, so the array splits into ["9800000","200000"] across two receivers — verify the sum, not index 0; index 0 (9800000) is your wallet's net.
2. GET /api/v1/protocol/agents/{agentId}/plans (public) → confirm the plan id appears in plans[] (the plan is linked to the agent).

Report both IDs and the confirmation results. (Fiat provider defaults to Stripe and is not echoed in the plan JSON, so you can only confirm "fiat" via isCrypto:false, not "Stripe" specifically.)

How it works

1. Build the price and credits config

   Pick one price helper and one credits helper — they produce the on-chain config so you don’t hand-build it:

   TypeScript

   // Price: fiat (Stripe/Braintree/Visa) — amount in 6-decimal units ($10.00)
   const priceConfig = payments.plans.getFiatPriceConfig(10_000_000n, BUILDER_ADDRESS, 'USD')
   // or crypto: getERC20PriceConfig(10_000_000n, USDC_ADDRESS, BUILDER_ADDRESS)
   
   // Credits: 100 granted, 1 burned per request
   const creditsConfig = payments.plans.getFixedCreditsConfig(100n, 1n)
   // or getExpirableDurationConfig(...) (time-based) · getPayAsYouGoCreditsConfig() (per-call)
   

   Python

   # Price: fiat — amount in 6-decimal units ($10.00)
   price_config = payments.plans.get_fiat_price_config(10_000_000, BUILDER_ADDRESS, "USD")
   # or crypto: payments.plans.get_erc20_price_config(10_000_000, USDC_ADDRESS, BUILDER_ADDRESS)
   
   # Credits: 100 granted, 1 burned per request
   credits_config = payments.plans.get_fixed_credits_config(100, 1)
   

   In TypeScript, plan config amounts are BigInt — always pass …n (e.g. 10_000_000n).

2. Register the agent and plan together

   One call publishes both and links them:

   TypeScript

   const { agentId, planId } = await payments.agents.registerAgentAndPlan(
     { name: 'Weather Agent', description: 'On-demand forecasts', tags: ['weather'], dateCreated: new Date() },
     { endpoints: [{ POST: 'https://my-agent.example.com/forecast' }] },
     { name: 'Weather Starter', description: '100 requests for $10', dateCreated: new Date() },
     priceConfig,
     creditsConfig,
   )
   console.log({ agentId, planId })
   

   Python

   result = payments.agents.register_agent_and_plan(
       agent_metadata={'name': 'Weather Agent', 'description': 'On-demand forecasts', 'tags': ['weather']},
       agent_api={'endpoints': [{'POST': 'https://my-agent.example.com/forecast'}]},
       plan_metadata={'name': 'Weather Starter', 'description': '100 requests for $10'},
       price_config=price_config,
       credits_config=credits_config,
   )
   print(result['agentId'], result['planId'])
   

   The endpoints are optional — omit them for an open agent, or include them so the platform enforces route-level access on top of your own middleware.

3. Confirm it's published

   List what you’ve published to verify the agent and plan are live:

   GET {API_BASE}/protocol/agents
   Authorization: Bearer <api-key>
   

   Each item is the full record — read the name from metadata.main.name and the id from id. Then point buyers at your organization’s agentic-instructions.md, where published plans and agents appear automatically.

Prefer no code? You can register and price everything in the web app — see Register Agents.

Related

Add payments to your agent

Gate the registered agent’s endpoints behind the plan.

Register Agents (App)

The no-code path to publishing agents and plans.

Check revenue

Track sales once buyers start arriving.

Order Plans

How buyers purchase the plan you just created.