> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getpara.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Cancel Transfer

> Request cancellation of an existing unresolved transfer using a zero-value native transfer
to the same wallet, with empty calldata and gas limit 21000. It retains the original nonce,
chain, and type 0 or type 2 transaction family. The wallet must have no deployed or delegated
code (`eth_getCode` returns `0x`), otherwise admission returns `400 RECOVERY_CANCEL_UNSUPPORTED`.
A verified successful cancellation marks the original record `failed` with `failureCode: CANCELLED`
only after its canonical receipt and finality are verified.

Requires a secret API key, current authority over an API-created, unclaimed wallet,
and a verified pending original hash, sender, nonce, payment envelope, and fees.
Supports ordinary self-funded EVM native or ERC-20 `/transfer` records outside
automatic retry, sponsorship, yield, and arbitrary `sign-transaction` broadcasts.
Older records without spend-accounting metadata require a current policy with no spend limits.
Historical `failed/broadcast` or `failed/monitor_timeout` records can qualify only when the
original is verified as still pending. A receipt or advanced latest sender nonce rejects recovery.

Supply one positive uint256 `maxExecutionFeeWei` integer string. Para chooses fees from
current network estimates with at least a 12.5% increase in every original fee component,
rounded up; a zero component must become at least 1. The replacement's gas limit times
gasPrice (type 0) or maxFeePerGas (type 2) stays within your ceiling. Separate chain fees,
such as L1 data fees, are excluded. The wallet must cover the replacement's value and selected gas fees.
If the minimum fee bump exceeds the ceiling, admission returns `400 RECOVERY_FEE_CAP_REACHED`.
`400 RECOVERY_FEES_ABOVE_BUDGET` means the current base-fee floor plus the minimum required tip
cannot fit (the base-fee floor alone for type 0). Neither error admits an operation; retry with a
higher ceiling and a new `Idempotency-Key`. Higher recommendations are capped when the required minimum fits.

Save a new `Idempotency-Key` with this body. Selected fees are saved once; replays retrieve
the same operation without choosing new fees or signing again. Only one manual operation is
accepted across speed-up and cancellation for each original transfer. Current authority and
policy are checked before signing. Para does not bump the selected fees automatically.
Signing authorization expires five minutes after acceptance without cancelling signed transactions.
Recovery normally becomes `stopped` after the single replacement is submitted, with reason
`RECOVERY_MANUAL_ATTEMPT_COMPLETE`. Chain reconciliation continues; keep polling status and monitoring.
Only if you choose to abandon an unresolved payment, use the existing fresh `sign-transaction`
cancellation flow. This grant cannot renew or resume. See [Cancel a stopped payment](/v3/rest/automatic-retry#cancel-a-stopped-payment).

`202` returns the original transaction record with `manualRecovery` metadata. Poll its existing
lookup endpoint. The original and replacement compete for the same nonce; either can win.
The original hash stays unchanged; `monitoring.winningHash` identifies the verified winner.




## OpenAPI

````yaml /openapi.yaml post /v1/wallets/{walletId}/transactions/{transactionId}/cancel
openapi: 3.0.3
info:
  title: Para REST API
  version: '1.0'
  description: Server-to-server wallet creation and signing over HTTP
servers:
  - url: https://api.beta.getpara.com
    description: Beta
  - url: https://api.getpara.com
    description: Production
security:
  - ApiKeyAuth: []
paths:
  /v1/wallets/{walletId}/transactions/{transactionId}/cancel:
    post:
      tags:
        - Signing
      summary: Cancel Transfer
      description: >
        Request cancellation of an existing unresolved transfer using a
        zero-value native transfer

        to the same wallet, with empty calldata and gas limit 21000. It retains
        the original nonce,

        chain, and type 0 or type 2 transaction family. The wallet must have no
        deployed or delegated

        code (`eth_getCode` returns `0x`), otherwise admission returns `400
        RECOVERY_CANCEL_UNSUPPORTED`.

        A verified successful cancellation marks the original record `failed`
        with `failureCode: CANCELLED`

        only after its canonical receipt and finality are verified.


        Requires a secret API key, current authority over an API-created,
        unclaimed wallet,

        and a verified pending original hash, sender, nonce, payment envelope,
        and fees.

        Supports ordinary self-funded EVM native or ERC-20 `/transfer` records
        outside

        automatic retry, sponsorship, yield, and arbitrary `sign-transaction`
        broadcasts.

        Older records without spend-accounting metadata require a current policy
        with no spend limits.

        Historical `failed/broadcast` or `failed/monitor_timeout` records can
        qualify only when the

        original is verified as still pending. A receipt or advanced latest
        sender nonce rejects recovery.


        Supply one positive uint256 `maxExecutionFeeWei` integer string. Para
        chooses fees from

        current network estimates with at least a 12.5% increase in every
        original fee component,

        rounded up; a zero component must become at least 1. The replacement's
        gas limit times

        gasPrice (type 0) or maxFeePerGas (type 2) stays within your ceiling.
        Separate chain fees,

        such as L1 data fees, are excluded. The wallet must cover the
        replacement's value and selected gas fees.

        If the minimum fee bump exceeds the ceiling, admission returns `400
        RECOVERY_FEE_CAP_REACHED`.

        `400 RECOVERY_FEES_ABOVE_BUDGET` means the current base-fee floor plus
        the minimum required tip

        cannot fit (the base-fee floor alone for type 0). Neither error admits
        an operation; retry with a

        higher ceiling and a new `Idempotency-Key`. Higher recommendations are
        capped when the required minimum fits.


        Save a new `Idempotency-Key` with this body. Selected fees are saved
        once; replays retrieve

        the same operation without choosing new fees or signing again. Only one
        manual operation is

        accepted across speed-up and cancellation for each original transfer.
        Current authority and

        policy are checked before signing. Para does not bump the selected fees
        automatically.

        Signing authorization expires five minutes after acceptance without
        cancelling signed transactions.

        Recovery normally becomes `stopped` after the single replacement is
        submitted, with reason

        `RECOVERY_MANUAL_ATTEMPT_COMPLETE`. Chain reconciliation continues; keep
        polling status and monitoring.

        Only if you choose to abandon an unresolved payment, use the existing
        fresh `sign-transaction`

        cancellation flow. This grant cannot renew or resume. See [Cancel a
        stopped payment](/v3/rest/automatic-retry#cancel-a-stopped-payment).


        `202` returns the original transaction record with `manualRecovery`
        metadata. Poll its existing

        lookup endpoint. The original and replacement compete for the same
        nonce; either can win.

        The original hash stays unchanged; `monitoring.winningHash` identifies
        the verified winner.
      operationId: cancelRestTransfer
      parameters:
        - $ref: '#/components/parameters/WalletId'
        - $ref: '#/components/parameters/RequestId'
        - name: transactionId
          in: path
          required: true
          description: Original persisted `/transfer` transaction ID.
          schema:
            type: string
            format: uuid
        - name: Idempotency-Key
          in: header
          required: true
          description: >-
            Save a new key for this manual recovery intent and reuse it with the
            same body for HTTP retries.
          schema:
            type: string
            minLength: 1
            maxLength: 256
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ManualRecoveryRequest'
            example:
              maxExecutionFeeWei: '1000000000000000'
      responses:
        '202':
          description: >-
            Manual recovery accepted or replayed; poll the original transaction
            for its outcome.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ManualRecoveryTransferResponse'
              example:
                transactionId: 550e8400-e29b-41d4-a716-446655440000
                walletId: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
                walletType: EVM
                intentKind: transfer
                status: submitted
                createdAt: '2026-10-14T12:00:00Z'
                manualRecovery:
                  action: cancel
                  state: active
                  nonce: 7
                  originalHash: 0x1234abcd...
                  attempt:
                    stage: prepared
                    preparedAt: '2026-10-14T12:05:00Z'
        '400':
          description: >-
            Invalid fee ceiling, RECOVERY_UNSUPPORTED,
            RECOVERY_CANCEL_UNSUPPORTED, RECOVERY_FEE_CAP_REACHED,
            RECOVERY_FEES_ABOVE_BUDGET, or INSUFFICIENT_NATIVE_BALANCE.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
        '409':
          description: >-
            RECOVERY_ALREADY_RESOLVED, RECOVERY_CONTEXT_UNAVAILABLE,
            RECOVERY_NONCE_CONSUMED, RECOVERY_ALREADY_REQUESTED,
            AUTO_RETRY_ACCOUNTING_MISSING (an older record lacks
            spend-accounting metadata required by the current policy), or a
            conflicting wallet operation or idempotency key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/ServerError'
        '503':
          description: >-
            RPC_UNAVAILABLE. RPC evidence could not be verified; no new recovery
            was accepted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
components:
  parameters:
    WalletId:
      name: walletId
      in: path
      required: true
      description: Wallet UUID. A malformed or inaccessible wallet ID returns `404`.
      schema:
        type: string
        format: uuid
        example: 0a1b2c3d-4e5f-6789-abcd-ef0123456789
    RequestId:
      name: X-Request-Id
      in: header
      required: false
      description: UUID for request tracing. Para returns one if omitted.
      schema:
        type: string
        format: uuid
  schemas:
    ManualRecoveryRequest:
      type: object
      required:
        - maxExecutionFeeWei
      additionalProperties: false
      properties:
        maxExecutionFeeWei:
          type: string
          pattern: ^[0-9]{1,78}$
          not:
            pattern: ^0+$
          description: >
            Positive uint256 execution-gas fee ceiling for this replacement in
            native-token base units.

            Bounds gasLimit times gasPrice (type 0) or maxFeePerGas (type 2),
            excluding separate chain

            fees such as L1 data fees. Para selects and saves the replacement
            fees once, within this ceiling.
          example: '1000000000000000'
    ManualRecoveryTransferResponse:
      allOf:
        - $ref: '#/components/schemas/RestTransactionSummary'
      type: object
      required:
        - manualRecovery
      properties:
        manualRecovery:
          $ref: '#/components/schemas/RestManualRecoveryDetails'
    Error:
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: string
          description: Machine-readable error code for programmatic handling
          example: INVALID_REQUEST
        message:
          type: string
          description: Human-readable error message
        transactionId:
          type: string
          format: uuid
          description: >-
            Persisted transaction record id. Present only when a broadcast
            request failed after a history row was created.
        failureStage:
          type: string
          enum:
            - mpc_sign
            - signature_apply
            - signer_verify
            - broadcast
            - monitor_timeout
          description: >-
            Which stage of the broadcast lifecycle failed. Present on persisted
            broadcast failures.
        failureCode:
          type: string
          description: >-
            Machine-readable failure reason from the underlying broadcast helper
            (e.g. `INSUFFICIENT_NATIVE_BALANCE`, `EXECUTION_FAILED`). Present on
            broadcast-stage failures.
        signedTransaction:
          type: string
          description: >-
            Legacy signed transaction bytes on broadcast failures after signing.
            Sponsored responses never expose signed payloads.
      additionalProperties: true
      description: >
        All error responses include `code` and `message` fields. Some errors
        include extra fields (e.g. `walletId` on 409 Conflict).

        Broadcast failures that occur after a persisted transaction row is
        created include `transactionId`,

        `failureStage`, and (on broadcast-stage failures) `failureCode`, and
        also set the `x-transaction-id`

        response header. Legacy failures after signing can include
        `signedTransaction` for inspecting

        the already-signed bytes. Sponsored responses never expose signed
        payloads; recover the original

        operation with its tracking ID or original request and idempotency key.


        Common error codes: `INVALID_REQUEST`, `UNAUTHORIZED`, `FORBIDDEN`,
        `NOT_FOUND`, `CONFLICT`, `WALLET_ALREADY_EXISTS`,
        `WALLET_ALREADY_CLAIMED`, `RATE_LIMITED`, `INTERNAL_ERROR`.
    RestTransactionSummary:
      type: object
      required:
        - transactionId
        - walletId
        - walletType
        - intentKind
        - status
        - createdAt
      properties:
        executionMode:
          type: string
          enum:
            - legacy
            - sponsored
          description: >-
            Sponsored records use `sponsored`; legacy responses may omit this
            field.
        transactionId:
          type: string
          format: uuid
          example: 550e8400-e29b-41d4-a716-446655440000
        walletId:
          type: string
          format: uuid
        walletType:
          type: string
          enum:
            - EVM
            - SOLANA
        intentKind:
          type: string
          enum:
            - transfer
            - sign_transaction
            - yield
          description: REST operation that created the record.
        chainId:
          type: string
          description: EVM chain ID (EVM records only).
        network:
          type: string
          enum:
            - SOLANA
            - SOLANA_DEVNET
          description: Solana network (Solana records only).
        to:
          type: string
          description: >-
            Destination address. Absent for Solana `sign_transaction` records
            because Para does not decode arbitrary Solana instructions.
        value:
          type: string
          description: >-
            Transfer amount in smallest unit (wei / lamports / token smallest
            unit), or EVM `sign_transaction` value when supplied.
        tokenAddress:
          type: string
          description: >-
            Token contract (ERC-20 / SPL mint) address if a token transfer, else
            absent. Always absent for `sign_transaction` records.
        status:
          type: string
          enum:
            - pending
            - submitted
            - confirmed
            - reverted
            - failed
          description: >
            `pending` and `submitted` are nonterminal. `confirmed` and
            `reverted` are verified

            chain outcomes. `failed` can report a signing or broadcast error, or
            a verified same-nonce winner;

            historical broadcast and monitoring-timeout errors can retain an
            uncertain chain outcome.

            Treat unknown future values as nonterminal.

            For sponsored operations, inclusion is `submitted` with stage
            `included` until

            receipt verification. Successful execution with verified token
            delivery is `confirmed`;

            an included execution revert is `reverted`. Unknown submission stays
            nonterminal,

            and unresolved token evidence remains `pending` with stage
            `delivery_unverified`.

            Legacy EVM `transfer` and `sign_transaction` broadcasts remain
            `submitted` during durable

            reconciliation after the 30-minute active window. Receipt resolution
            requires canonical

            block identity, at least two confirmations, and finalized-block
            evidence. Timeout, RPC errors,

            and nonce consumption without an identified winner are unresolved,
            not payment failure.

            Solana broadcasts require finalized signature status and also retain
            unresolved monitoring context.

            A verified Para automatic-retry or manual speed-up variant resolves
            the same payment as confirmed or reverted.

            A verified cancellation or unrelated identified same-nonce winner
            leaves the original `failed` with `REPLACED` or `CANCELLED`;

            inspect `monitoring` for the actual winner's outcome. Historical
            `failed` / `monitor_timeout`

            records remain uncertain until chain-backed reconciliation corrects
            them. Historical failed/broadcast

            records can also be eligible for manual recovery when the original
            is verified as still pending.
        monitoring:
          $ref: '#/components/schemas/RestTransactionMonitoring'
        hash:
          type: string
          nullable: true
          description: >-
            Original transaction hash. Null or absent before signing; an
            identified same-nonce winner is exposed separately in
            monitoring.winningHash. Sponsored operations expose this after
            inclusion; never a UserOperation hash.
        blockNumber:
          type: string
          description: >-
            Block number as a decimal string (present when confirmed or
            reverted).
        blockHash:
          type: string
        failureStage:
          type: string
          enum:
            - mpc_sign
            - signature_apply
            - signer_verify
            - broadcast
            - monitor_timeout
          description: >-
            Stage at which the pipeline failed. `monitor_timeout` appears only
            on historical records and does not establish chain failure.
        failureCode:
          type: string
          description: >-
            Structured broadcast error code, or `REPLACED` / `CANCELLED` when a
            verified same-nonce winner superseded the original transaction.
        failureMessage:
          type: string
          description: Truncated error message (max 512 chars).
        createdAt:
          type: string
          format: date-time
        submittedAt:
          type: string
          format: date-time
          description: Set when status first moves to `submitted`.
        resolvedAt:
          type: string
          format: date-time
          description: >-
            Set when status reaches a terminal value (`confirmed`, `reverted`,
            `failed`).
    RestManualRecoveryDetails:
      type: object
      required:
        - action
        - state
        - nonce
        - originalHash
        - attempt
      description: >
        Present in manual-recovery POST/replay and single-transaction GET
        responses.

        Not included in transaction-list summaries. State tracks recovery
        processing;

        use the parent status and monitoring to establish the payment or
        cancellation outcome.
      properties:
        action:
          type: string
          enum:
            - speed_up
            - cancel
        state:
          type: string
          enum:
            - active
            - stopped
            - resolved
          description: >-
            Stopped is normal after the single replacement is submitted (reason
            RECOVERY_MANUAL_ATTEMPT_COMPLETE), and also occurs on expiry or
            another processing stop. Chain reconciliation continues; poll the
            parent status and monitoring. Use fresh explicit cancellation only
            if you choose to abandon an unresolved payment.
        reason:
          type: string
          description: Latest recovery or stop reason, when present.
        nonce:
          type: integer
          minimum: 0
          description: Original payment nonce, reused for the manual replacement.
        originalHash:
          type: string
          description: Verified original transfer hash, unchanged by recovery.
        attempt:
          type: object
          required:
            - stage
            - preparedAt
          description: >-
            The single manual replacement authorized through speed-up or
            cancellation. Its submission normally stops recovery processing
            while chain reconciliation continues.
          properties:
            stage:
              type: string
              enum:
                - prepared
                - signing
                - rejected
                - signed
                - submission_unknown
                - submitted
            hash:
              type: string
              description: >-
                Manual replacement hash after signed bytes are saved; does not
                establish inclusion or success.
            preparedAt:
              type: string
              format: date-time
            lastBroadcastAt:
              type: string
              format: date-time
    RestTransactionMonitoring:
      type: object
      required:
        - state
      description: >
        Optional durable monitoring metadata for legacy EVM and Solana
        broadcasts. Active monitoring hands off after

        30 minutes without changing unresolved chain outcome to failed. After 24
        hours, escalation retains

        unresolved state. Healthy pending checks stay at most five minutes apart
        during the first 24 hours, then

        may back off to one hour. RPC errors and missing context use backoff
        capped at one hour. After observing receipt

        or signature evidence, checks for finality, confirmations, or canonical
        chain evidence run every 60 seconds

        regardless of age. Unsupported finality evidence or missing legacy
        context remains unresolved and requires

        operational follow-up.
      properties:
        state:
          type: string
          enum:
            - active
            - reconciling
            - escalated
            - resolved
        timedOutAt:
          type: string
          format: date-time
          description: When active monitoring handed off to durable checks.
        lastCheckedAt:
          type: string
          format: date-time
          description: Most recent reconciliation check.
        reason:
          type: string
          enum:
            - pending
            - nonce_consumed
            - noncanonical
            - insufficient_confirmations
            - awaiting_finality
            - missing_context
            - rpc_error
          description: >-
            Latest reason the chain outcome remains unresolved. Nonce
            consumption alone does not identify a winner.
        chainOutcome:
          type: string
          enum:
            - success
            - revert
            - replacement
            - cancellation
          description: Verified outcome; absent while unresolved.
        winningHash:
          type: string
          description: >-
            Verified transaction using the original EVM sender and nonce. The
            original record hash remains unchanged.
        winningStatus:
          type: string
          enum:
            - confirmed
            - reverted
          description: Verified execution result of the identified winning transaction.
  responses:
    Unauthorized:
      description: API key not provided
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: UNAUTHORIZED
            message: secret api key not provided
    Forbidden:
      description: Invalid API key
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: FORBIDDEN
            message: invalid secret api key
    NotFound:
      description: Wallet not found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: NOT_FOUND
            message: wallet not found
    TooManyRequests:
      description: Rate limit exceeded
      headers:
        Retry-After:
          schema:
            type: integer
          description: Seconds until the rate limit window resets
          example: 60
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: RATE_LIMITED
            message: Rate limit exceeded, try again shortly.
    ServerError:
      description: Internal server error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: INTERNAL_ERROR
            message: Internal Server Error
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-API-Key
      description: Your partner secret key (server-side only)
      x-default: sk_your_secret_key_here

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.