Nevermined Delegation API

The Delegation API from Nevermined — 4 operation(s) for delegation.

GitHub OpenAPI

Operations 5

POST /api/v1/delegation/create Create a spending delegation and return a signed JWT token #
GET /api/v1/delegation List all delegations for the authenticated user #
GET /api/v1/delegation/{delegationId} Get delegation details including remaining budget #
DELETE /api/v1/delegation/{delegationId} Revoke a delegation #
GET /api/v1/delegation/{delegationId}/transactions List transactions for a delegation #

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API
curl "https://apis.io/api/v1/apis/nevermined-app:nevermined-app-delegation-api"
All apis
curl "https://apis.io/api/v1/apis?limit=25"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. By signing up you are subscribing to the APIs.io and API Evangelist newsletters — you can unsubscribe from any issue. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

nevermined-app-delegation-api-openapi.yml Raw ↑
openapi: 3.2.0
info:
  title: NVM BACKEND Delegation API
  description: ''
  version: 1.103.0
  contact: {}
servers:
- url: https://api.live.nevermined.app
tags:
- name: Delegation
paths:
  /api/v1/delegation/create:
    post:
      description: Creates a spending delegation for the authenticated user against a previously enrolled payment method. For fiat-backed delegations (stripe/visa/vgs) the response includes a signed JWT (`delegationToken`); for crypto (erc4337) flows the token is held client-side and omitted. Requires a Nevermined API key.
      operationId: DelegationController_createDelegation
      parameters: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateDelegationDto'
      responses:
        '201':
          description: The created delegation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateDelegationResponseDto'
        '401':
          description: Unauthorized
      security:
      - Authorization: []
      summary: Create a spending delegation and return a signed JWT token
      tags:
      - Delegation
  /api/v1/delegation:
    get:
      description: Returns a paginated list of the authenticated user's spending delegations. Use `accessible=true` to return only delegations the requesting API key may spend against. Requires a Nevermined API key.
      operationId: DelegationController_listDelegations
      parameters:
      - name: page
        required: false
        in: query
        description: Page number (1-based). Defaults to 1.
        schema:
          type: integer
          default: 1
          example: 1
      - name: offset
        required: false
        in: query
        description: Number of items per page. Defaults to 10.
        schema:
          type: integer
          default: 10
          example: 10
      - name: accessible
        required: false
        in: query
        description: When "true", return only delegations accessible to the requesting API key (filters by apiKeyId, Active status, expiry, and remaining budget)
        schema:
          type: string
          enum:
          - 'true'
          - 'false'
          example: 'true'
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DelegationListDto'
      security:
      - Authorization: []
      summary: List all delegations for the authenticated user
      tags:
      - Delegation
  /api/v1/delegation/{delegationId}:
    get:
      description: Returns the full details of a single delegation owned by the authenticated user, including remaining budget and last-used timestamp. Requires a Nevermined API key.
      operationId: DelegationController_getDelegation
      parameters:
      - name: delegationId
        required: true
        in: path
        description: UUID v4 of the delegation to fetch.
        schema:
          type: string
          format: uuid
          example: a1b2c3d4-e5f6-4a90-8bcd-ef1234567890
      - name: withPayer
        required: false
        in: query
        description: When "true", also resolve `fundingWalletAddress` — the wallet the Router crypto rail spends from (EOA / 7702 kernel, or the org wallet) — and `lockedInChannels`, what that wallet has locked in MPP payment channels, and `spendable`, what the delegation can actually spend now on each network. Opt-in because it adds a wallet lookup, a channel read and balance reads.
        schema:
          type: string
          enum:
          - 'true'
          - 'false'
          example: 'true'
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DelegationDetailsDto'
        '404':
          description: Delegation not found
      security:
      - Authorization: []
      summary: Get delegation details including remaining budget
      tags:
      - Delegation
    delete:
      description: Revokes a delegation owned by the authenticated user and cascade-revokes its linked permissions. For Visa delegations the linked VGS intent is cancelled best-effort. Requires a Nevermined API key.
      operationId: DelegationController_revokeDelegation
      parameters:
      - name: delegationId
        required: true
        in: path
        description: UUID v4 of the delegation to revoke.
        schema:
          type: string
          format: uuid
          example: a1b2c3d4-e5f6-4a90-8bcd-ef1234567890
      responses:
        '200':
          description: 'The revoke result (`{ success: true }`)'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NvmAPIResultDto'
        '404':
          description: Delegation not found
      security:
      - Authorization: []
      summary: Revoke a delegation
      tags:
      - Delegation
  /api/v1/delegation/{delegationId}/transactions:
    get:
      description: Returns a paginated list of charge transactions recorded against a delegation owned by the authenticated user. Requires a Nevermined API key.
      operationId: DelegationController_getTransactions
      parameters:
      - name: delegationId
        required: true
        in: path
        description: UUID v4 of the delegation whose transactions are listed.
        schema:
          type: string
          format: uuid
          example: a1b2c3d4-e5f6-4a90-8bcd-ef1234567890
      - name: page
        required: false
        in: query
        description: Page number (1-based). Defaults to 1.
        schema:
          type: integer
          default: 1
          example: 1
      - name: offset
        required: false
        in: query
        description: Number of items per page. Defaults to 10.
        schema:
          type: integer
          default: 10
          example: 10
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DelegationTransactionListDto'
        '404':
          description: Delegation not found
      security:
      - Authorization: []
      summary: List transactions for a delegation
      tags:
      - Delegation
components:
  schemas:
    NvmAPIResultDto:
      type: object
      properties:
        success:
          type: boolean
          example: true
          description: Indicates whether the API call was successful
        message:
          type: string
          example: Successfully minted
          description: Message describing the result of the API call
        txHash:
          type: string
          example: '0x923812b3c4d5e6f7890abcdef1234567890abcdef1234567890abcdef12345678'
          description: Blockchain transaction hash associated with the API call
        httpStatus:
          type: number
          example: 200
          description: HTTP status code of the API response
        data:
          type: object
          description: Additional parameters related to the API call
          additionalProperties: true
        when:
          format: date-time
          type: string
          description: Timestamp when the API call was made
      required:
      - success
      - message
      - txHash
      - httpStatus
      - data
      - when
    DelegationTransactionListDto:
      type: object
      properties:
        totalResults:
          type: number
        page:
          type: number
        offset:
          type: number
        transactions:
          type: array
          items:
            $ref: '#/components/schemas/DelegationTransactionDto'
      required:
      - totalResults
      - page
      - offset
      - transactions
    CreateDelegationResponseDto:
      type: object
      properties:
        delegationId:
          type: string
          example: a1b2c3d4-e5f6-4a90-8bcd-ef1234567890
        delegationToken:
          type:
          - string
          - 'null'
          example: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZWxlZ2F0aW9uIn0.c2lnbmF0dXJl
          description: Signed JWT for fiat-backed delegations (stripe/visa/vgs). Omitted for crypto (erc4337) flows where the signed delegation is held client-side.
      required:
      - delegationId
    DelegationDetailsDto:
      type: object
      properties:
        allowSessionPayments:
          type: boolean
          description: 'erc4337 only: whether this delegation may pay services that sell over an MPP `session`, which lock a refundable deposit from the wallet at the first call. Set at creation.'
        agentId:
          type:
          - string
          - 'null'
          description: Buyer-supplied agent identifier; attribution only.
        label:
          type:
          - string
          - 'null'
          description: Buyer-chosen agent name.
        delegationId:
          type: string
          example: a1b2c3d4-e5f6-4a90-8bcd-ef1234567890
        provider:
          type: string
          example: stripe
          enum:
          - stripe
          - braintree
          - erc4337
          - visa
          - vgs
        providerPaymentMethodId:
          type: string
          example: pm_1Abc2Def3Ghi4Jkl
        status:
          type: string
          example: Active
          enum:
          - Active
          - Revoked
          - Expired
          - Exhausted
        spendingLimitCents:
          type: string
          example: '10000'
        amountSpentCents:
          type: string
          example: '2500'
          description: What the delegation has spent, rounded UP to a whole cent. The cap accrues at sub-cent resolution — `amountSpentMicros` is the exact figure — so this is within one cent of it, and `amountSpentCents + remainingBudgetCents` equals `spendingLimitCents` while the delegation is within its cap.
        amountSpentMicros:
          type: string
          example: '24995000'
          description: What the delegation has spent, in micros — millionths of the currency unit, i.e. 1/10,000 of a cent. The figure the spending cap is enforced on.
        remainingBudgetCents:
          type: string
          example: '7500'
          description: 'Whole cents left under the cap: `spendingLimitCents - amountSpentCents`, never negative.'
        remainingBudgetMicros:
          type: string
          example: '75005000'
          description: Micros left under the cap, never negative. A delegation with any micros left can still take a payment that fits in them, even when `remainingBudgetCents` reads 0.
        currency:
          type: string
          example: usd
        transactionCount:
          type: number
          example: 12
        maxTransactions:
          type:
          - number
          - 'null'
          example: 50
          description: Maximum number of payments this delegation may make, or null for no count limit.
        expiresAt:
          format: date-time
          type: string
          example: '2026-02-20T00:00:00Z'
        createdAt:
          format: date-time
          type: string
          example: '2026-02-13T10:30:00Z'
        apiKeyId:
          type:
          - string
          - 'null'
          example: sk-abc123
          description: 'Legacy key-id pin: the NVM API Key ID this delegation is restricted to. Null does NOT necessarily mean "any key" — check `bindingId`: a delegation pinned to an AgentBinding has `apiKeyId: null` but is still restricted. Null on BOTH = any of the owner''s keys may use it.'
        bindingId:
          type:
          - string
          - 'null'
          example: ab-abc123
          description: AgentBinding this delegation is pinned to — stable across credential refresh, unlike `apiKeyId`. When set, only credentials minted from this binding may use it (and `apiKeyId` is null). Null = not binding-pinned.
        planId:
          type:
          - string
          - 'null'
          example: '123456789'
          description: 'Plan this delegation is restricted to, or null for a plan-agnostic one that can pay any plan. Applies to every provider, `visa` included: a Visa delegation created without a plan is null here, while one created with a plan keeps it and can only settle that plan.'
        lastUsedAt:
          type:
          - string
          - 'null'
          example: '2026-02-13T14:00:00Z'
          format: date-time
        fundingWalletAddress:
          type:
          - string
          - 'null'
          example: '0x1234abcd5678ef901234abcd5678ef901234abcd'
          description: 'On-chain wallet the Router crypto rail spends from for this delegation — the caller EOA (7702 kernel address for migrated wallets) for a personal delegation, or the organization wallet for an org-wallet delegation. Fund/check THIS wallet before a Router call. For a personal delegation the Router does NOT spend from `providerPaymentMethodId` (the smart-account address) — it spends from the EOA; for an org-wallet delegation `providerPaymentMethodId` IS this wallet. (On the default wallet mode the same delegation used for a plan-purchase settles from the smart account instead — this field is the Router payer specifically.) Only returned when requested with `?withPayer=true`. `null` on card-backed delegations (a card is not funded from a wallet — tell them apart by `provider`: `erc4337` is the crypto rail); `null` on a crypto delegation means the payer wallet could not be resolved — either the owner profile has no wallet (permanent) or the lookup failed transiently.'
        lockedInChannels:
          description: 'Money `fundingWalletAddress` has deposited into MPP session payment channels and can still get back, per chain and token. It has left the wallet but it is not spent and it is not charged to this budget: it comes back to the wallet when the channel closes. It is the FUNDING WALLET’s total, not a per-delegation figure: every delegation spending from the same wallet reports the same channels. Only returned when requested with `?withPayer=true`. An empty list means nothing is locked, and is what a card-backed delegation reports. `null` means it could not be determined (the funding wallet could not be resolved, or the read failed), which is not the same as nothing locked.'
          type:
          - array
          - 'null'
          items:
            $ref: '#/components/schemas/LockedChannelFundsDto'
        spendable:
          description: 'An upper bound on what this delegation can spend now: `remainingBudgetMicros` is only a ceiling, and a crypto delegation can spend no more than its funding wallet holds. One entry per network the Router is configured to pay the token of the budget’s currency on, each the lesser of the remaining budget and the wallet’s balance of that token there, and for an organization wallet what the spending member’s group budget has left; a call settles on the network the merchant quotes, so only that network’s entry applies to it. It is a bound, not a promise: it does not subtract payments authorized but not settled yet, routing fees owed but not collected yet, or gas. It applies to a payment in the budget’s token: a personal crypto delegation can also pay a merchant in another stablecoin the Router funds, from that token’s balance, which can be higher or lower. A card-backed delegation has one entry with `network: null` equal to the remaining budget. Zero on every entry when the delegation is not Active. Only returned when requested with `?withPayer=true`. An empty list means the Router pays the budget’s token on no network this deployment serves. `null` means it could not be determined: the funding wallet could not be resolved, the budget’s currency maps to no token, or the delegation’s payment rail is one this read has no rule for.'
          type:
          - array
          - 'null'
          items:
            $ref: '#/components/schemas/DelegationSpendableDto'
      required:
      - delegationId
      - provider
      - providerPaymentMethodId
      - status
      - spendingLimitCents
      - amountSpentCents
      - amountSpentMicros
      - remainingBudgetCents
      - remainingBudgetMicros
      - currency
      - transactionCount
      - maxTransactions
      - expiresAt
      - createdAt
      - lastUsedAt
    CreateDelegationDto:
      type: object
      properties:
        agentId:
          type: string
          description: Buyer-supplied agent identifier for attribution only; does not grant access or change credential restrictions.
        label:
          type: string
          description: Buyer-chosen agent name shown in delegations and payment history.
        provider:
          type: string
          description: Payment rail for this delegation. `stripe`, `visa`, and `erc4337` select that rail directly. `vgs` is a portable, plan-agnostic card delegation whose settlement processor (Stripe or Braintree) is chosen when a payment is made, based on the plan being paid — so one enrolled card can pay across processors. `vgs` requires a portable `providerPaymentMethodId` (the `CRD…` `cardId`, which must carry an active network token); for `vgs`, `planId` is optional and only restricts the delegation to a single plan.
          example: stripe
          enum:
          - stripe
          - erc4337
          - visa
          - vgs
        providerPaymentMethodId:
          type: string
          description: Payment-method identifier from the provider. For stripe this is the saved card; for vgs this is the `CRD…` canonical cardId from the unified VGS-Collect enroll; for visa this is the card’s `CRD…` cardId (the card must list `visa` in its `rails` on GET /payment-methods) or the VGS agentic-token id returned by enrollment. A visa delegation created from the `CRD…` is stored under the card’s agentic token, so delegation reads return that token id as its `providerPaymentMethodId`, not the `CRD…` sent; the visa entry of GET /payment-methods whose `id` is that token carries the card’s `cardId`. Required for these providers; ignored for erc4337.
          example: pm_1Abc2Def3Ghi4Jkl
        consumerPrompt:
          type: string
          description: 'Visa-only: human-readable approval prompt shown to the user during VGS Agentic Auth device binding. Required when provider=visa.'
          example: Allow up to USD 50.00 over 5 transactions
        assuranceData:
          type: object
          description: 'Visa-only: opaque assurance payload from the VGS Agentic Auth browser SDK after FIDO/OTP device binding. Required when provider=visa.'
        spendingLimitCents:
          type: number
          description: Maximum spending limit in cents (smallest currency unit)
          example: 10000
        durationSecs:
          type: number
          description: Duration of the delegation in seconds
          example: 604800
        currency:
          type: string
          description: Currency code (lowercase). A card delegation charges in this currency and nothing converts it, so it can only pay plans priced in the same currency; a card delegation created with `planId` set in another currency than that plan is refused (`BCK.DELEGATION.0011`).
          example: usd
          enum:
          - usd
          - eur
          - usdc
          - eurc
        planId:
          type: string
          description: Restrict this delegation to a single plan. Optional and plan-agnostic by default for every provider, including `vgs` and `visa` card delegations (whose merchant is resolved at payment time from the plan being paid).
          example: '123456789'
        maxTransactions:
          type: number
          description: Maximum number of transactions allowed (null = unlimited)
          example: 50
        apiKeyId:
          type: string
          description: Optional API Key ID (skId) to restrict this delegation to
          example: sk-abc123
        allowedRecipients:
          description: 'erc4337 / Router only: restrict spend to these pay-to addresses — the Router rejects payments to any other recipient. Omit for no recipient restriction.'
          example:
          - '0x209693Bc6afc0C5328bA36FaF03C514EF312287C'
          type: array
          items:
            type: string
        allowSessionPayments:
          type: boolean
          description: 'erc4337 / Router only: whether this delegation may pay services that sell over an MPP `session`, which lock a refundable deposit from the wallet at the first call. Defaults to true. Set false to refuse them: a service that also offers a per-call charge over Tempo is paid that way regardless, and a call that has nothing else to pay is refused (409 BCK.ROUTER.0047). A delegation cannot be edited, so this is fixed at creation.'
          example: false
        organizationWalletId:
          type: string
          description: 'erc4337 / Router only: fund this delegation from an organization wallet instead of the caller''s own wallet. The caller must be an admin of the wallet''s organization, and spending is always capped by the member''s group budget (the wallet must be shared with that group).'
          example: orw-abc123
      required:
      - provider
      - spendingLimitCents
      - durationSecs
      - currency
    DelegationTransactionDto:
      type: object
      properties:
        agentId:
          type:
          - string
          - 'null'
          description: Buyer-chosen agent identifier from this transaction’s immutable delegation.
        agentLabel:
          type:
          - string
          - 'null'
          description: Buyer-chosen name from this transaction’s immutable delegation.
        id:
          type: string
          example: tx-uuid
        delegationId:
          type: string
          example: delegation-uuid
        providerTransactionId:
          type: string
          example: pi_1Abc2Def3Ghi4Jkl
        amountCents:
          type: string
          example: '1000'
        currency:
          type: string
          example: usd
        status:
          type: string
          example: succeeded
        failureReason:
          type:
          - string
          - 'null'
          example: null
        feeCents:
          type: string
          description: Nevermined’s routing fee for this charge, in cents, already INCLUDED in `amountCents`. Charged only on payments routed to an external merchant via the Router — `"0"` on every other row (a plan purchase on the card rails, or a crypto settlement), where no routing fee applies. On a Router row `amountCents - feeCents` is the merchant leg — **unless `feeReleased` is `true`, in which case `amountCents` is ALREADY net of the fee and must not be reduced again**. On other rows the identity does not hold either, because a plan purchase can carry a platform margin taken out of the price that this figure does not describe. **`"0"` does not by itself mean no fee applied:** the two figures round in opposite directions, so a fee too small to add a cent to the reserve still shows here as `"0"`. Read `feeAtomic` to answer that.
          example: '0'
        feeAtomic:
          type: string
          description: The same fee in the settlement asset’s smallest unit, rounded down. This is the field that answers “did a routing fee apply at all” — `"0"` means none did. The asset it is denominated in is the one the Router settled, reported on `GET /router/payments`; it is NOT the same unit as `amountCents`.
          example: '0'
        feeBps:
          type: number
          description: The fee rate applied, in basis points over a 10,000 denominator. Pinned per row, so a later rate change never rewrites what an old payment was charged. `0` when no fee applied.
          example: 0
        feeReleased:
          type: boolean
          description: 'True when the routing fee was not collected and has been credited back to your cap. Non-delivery by the merchant is one cause; a fee leg that was refused, or expired before it could be broadcast, is another — so this does NOT mean the merchant failed you. **`amountCents` has ALREADY been reduced by `feeCents` when this is true**, so do not subtract the fee a second time. It does not follow that the remainder is the merchant leg: a payment whose merchant reserve was also released has that deducted from the same field and reads `status: ''failed''`. A fee too small to reserve a cent is released without ever setting this flag, so a row may read `false` here while `GET /router/payments` reports the fee `Released`; `amountCents` is untouched in that case, so the arithmetic above still holds.'
          example: false
        createdAt:
          format: date-time
          type: string
          example: '2026-02-13T14:00:00Z'
      required:
      - id
      - delegationId
      - providerTransactionId
      - amountCents
      - currency
      - status
      - failureReason
      - feeCents
      - feeAtomic
      - feeBps
      - feeReleased
      - createdAt
    DelegationSummaryDto:
      type: object
      properties:
        allowSessionPayments:
          type: boolean
          description: 'erc4337 only: whether this delegation may pay services that sell over an MPP `session`, which lock a refundable deposit from the wallet at the first call. Set at creation.'
        agentId:
          type:
          - string
          - 'null'
          description: Buyer-supplied agent identifier; attribution only.
        label:
          type:
          - string
          - 'null'
          description: Buyer-chosen agent name.
        delegationId:
          type: string
          example: a1b2c3d4-e5f6-4a90-8bcd-ef1234567890
        provider:
          type: string
          example: stripe
          enum:
          - stripe
          - braintree
          - erc4337
          - visa
          - vgs
        providerPaymentMethodId:
          type: string
          example: pm_1Abc2Def3Ghi4Jkl
        status:
          type: string
          example: Active
          enum:
          - Active
          - Revoked
          - Expired
          - Exhausted
        spendingLimitCents:
          type: string
          example: '10000'
        amountSpentCents:
          type: string
          example: '2500'
          description: What the delegation has spent, rounded UP to a whole cent. The cap accrues at sub-cent resolution — `amountSpentMicros` is the exact figure — so this is within one cent of it, and `amountSpentCents + remainingBudgetCents` equals `spendingLimitCents` while the delegation is within its cap.
        amountSpentMicros:
          type: string
          example: '24995000'
          description: What the delegation has spent, in micros — millionths of the currency unit, i.e. 1/10,000 of a cent. The figure the spending cap is enforced on.
        remainingBudgetCents:
          type: string
          example: '7500'
          description: 'Whole cents left under the cap: `spendingLimitCents - amountSpentCents`, never negative.'
        remainingBudgetMicros:
          type: string
          example: '75005000'
          description: Micros left under the cap, never negative. A delegation with any micros left can still take a payment that fits in them, even when `remainingBudgetCents` reads 0.
        currency:
          type: string
          example: usd
        transactionCount:
          type: number
          example: 12
        maxTransactions:
          type:
          - number
          - 'null'
          example: 50
          description: Maximum number of payments this delegation may make, or null for no count limit.
        expiresAt:
          format: date-time
          type: string
          example: '2026-02-20T00:00:00Z'
        createdAt:
          format: date-time
          type: string
          example: '2026-02-13T10:30:00Z'
        apiKeyId:
          type:
          - string
          - 'null'
          example: sk-abc123
          description: 'Legacy key-id pin: the NVM API Key ID this delegation is restricted to. Null does NOT necessarily mean "any key" — check `bindingId`: a delegation pinned to an AgentBinding has `apiKeyId: null` but is still restricted. Null on BOTH = any of the owner''s keys may use it.'
        bindingId:
          type:
          - string
          - 'null'
          example: ab-abc123
          description: AgentBinding this delegation is pinned to — stable across credential refresh, unlike `apiKeyId`. When set, only credentials minted from this binding may use it (and `apiKeyId` is null). Null = not binding-pinned.
        planId:
          type:
          - string
          - 'null'
          example: '123456789'
          description: 'Plan this delegation is restricted to, or null for a plan-agnostic one that can pay any plan. Applies to every provider, `visa` included: a Visa delegation created without a plan is null here, while one created with a plan keeps it and can only settle that plan.'
      required:
      - delegationId
      - provider
      - providerPaymentMethodId
      - status
      - spendingLimitCents
      - amountSpentCents
      - amountSpentMicros
      - remainingBudgetCents
      - remainingBudgetMicros
      - currency
      - transactionCount
      - maxTransactions
      - expiresAt
      - createdAt
    DelegationListDto:
      type: object
      properties:
        totalResults:
          type: number
        page:
          type: number
        offset:
          type: number
        delegations:
          type: array
          items:
            $ref: '#/components/schemas/DelegationSummaryDto'
      required:
      - totalResults
      - page
      - offset
      - delegations
    LockedChannelFundsDto:
      type: object
      properties:
        network:
          type: integer
          example: 4217
          description: Chain id the payment channels are on
        token:
          type: string
          example: '0x20C000000000000000000000b9537d11c60E8b50'
          description: The token the channels hold in escrow, EIP-55 checksummed
        symbol:
          type:
          - string
          - 'null'
          example: USDC.e
          description: Ticker, or null when the token is not one Nevermined recognises
        decimals:
          type:
          - integer
          - 'null'
          example: 6
          description: Decimal scale of `atomic`, or null when unknown
        atomic:
          type: string
          example: '6000000'
          pattern: ^(0|[1-9][0-9]*)$
          description: 'Atomic (integer) amount locked, as a string: over every payment channel on this chain and token that is not closed yet, the deposit minus the payments its vouchers already authorized.'
        formatted:
          type:
          - string
          - 'null'
          example: '6'
          description: Human-readable amount; null exactly when `decimals` is
      required:
      - network
      - token
      - symbol
      - decimals
      - atomic
      - formatted
    DelegationSpendableDto:
      type: object
      properties:
        network:
          type:
          - integer
          - 'null'
          example: 4217
          description: Chain id, or null for a card-backed delegation, which no wallet funds.
        networkName:
          type:
          - string
          - 'null'
          example: tempo
          description: The Router’s canonical name for the chain. A quote may name the same chain differently, such as `eip155:<network>`, so match a quote to an entry by `network`, the chain id. Null exactly when `network` is null.
        spendableMicros:
          type:
          - string
          - 'null'
          example: '4640000'
          pattern: ^(0|[1-9][0-9]*)$
          description: 'Micros (1/10,000 of a cent, like `remainingBudgetMicros`): no more than this can be spent now on `network` in the budget’s token. The lesser of the remaining budget and the funding wallet’s balance there, rounded down, and for an organization wallet what the spending member’s group budget has left. `null` when it could not be determined in time (the wallet’s balance on this network or, for an organization wallet, its group budget could not be read), which is not zero; never null when `network` is null.'
      required:
      - network
      - networkName
      - spendableMicros
  securitySchemes:
    Authorization:
      scheme: bearer
      bearerFormat: JWT
      type: http