What makes Nevermined Payments notable?

1.3K downloads. Trust evidence available

How should Nevermined Payments be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Nevermined Payments

Use when an AI agent must operate on Nevermined autonomously — purchase a payment plan via the x402 protocol (crypto or card), enroll a card and create a spending delegation, obtain a Nevermined API key, register a payment plan or AI agent, or check its credits (as a buyer) or revenue (as a seller) — and when adding x402 payment protection to a TypeScript or Python agent (Express, FastAPI, MCP, Google A2A, Strands, LangChain / LangGraph). Covers the @nevermined-io/payments and payments-py SDKs and the Nevermined REST API.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.3k

Updated

Oct 10, 2026

Version

1.0.10

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.3K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.3K downloadsadoption · observed Oct 10, 2026
Latest release: 1.0.10release · observed Sep 25, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17beb0b7q3geaakdyrsav6nq188t5nd:nevermined

Install using `clawhub skill install s17beb0b7q3geaakdyrsav6nq188t5nd:nevermined` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/nevermined-io/nevermined before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-nevermined-io-nevermined/snapshot"

Documentation

CLAWHUB

150,815 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: nevermined-payments
version: "0.5.2"
lastUpdated: "2026-09-25"
description: >
  Use when an AI agent must operate on Nevermined autonomously — purchase a payment
  plan via the x402 protocol (crypto or card), enroll a card and create a spending
  delegation, obtain a Nevermined API key, register a payment plan or AI agent, or
  check its credits (as a buyer) or revenue (as a seller) — and when adding x402
  payment protection to a TypeScript or Python agent (Express, FastAPI, MCP, Google
  A2A, Strands, LangChain / LangGraph). Covers the @nevermined-io/payments and payments-py SDKs and the
  Nevermined REST API.
metadata:
  openclaw:
    primaryEnv: NVM_API_KEY
    requires:
      env:
        - NVM_API_KEY
    envVars:
      - name: NVM_API_KEY
        required: true
        description: >
          Nevermined API key used by the SDK, REST API, and CLI. Format
          `sandbox:...` for the sandbox environment, `live:...` for production.
          Issued from https://nevermined.app under API Keys.
---

# Nevermined Payments Integration

> **Skill version**: 0.5.2 | **Last updated**: 2026-09-25 | **Canonical source (always latest):** https://github.com/nevermined-io/docs/tree/main/skills/nevermined-payments
>
> **Use the latest version.** This skill changes often. If you have an installed or cached copy, compare its **Last updated** date with the canonical source above and refresh it if older — an out-of-date copy can be missing whole flows. Unless a specific version is requested, work from the latest.
>
> Verified against the live sandbox API (`https://api.sandbox.nevermined.app/api/v1/rest/docs-json`); the cited SDK calls were checked against `@nevermined-io/[email protected]` and `[email protected]` — install the latest release of each.

## Overview

Nevermined provides financial rails for AI agents — real-time monetization, access control, and payments. This skill covers **two modes**, and most tasks fall cleanly into one:

| Mode | You are… | Lead interface | Use when the goal is… |
|---|---|---|---|
| **🅐 Operate as an autonomous agent** | an agent **acting on its own behalf** at runtime | **REST** (works with no SDK install) | buy a plan, enroll a card + delegation, get an API key, register a plan/agent, check credits (buyer) or revenue (seller) |
| **🅑 Add payments to your code** | a developer **wiring payments into an agent** so it can **receive** payments | **SDK** (TypeScript / Python) | protect Express/FastAPI/MCP/A2A/Strands endpoints behind a plan |

If you are an autonomous agent that needs to **pay, enroll, register, or report**, start at **Track A — Operate as an autonomous agent**. If you are building a service that needs to **charge** callers, jump to **Track B — Add payments to your code**.

### How payments work (x402 in one minute)

Nevermined uses the **x402 protocol** (HTTP `402 Payment Required`). A buyer acquires an **access token** authorizing a spend, then **settles** it — which charges the payment method,

_meta.json

{
  "ownerId": "kn7bk8z6x7ytxvdb48j34j2ahh812m3p",
  "slug": "nevermined",
  "version": "1.0.10",
  "publishedAt": 1790357689120
}

references/a2a-integration.md

# Google A2A Integration

Integrate Nevermined payments with [Google A2A (Agent-to-Agent)](https://a2a-protocol.org/) to enable multi-agent systems to authorize and charge per request between agents.

> 🔐 **Trust & transport.** A2A flows ship payment tokens (`payment-signature`) between agents — they are bearer credentials. Always: (1) serve agents over HTTPS, (2) validate the peer Agent Card and base URL before sending tokens, (3) restrict CORS to known agent origins, (4) issue short-lived, narrowly scoped **delegations** (`createDelegation` with tight `spendingLimitCents` + `durationSecs`), then request tokens by their `delegationId`, and (5) treat push-notification webhook URLs as untrusted until verified.

## Features

- **Agent Card with payment extension**: served at `/.well-known/agent-card.json` (legacy alias `/.well-known/agent.json`)
- **In-band payment (x402 v2 A2A transport)**: the client carries the x402 payload in the JSON-RPC message metadata; the `payment-signature` HTTP header is still accepted as a deprecated fallback
- **Credits Validation**: verify sufficient credits before executing a task
- **Credits Burning/Redemption**: burn credits specified in `metadata.creditsUsed` after execution
- **Streaming**: supports `message/stream` and `tasks/resubscribe`
- **Push Notifications**: standard A2A push notification flow
- **Async Task Handling**: intermediate and final state events, compatible with polling and streaming

## Installation

### TypeScript

```bash
npm install @nevermined-io/payments
```

### Python

```bash
pip install payments-py
```

## A2A Server

### Build the Payment Agent Card

Add a Nevermined payment extension to your A2A agent card to advertise that your agent charges for requests.

#### TypeScript

```typescript
import { Payments } from "@nevermined-io/payments"

const payments = Payments.getInstance({
  nvmApiKey: process.env.NVM_API_KEY!,
  environment: 'sandbox',
})

const baseAgentCard = {
  name: 'My A2A Server',
  description: 'A2A agent that requires payment',
  capabilities: {
    streaming: true,
    pushNotifications: true,
    stateTransitionHistory: true,
  },
  defaultInputModes: ['text'],
  defaultOutputModes: ['text'],
  skills: [],
  url: 'http://localhost:3005/a2a/',
  version: '1.0.0',
}

// buildPaymentAgentCard is static on the Payments class (not on the `payments` instance)
const agentCard = Payments.a2a.buildPaymentAgentCard(baseAgentCard, {
  paymentType: "dynamic",
  credits: 1,
  planId: process.env.NVM_PLAN_ID!,
  agentId: process.env.NVM_AGENT_ID!,
})
```

#### Python

```python
from payments_py import Payments, PaymentOptions
from payments_py.a2a.agent_card import build_payment_agent_card

payments = Payments.get_instance(
    PaymentOptions(nvm_api_key=os.environ["NVM_API_KEY"], environment="sandbox")
)

base_agent_card = {
    "name": "My A2A Agent",
    "description": "A2A agent that requires payment",
    "capabilities": {
        "streaming": True,
        "pushNotifications"

references/autonomous-operations.md

# Autonomous Agent Operations (REST runbook)

How an AI agent operates on Nevermined **on its own behalf** using the REST API — get an API key, enroll a card, create a delegation, purchase plans via x402, and check status. Every call here is plain HTTPS; no SDK install is required. This is the heavy-detail companion to **Track A** in `SKILL.md`.

> All bodies and response shapes below are verified against the live sandbox OpenAPI (`https://api.sandbox.nevermined.app/api/v1/rest/docs-json`). Send `Authorization: Bearer $NVM_API_KEY` on every call unless noted.
>
> Also send `Nevermined-Version: <MAJOR.MINOR>` on every call to pin the wire shape across platform releases — discover the supported range with `GET /api/v1/meta/versions` and default to its `current`. Never silently change a key's stored pin.

## Environments

| Environment | API base URL | App | Card enrollment UI | Crypto network | Key prefix |
|---|---|---|---|---|---|
| `sandbox` | `https://api.sandbox.nevermined.app` | `https://nevermined.app` | `https://embed.nevermined.app` | `eip155:84532` (Base Sepolia) | `sandbox:` |
| `live` | `https://api.live.nevermined.app` | `https://nevermined.app` | `https://embed.nevermined.app` | `eip155:8453` (Base Mainnet) | `live:` |

Only `sandbox` and `live` are public. Use the exact base URL — never infer it.

## What needs a human (once) vs. fully programmatic

| Step | Human? |
|---|---|
| Get the first API key | **Yes, once** (browser sign-in) |
| Enroll a card | **Yes, once** (browser; skip entirely for stablecoins) |
| Check payment methods, create delegation, get token, settle, register, status, revenue | No — fully programmatic |

---

## 1. Get a Nevermined API key

You cannot mint the first key yourself.

**Option A — embedded login (key returns automatically).** Host an HTTP server on `127.0.0.1:<port>` with a `/callback` route, then have your human open:

```
https://nevermined.app/auth/cli?callback_url=http://127.0.0.1:<port>/callback
```

After sign-in the browser hits `http://127.0.0.1:<port>/callback?nvm_api_key=<api-key>`. Read `nvm_api_key`, store it, reuse it.

**Option B — manual paste.** Human signs in at [nevermined.app](https://nevermined.app) → Settings → Global NVM API Keys → **+ New API Key**, and pastes it back. Or opens `https://nevermined.app/auth/cli` (no `callback_url`) to read the key on screen.

A `sandbox` key starts with `sandbox`; a `live` key with `live`.

---

## 2. Check your payment methods

```bash
curl -s -H "Authorization: Bearer $NVM_API_KEY" \
  https://api.sandbox.nevermined.app/api/v1/payment-methods
```

Response — array of payment methods:

```json
[
  {
    "id": "pm_1Q...",
    "type": "card",
    "brand": "visa",
    "last4": "4242",
    "expMonth": 12,
    "expYear": 2030,
    "alias": "My Card",
    "provider": "stripe",
    "status": "Active",
    "allowedApiKeyIds": null
  }
]
```

A **stablecoin** method exists by default (fund it to pay immediately). A **card** method only appears after the

references/client-integration.md

# Client-Side Integration (Subscriber Flow)

How to purchase plans, generate x402 tokens, and call payment-protected APIs as a subscriber.

> ⚠️ **Run examples in `sandbox` first.** `orderPlan` charges money in `live`, and `delegationConfig` grants the platform pre-authorized spending up to `spendingLimitCents` for `durationSecs` seconds. Examples below use a small sandbox-friendly budget (`100¢` over `1h`); raise per use-case after explicit review.

## Overview

As a subscriber (consumer of a paid API/agent), you:
1. Order a payment plan
2. Check your credit balance
3. Generate an x402 access token
4. Send requests with the `payment-signature` header
5. Decode the settlement receipt from the `payment-response` header

## Pure-REST purchase (no SDK)

An autonomous agent can complete the whole subscriber flow with plain HTTP — no SDK install. Send `Authorization: Bearer $NVM_API_KEY` on each call.

```bash
# 1. Get an x402 access token (create the delegation first via /delegation/create, then pass its delegationId)
curl -s -X POST -H "Authorization: Bearer $NVM_API_KEY" -H "Content-Type: application/json" \
  -d '{ "accepted": { "scheme": "nvm:erc4337", "network": "eip155:84532", "planId": "<PLAN_ID>" },
        "delegationConfig": { "delegationId": "<DELEGATION_ID>" } }' \
  https://api.sandbox.nevermined.app/api/v1/x402/permissions
# → { "accessToken": "..." }

# 2. Settle (proof of purchase). For a plan top-up, resource.url is the plan URL.
curl -s -X POST -H "Authorization: Bearer $NVM_API_KEY" -H "Content-Type: application/json" \
  -d '{ "paymentRequired": { "x402Version": 2, "resource": { "url": "<PLAN_OR_RESOURCE_URL>" },
          "accepts": [ { "scheme": "nvm:erc4337", "network": "eip155:84532", "planId": "<PLAN_ID>", "extra": {} } ],
          "extensions": {} },
        "x402AccessToken": "<accessToken>" }' \
  https://api.sandbox.nevermined.app/api/v1/x402/settle
# → { "success": true, "billingModel": "credits", "creditsRedeemed": "1", "remainingBalance": "999", "transaction": "0x..." }
```

- **Card payment:** switch `scheme` to `nvm:card-delegation` and `network` to `stripe` (or `braintree`/`visa`) in both calls.
- **Calling a protected agent directly:** skip building `paymentRequired` — send the access token as the `payment-signature` header; the agent settles for you and returns the receipt in the `payment-response` header.
- **Proof of purchase — read `billingModel` first.** On a `credits` plan it is `success: true` and `creditsRedeemed > 0`. On a `pay-as-you-go` plan there is no credit balance, so `creditsRedeemed` and `remainingBalance` are always the string `"0"` even on a successful charge; the proof is `success: true` plus a non-empty `orderTx` (fiat) or `transaction` (crypto). Never gate on `creditsRedeemed` alone — on a card rail it reports a real charge as a decline and invites a retry. If `billingModel` is missing entirely the deployment predates it: apply the `credits` rule.

Full runbook with API-key retrieval, card en

Github ReposUpdated 1d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.