> ## Documentation Index > Fetch the complete documentation index at: https://docs.dakota.xyz/llms.txt > Use this file to discover all available pages before exploring further. # List the calling client's scheduled payments (BETA) > > **Beta** — early access. Returns the calling client's scheduled payments (the ScheduledPayment primitive — all statuses, not just future ones), newest due first. Each shows its funding wallet (the customer's choice at acceptance); once executed, a row also carries the covering mandate and money-path transaction as audit. Narrow the collection with the optional customer_id, signer_id, wallet_id, mandate_id, and status filters; omit them all for the full client collection. The mandate_id filter naturally matches executed rows only (a row carries no mandate until it fires). Payments are returned in `data`, with `meta` carrying the total match count (across all pages, honouring the same filters) and whether more rows exist before or after this one. Unpaginated, `meta.total_count` equals the length of `data` and both flags are false. ## OpenAPI ````yaml /openapi.yaml get /scheduled-payments openapi: 3.0.3 info: title: Dakota Platform API version: 1.0.0 description: >- Combined API specification for Dakota Platform services: - Issuance API: Asset minting and burning operations - Onboarding API: Know Your Business/Customer verification - On/Off Ramp API: Managing on-ramp and off-ramp accounts - Recipients API: Managing destinations for KYB'd entities - Transactions API: Viewing transaction history across platform operations ## Authentication and API Headers All API endpoints require the following headers: - `x-idempotency-key`: Required for all POST endpoints to ensure request idempotency - `x-api-key`: Required for authentication across all endpoints Note: On /applications endpoints you need a token for authentication instead of a x-api-key - `x-application-token`: Required for authentication on public /applications endpoints (alternative to `x-api-key` where documented) ## Rate Limits Requests are rate limited per API key. Every response includes the following headers: | Header | Description | | --- | --- | | `X-RateLimit-Limit` | Maximum requests allowed in the current one-minute window. | | `X-RateLimit-Remaining` | Requests remaining in the current window. | | `X-RateLimit-Reset` | Absolute Unix timestamp (seconds since epoch) when the current rate-limit window resets. | When a request is throttled (`429`), responses also include `Retry-After` with seconds to wait before retrying. servers: - url: https://api.platform.dakota.xyz description: Production environment - url: https://api.platform.sandbox.dakota.xyz description: Sandbox — safe for testing with simulated data security: - ApiKeyAuth: [] tags: - name: Agentic Payments x-beta: true description: >- Beta — agent-driven payments: provision agents, draft and approve spending mandates, accept reviewed instructions, and manage scheduled payments. **Prerequisites:** Customer onboarded; signer groups attached for recognition. **Related:** Wallets, Signer Groups, Transactions - name: Mandates x-beta: true description: >- Beta — spending mandates: signed, signer-bound authorizations governing what may be spent, approved or cancelled by a second recognized signer (§8 — the dual-control rule that every mandate mutation must be signed by a recognized signer OTHER than the bound one). Independent of agents and scheduled payments. **Prerequisites:** Signer groups attached for recognition. **Related:** Signer Groups, Transactions - name: Insights x-beta: true description: >- Beta — read-only account insight: a deterministic report over a customer's agentic activity (funding balances, upcoming obligations, failures, mandate headroom and expiry). Never moves money, never creates or changes anything. **Prerequisites:** Customer onboarded; insight is computed from the customer's scheduled payments, mandates, and wallets. **Related:** Agentic Payments, Mandates - name: Customers description: >- Manage customer entities representing businesses and organizations onboarded to Dakota. **Prerequisites:** Complete KYB via Onboarding endpoints before initiating money movement. **Related:** Onboarding, Recipients, Transactions, Accounts, Wallets - name: Wallets description: >- Manage wallets, balances, and wallet-to-signer-group relationships for custody and movement controls. **Prerequisites:** Customer must exist. Configure signer groups before policy-enforced workflows. **Related:** Signer Groups, Policies, Transactions, Customers - name: Transactions description: >- Create, cancel, and retrieve transaction records across account and wallet flows. **Prerequisites:** Accounts or destinations must be configured based on flow type. **Related:** Accounts, Recipients, Policies, Events - name: Recipients description: >- Manage recipient entities and destination rails used by customers for payouts and transfers. **Prerequisites:** Customer must be onboarded and active. **Related:** Customers, Transactions, Accounts, Onboarding - name: Accounts description: >- Manage account resources used for onramp, offramp, and swap operations. **Prerequisites:** Customer must be created and network/asset constraints must be known. **Related:** Customers, Transactions, Auto Transactions, Info - name: Auto Transactions description: >- Manage automated transaction configurations and execution history for account automation workflows. **Prerequisites:** Source account must exist and be configured for automation. **Related:** Accounts, Transactions, Events - name: Onboarding description: >- Manage KYB/KYC onboarding lifecycle, application documents, attestations, and verification steps. **Prerequisites:** Customer context and required entity/application metadata. **Related:** Customers, Exceptions, Recipients, Transactions - name: Policies description: >- Define and manage policy objects and rules used for transaction governance and risk controls. **Prerequisites:** Wallet and signer group resources should be configured for enforcement scenarios. **Related:** Wallets, Signer Groups, Transactions - name: Signer Groups description: >- Manage signer groups and signer assignments for multi-party authorization models. **Prerequisites:** Wallets should exist before linking signer groups. **Related:** Wallets, Policies, Transactions - name: Authentication description: >- Manage API authentication credentials and key lifecycle for platform access. **Prerequisites:** Client organization must be provisioned. **Related:** Users, Info - name: Users description: >- Manage client users, roles, and identity metadata for platform access control. **Prerequisites:** Auth credentials and client context must be established. **Related:** Authentication - name: Webhooks description: >- Manage outbound webhook targets and delivery configuration for event notifications. **Prerequisites:** Subscriber endpoint must be reachable and secured. **Related:** Events, Authentication - name: Payouts description: >- Manage where Dakota sends your accrued developer-fee payouts. **Prerequisites:** Auth credentials and client context must be established. **Related:** Events - name: Events description: >- Retrieve event records emitted by platform operations for audit and troubleshooting. **Prerequisites:** Requesting client must have access to referenced resources. **Related:** Webhooks, Transactions, Onboarding - name: Info description: >- Read platform capability metadata, such as supported rails, networks, and assets. These operations are served under `/capabilities/*` - `GET /capabilities/countries` and `GET /capabilities/networks`. The tag name does not appear in the request paths. **Prerequisites:** Valid authentication headers. **Related:** Accounts, Transactions - name: Sandbox description: >- Trigger sandbox-only simulation endpoints for safe end-to-end integration testing with synthetic data. The sandbox host (`https://api.platform.sandbox.dakota.xyz`) also accepts a family of `X-Sandbox-*` request headers on most write endpoints (`Customers`, `Accounts`, `Transactions`, simulate endpoints) that let integrators drive deterministic failure modes — pick a preset via `X-Sandbox-Scenario`, or compose a custom one with `X-Sandbox-Error-Step`/`X-Sandbox-Error-Status`/`X-Sandbox-Error-Message`. `X-Sandbox-Instant-Completion` collapses async flows to a single synchronous step, and `X-Sandbox-Skip-Auto-Approval` keeps newly created KYB applications in `pending` for manual-review testing. All `X-Sandbox-*` headers are ignored in production. **Prerequisites:** Sandbox environment and test customer data. **Related:** Customers, Accounts, Transactions, Onboarding - name: Legal description: |- The legal documents customers accept — terms of service, privacy policy, e-sign notice, and partner agreements. Dakota publishes these here, and this is the authoritative source: the hosted onboarding flow, the dakota.xyz website, and your own integration all read the same revisions. Present the current revision to your customer before capturing their acceptance so the record reflects the text they actually saw. paths: /scheduled-payments: get: tags: - Agentic Payments summary: List the calling client's scheduled payments (BETA) description: > > **Beta** — early access. Returns the calling client's scheduled payments (the ScheduledPayment primitive — all statuses, not just future ones), newest due first. Each shows its funding wallet (the customer's choice at acceptance); once executed, a row also carries the covering mandate and money-path transaction as audit. Narrow the collection with the optional customer_id, signer_id, wallet_id, mandate_id, and status filters; omit them all for the full client collection. The mandate_id filter naturally matches executed rows only (a row carries no mandate until it fires). Payments are returned in `data`, with `meta` carrying the total match count (across all pages, honouring the same filters) and whether more rows exist before or after this one. Unpaginated, `meta.total_count` equals the length of `data` and both flags are false. operationId: listScheduledPayments parameters: - name: customer_id in: query required: false schema: type: string description: >- Only payments for this customer (the signer's owning agent's customer). - name: signer_id in: query required: false schema: type: string description: Only payments bound to this signer. - name: wallet_id in: query required: false schema: type: string description: Only payments funded from this wallet. - name: mandate_id in: query required: false schema: type: string description: > Only payments that executed under this mandate (mandate_id is stamped at fire time, so this matches executed rows only). - name: mandate_version in: query required: false schema: type: integer description: > Only payments that executed under this VERSION of the mandate — "which payments were judged against v2's caps". Use together with mandate_id; like it, this matches executed rows only. - name: status in: query required: false schema: type: string description: > Comma-separated statuses to include, e.g. "scheduled,executed". Allowed values: scheduled, cancelled, executed, failed. Omit for all. - name: limit in: query required: false description: > Page size. OMIT FOR EVERY MATCHING PAYMENT, which is what this endpoint has always returned and remains the default — a client that does not ask to paginate must not be silently truncated. When you do page, `meta.total_count` and `meta.has_more_after` tell you where you are in the collection, so a full page is never mistaken for the end. schema: type: integer minimum: 1 maximum: 100 - name: page in: query required: false description: > 1-based page number, used only alongside `limit`; on its own it has nothing to page through and is ignored. A page past the end is an empty list, not an error. Rows are ordered by due date DESCENDING and then by id descending — newest due first, so page 1 carries the most recent and upcoming activity rather than the oldest settled history. The id tiebreak makes that order total, so a payment cannot be skipped or repeated across pages by sharing a due date with another. schema: type: integer minimum: 1 default: 1 responses: '200': description: Scheduled payments, newest due first content: application/json: schema: $ref: '#/components/schemas/ScheduledPaymentList' example: data: - id: 2vWxScheduled000000000000000 wallet_id: 2vWxWallet000000000000000000 amount: '10000' asset: USDC address: '0xa11ce00000000000000000000000000000000001' network_id: base-sepolia status: scheduled scheduled_at: 1781481600 meta: total_count: 1 has_more_after: false has_more_before: false '400': description: Invalid request content: application/problem+json: schema: $ref: '#/components/schemas/ProblemDetails' example: type: >- https://docs.dakota.xyz/api-reference/errors#invalid-identifier title: Invalid Identifier status: 400 detail: invalid signer_id '404': description: Agentic payments not enabled, or the resource was not found content: application/problem+json: schema: $ref: '#/components/schemas/ProblemDetails' example: type: https://docs.dakota.xyz/api-reference/errors#not-found title: Not Found status: 404 detail: agentic payments are not enabled components: schemas: ScheduledPaymentList: type: object required: - data - meta properties: data: type: array items: $ref: '#/components/schemas/ScheduledPaymentResponse' meta: $ref: '#/components/schemas/Meta' ProblemDetails: type: object required: - type - title - status description: | Error response following RFC 9457 Problem Details. Public API error responses use this format. example: type: https://docs.dakota.xyz/api-reference/errors#not-found title: Customer Not Found status: 404 detail: Customer cst_2abc123 was not found in your organization. instance: https://api.platform.dakota.xyz/customers/cst_2abc123 request_id: req_7f3a8b2c properties: type: type: string format: uri description: | URI reference identifying the problem type. Resolves to human-readable documentation. example: https://docs.dakota.xyz/api-reference/errors#not-found title: type: string description: >- Short, human-readable summary of the problem type. Stable across occurrences. example: Customer Not Found status: type: integer description: HTTP status code for this occurrence. example: 404 detail: type: string description: Human-readable explanation specific to this occurrence. example: Customer cst_2abc123 was not found in your organization. instance: type: string format: uri description: The request path that triggered this error. example: https://api.platform.dakota.xyz/customers/cst_2abc123 request_id: type: string description: Unique request identifier. Include when contacting support. example: req_7f3a8b2c errors: type: array description: Field-level validation errors (present for validation failures). items: $ref: '#/components/schemas/ValidationError' resolution_url: type: string format: uri description: | A link the customer can follow to CLEAR this error, present only on problems with a concrete self-service remedy. Today this is returned by `#terms-not-accepted`, where it points at the hosted flow in which the outstanding agreement can be signed. The link is token-gated and usable as-is — send the customer to it directly rather than parsing it out of `detail`. example: >- https://onboarding.dakota.xyz/applications/2abc123?token=tok_7f3a8b2c user_message: type: string description: | A plain-language rendition of `detail` written for the end customer, present when one exists for this error. `detail` names request fields and actions so a machine caller (such as a payment agent drafting proposals) can self-correct; `user_message` says the same thing without API vocabulary. Clients that relay errors into a human surface (chat, email, UI) should show `user_message` when present and fall back to `detail`. example: >- ACH payments pay out USD, so a USDC payout isn't possible on this rail. Change the payout currency to USD and try again. ScheduledPaymentResponse: type: object properties: id: type: string signer_id: type: string description: The signer (hosted agent) this payment fires under. wallet_id: type: string description: >- The funding wallet this payment spends from (the customer's choice at acceptance). mandate_id: type: string description: >- AUDIT — the mandate that covered this payment at fire time. Absent until the payment executes (coverage is decided at fire time, not bound at rest). mandate_version: type: integer description: > AUDIT — WHICH version of that mandate authorized this payment. A mandate's rule can be amended (new versions are appended), so `mandate_id` alone no longer identifies the caps the payment was judged against; this does, and it stays true after later amendments. Look the rule up at GET /mandates/{mandate_id}/versions. Always accompanies `mandate_id` — when the covering mandate could not be determined, both are absent rather than one being guessed. wallet_transaction_id: type: string description: >- AUDIT — the money-path transaction created when this payment fired. Absent until the payment executes. amount: type: string description: >- What LEAVES the funding wallet, denominated in `asset` on `network_id`. For a DIRECT payment that is also what the payee receives. For a CONVERTED payment (the payee settles on a different asset or chain) it is the DEPOSIT into the conversion account, grossed up so the payee nets the requested figure — so it is LARGER than the payout and in a DIFFERENT asset. Never render it against `output_asset`. asset: type: string description: >- The asset `amount` is denominated in — the asset that LEAVES the wallet. For a converted payment this is the deposit asset, not the one the payee receives (see `output_asset`). failure_reason: type: string description: >- Why the payment failed (e.g. the mandate gate's denied dimensions); absent unless status is failed. recipient_id: type: string description: >- The recipient this payment pays, when it was created from a destination. Absent for a direct-address payment (which carries no recipient). destination_id: type: string description: >- The REAL destination this payment settles to — a bank (for an offramp) or a crypto destination. For an auto-account (convert-and-forward) payment, `address` is the crypto DEPOSIT actually paid while this names the bank/crypto target, so a client can show which account the scheduled payment is for. Absent for a direct-address payment. destination_type: type: string enum: - bank - crypto description: >- The kind of the REAL destination (see destination_id). `bank` marks an offramp (the payment converts crypto to fiat and forwards via a bank rail); `crypto` a direct or cross-family crypto payout. Absent for a direct-address payment with no destination. destination_label: type: string description: >- A human label for the real destination — e.g. "Chase ••••5432" for a bank, or a shortened address for crypto — so a client can show which account the payment settles to without a second lookup. Absent when unresolved. destination_rail: type: string description: >- For a `bank` destination, the payout rail (e.g. ach, fedwire, swift). Absent for crypto. output_asset: type: string description: >- The asset the recipient ULTIMATELY receives. For an offramp this is the fiat currency (e.g. USD) the deposit converts to; for a direct crypto payment it equals `asset`. DO NOT PAIR THIS WITH `amount`: for a converted payment `amount` is the DEPOSIT — what leaves the wallet, in the deposit's own asset — and it is grossed up so the payee nets the requested figure, so a real payment reads amount 0.211112 and pays out 0.19. The rate is 1:1; the fee is not. This response carries no output amount, so a converted payment's payout figure is not available here. output_network: type: string description: >- For a crypto destination, the network the recipient ULTIMATELY receives on — for a cross-family swap this differs from `network_id` (the DEPOSIT network the wallet pays), e.g. output_network solana-devnet while network_id is base-sepolia. Equals `network_id` for a direct crypto payment; absent for a bank offramp (fiat has no network). address: type: string network_id: type: string status: type: string enum: - scheduled - cancelled - executed - failed executed_at: type: integer format: int64 scheduled_at: type: integer format: int64 Meta: type: object description: Meta information about the response required: - total_count - has_more_after - has_more_before properties: total_count: type: integer description: Total number of items available example: 100 has_more_after: type: boolean description: Indicates whether there are more items that follow this set. example: true has_more_before: type: boolean description: Indicates whether there are more items that precede this set. example: false ValidationError: type: object required: - field - message properties: field: type: string description: Field path using dot notation for nested fields. example: bank_account.routing_number message: type: string description: Human-readable description of the field error. example: Routing number must be exactly 9 digits code: type: string description: Machine-readable error code for this field. example: invalid_format securitySchemes: ApiKeyAuth: type: apiKey in: header name: x-api-key ````