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

# Get a transaction's status

> Lifecycle of a transaction submitted to the relay. Poll until `status` is no longer `pending` (typically under a second at `processed`; at most until the blockhash expires, about a minute).



## OpenAPI

````yaml /openapi.json get /v1/send/{signature}
openapi: 3.0.3
info:
  description: >-
    REST API for the Archer Exchange — a high-performance Solana-based order
    book exchange.


    All monetary values (prices, sizes, fees) are returned as decimal strings
    for precision.


    ### Rate Limiting

    All endpoints are rate-limited via a token-bucket algorithm. When the limit
    is exceeded, the API returns `429 Too Many Requests`.


    ### Error Format

    All errors follow a consistent JSON format:

    ```json

    {
      "error": "ERROR_CODE",
      "message": "Human-readable description"
    }

    ```


    ### Handling errors

    Every error falls into one of five actions. REST errors come back as
    `{"error": CODE, "message"}`. A transaction that fails on-chain reports
    `{"InstructionError": [index, {"Custom": code}]}`; codes are the `errors`
    list of the program IDL (`archer-sdk/idl/archer_v1.json`). When a build
    endpoint's preflight catches an on-chain error first, it returns `400
    INVALID_PARAMS` with the reason in `message`.


    | Action | REST | On-chain (code) |

    |---|---|---|

    | **Retry as is**, with backoff | `RATE_LIMITED` (429),
    `SERVICE_UNAVAILABLE` (503), `INTERNAL_ERROR` (500); relay `OVERLOADED`,
    `PREFLIGHT_UNAVAILABLE`. Keep backing off on 429: 50 of them within a minute
    from one IP returns `BANNED` (403) for 10 minutes | none |

    | **Refetch, rebuild, retry**: the book or registry changed under you | |
    `LevelSizeMismatch` (527), `StaleSequenceNumber` (509),
    `SequenceNumberTooFarAhead` (522), `RegistryBooksMismatch` (525),
    `IncompleteMakerBooks` (513), `NoMatchingLiquidity` (507); relay status
    `expired` (re-sign with a fresh blockhash) |

    | **Reprice** | `CROSSES_SPREAD`, `SLIPPAGE_EXCEEDED` | `PostOnlyWouldCross`
    (524), `CrossingOrderLevels` (505), `InvalidPrice` (503),
    `SlippageToleranceExceeded` (703) |

    | **Resize** | `INSUFFICIENT_LIQUIDITY` (the body's `availableSize` is what
    fits) | `MakerBookSideFull` (528: cancel a level first),
    `InvalidSizeAtLevel` (506), `InsufficientBalance` (402) and SPL Token `1`
    (fund the account or shrink), `ZeroSwapAmount` (702) |

    | **Stop**: fix the request or the setup; retrying cannot help |
    `INVALID_PARAMS`, `MISSING_API_KEY` / `INVALID_API_KEY` (401), `FORBIDDEN`,
    `NOT_FOUND`, `MARKET_NOT_FOUND`, `METHOD_NOT_ALLOWED`; `MARKET_PAUSED` /
    `MARKET_FROZEN` until the market resumes |
    `UnauthorizedArcherAccountDelegate` (1001), `BuilderFeeExceedsAccountCap`
    (1003), `UnauthorizedMaker` (502), `MakerNotRegistered` (512),
    `PostOnlyRequiresLimitOrderBook` (526), `MarketNotActive` (107),
    `MarketFrozen` (114); any 200–399 code (wrong account wiring, a bug to
    report) |
  title: Archer Exchange API
  version: 1.0.0
servers:
  - description: Production
    url: https://api.archer.exchange
  - description: Staging
    url: https://api-staging.archer.exchange
  - description: Local
    url: http://localhost:8080
security:
  - apiKey: []
tags:
  - description: Discover and inspect available trading markets
    name: Markets
  - description: Token metadata for every mint Archer lists
    name: Tokens
  - description: Get price quotes before placing an order
    name: Quote
  - description: Build unsigned Solana transactions for swaps
    name: Orders
  - description: Build unsigned Solana transactions for limit orders
    name: Limit Orders
  - description: >-
      ArcherAccount — a wallet's delegated trading identity. Collateral sits in
      token accounts owned by the account PDA; an authorized delegate can trade
      and quote as the account but never withdraw.
    name: Account
  - description: Read a maker book — balances and resting levels — by PDA or by owner
    name: Maker Books
  - description: Deposit / withdraw / close — fund movement for a maker book
    name: Maker Funds
  - description: Public protocol-wide aggregate statistics
    name: Stats
  - description: >-
      Submit signed Solana transactions and let Archer land them. Hosted at
      `https://send.archer.exchange`, separate from the REST API, using the same
      API key.
    name: Transaction Relay
paths:
  /v1/send/{signature}:
    servers:
      - description: Transaction relay
        url: https://send.archer.exchange
    get:
      tags:
        - Transaction Relay
      summary: Get a transaction's status
      description: >-
        Lifecycle of a transaction submitted to the relay. Poll until `status`
        is no longer `pending` (typically under a second at `processed`; at most
        until the blockhash expires, about a minute).
      operationId: relayTransactionStatus
      parameters:
        - description: Signature returned when the transaction was sent.
          in: path
          name: signature
          required: true
          schema:
            type: string
      responses:
        '200':
          content:
            application/json:
              examples:
                expired:
                  summary: Expired
                  value:
                    commitment: processed
                    err: null
                    landedAt: null
                    landingMs: null
                    reason:
                      code: null
                      instruction: null
                      name: BlockhashExpired
                      program: null
                      programName: null
                    receivedAt: 1791190083798
                    rpcError: null
                    sends: 2
                    signature: >-
                      5y6LPzFiaVcgmT9GqRbaTY38ks4QKRcQuuGJXKbRHXKetANNCo9ptn5dSc2b4FJUvcmxzHyacG5ESPD9bcJkv9Gd
                    slot: null
                    status: expired
                failed:
                  summary: Failed on-chain
                  value:
                    commitment: processed
                    err:
                      InstructionError:
                        - 2
                        - Custom: 703
                    landedAt: 1791190084200
                    landingMs: 402
                    reason:
                      code: 703
                      instruction: 2
                      name: SlippageToleranceExceeded
                      program: Archer8kgiavM61GyusMzaaS2ft5sALtNsD1HxkUPMhy
                      programName: Archer
                    receivedAt: 1791190083798
                    rpcError: null
                    sends: 1
                    signature: >-
                      4MbqSgwK7VkQwVwsPkjyUv5Z1nNQrhpgUgpQXCVNjhStuw65k6XqQYxWZKnmJGJFdw1Eeq6LroVBKqiAQjV8Dfyt
                    slot: 431573371
                    status: failed
                landed:
                  summary: Landed
                  value:
                    commitment: processed
                    err: null
                    landedAt: 1791190084200
                    landingMs: 402
                    reason: null
                    receivedAt: 1791190083798
                    rpcError: null
                    sends: 1
                    signature: >-
                      5r5Zb67VfBe3cGp27z53XVcQbF7oTmf9N4q2WoqDxWL716mSq8uttuZeABVksZRQPa28fTfJvDYiDcCYN685bDRr
                    slot: 431573371
                    status: landed
              schema:
                $ref: '#/components/schemas/RelayTransactionStatus'
          description: Current status.
        '400':
          content:
            application/json:
              example:
                error: INVALID_SIGNATURE
                message: Not a base58 signature.
              schema:
                $ref: '#/components/schemas/RelayErrorResponse'
          description: Not a base58 signature.
        '401':
          $ref: '#/components/responses/RelayUnauthorized'
        '404':
          content:
            application/json:
              example:
                error: NOT_FOUND
                message: Unknown signature, or its status has aged out.
              schema:
                $ref: '#/components/schemas/RelayErrorResponse'
          description: Never submitted to this relay, or finished more than 10 minutes ago.
        '429':
          $ref: '#/components/responses/RelayRateLimited'
      security:
        - apiKey: []
        - apiKeyQuery: []
components:
  schemas:
    RelayTransactionStatus:
      properties:
        commitment:
          description: The commitment requested when it was sent.
          enum:
            - processed
            - confirmed
            - finalized
          type: string
        err:
          description: >-
            On-chain execution error when `status` is `failed`, as Solana RPC
            returns it: a string (e.g. `"InsufficientFundsForRent"`) or an
            object (e.g. `{"InstructionError": [0, {"Custom": 1}]}`).
          nullable: true
        landedAt:
          description: When the relay saw it reach `commitment` (Unix ms).
          format: int64
          nullable: true
          type: integer
        landingMs:
          description: >-
            `landedAt - receivedAt`. Includes up to ~400 ms of status-polling
            delay.
          format: int64
          nullable: true
          type: integer
        reason:
          allOf:
            - $ref: '#/components/schemas/RelayFailureReason'
          description: >-
            Why it `failed` or `expired`; `null` while `pending` and when
            `landed`. For `failed`, the relay refines it with the transaction's
            on-chain logs a second or two after landing.
          nullable: true
        receivedAt:
          description: When the relay received it (Unix ms).
          format: int64
          type: integer
        rpcError:
          description: >-
            Last error from the staked RPC send, if any. Informational: the
            transaction is still sent directly to leaders.
          nullable: true
          type: string
        sends:
          description: >-
            Times the relay has sent it (first send plus re-sends, at most `1 +
            maxRetries`).
          type: integer
        signature:
          type: string
        slot:
          description: Slot it landed in.
          format: int64
          nullable: true
          type: integer
        status:
          description: >-
            - `pending`: being sent; not yet seen at `commitment`.

            - `landed`: reached `commitment` and executed successfully.

            - `failed`: reached `commitment` but execution failed; fees were
            paid. See `reason` (and the raw `err`).

            - `expired`: the blockhash expired before the transaction landed. It
            can no longer land; re-sign with a new blockhash. See `reason`.
          enum:
            - pending
            - landed
            - failed
            - expired
          type: string
      required:
        - signature
        - status
        - commitment
        - slot
        - err
        - receivedAt
        - landedAt
        - landingMs
        - sends
        - rpcError
        - reason
      type: object
    RelayErrorResponse:
      properties:
        err:
          description: >-
            `PREFLIGHT_FAILED` only: the simulation error as Solana RPC returns
            it, a string (e.g. `"AccountNotFound"`) or an object (e.g.
            `{"InstructionError": [0, {"Custom": 1}]}`).
        error:
          description: Machine-readable error code.
          enum:
            - MISSING_API_KEY
            - INVALID_API_KEY
            - RATE_LIMITED
            - INVALID_REQUEST
            - INVALID_TRANSACTION
            - PREFLIGHT_FAILED
            - PREFLIGHT_UNAVAILABLE
            - INVALID_SIGNATURE
            - NOT_FOUND
            - OVERLOADED
          type: string
        logs:
          description: '`PREFLIGHT_FAILED` only: program logs from the simulation.'
          items:
            type: string
          type: array
        message:
          description: Human-readable error description.
          type: string
        reason:
          allOf:
            - $ref: '#/components/schemas/RelayFailureReason'
          description: '`PREFLIGHT_FAILED` only: the simulation error explained.'
      required:
        - error
        - message
      type: object
    RelayFailureReason:
      description: >-
        Names the error behind a failed or expired transaction. Solana's error
        variants are passed through as-is; a custom program error code is mapped
        to that program's variant name (Archer, System, Token, Token-2022,
        Associated Token Account; any other program stays `Custom`). The program
        is taken from the logs, so a failure inside a router's call (e.g.
        Jupiter calling Archer) is attributed to the program that actually
        raised it.
      properties:
        code:
          description: >-
            The program's own error code, for custom program errors (Archer's
            codes are listed in its IDL).
          example: 703
          nullable: true
          type: integer
        instruction:
          description: Index of the top-level instruction the error is attributed to.
          example: 2
          nullable: true
          type: integer
        name:
          description: >-
            The error's variant name: the program's for a custom error (e.g.
            `InvalidMakerBook`, `SlippageToleranceExceeded`,
            `InsufficientFunds`), otherwise Solana's (e.g. `BlockhashNotFound`,
            `MissingRequiredSignature`); `Custom` for an unrecognised program's
            code; `BlockhashExpired` or `NotLanded` for an expired transaction.
          example: SlippageToleranceExceeded
          type: string
        program:
          description: >-
            Program that raised the error (base58). `null` for errors outside
            any instruction (fees, blockhash, account loading, expiry).
          example: Archer8kgiavM61GyusMzaaS2ft5sALtNsD1HxkUPMhy
          nullable: true
          type: string
        programName:
          description: >-
            Well-known name of `program`, when known (e.g. `Archer`, `Token
            Program`).
          example: Archer
          nullable: true
          type: string
      required:
        - name
        - program
        - programName
        - instruction
        - code
      type: object
  responses:
    RelayUnauthorized:
      content:
        application/json:
          example:
            error: MISSING_API_KEY
            message: >-
              An API key is required. Pass it via the X-API-Key header or
              ?api-key=.
          schema:
            $ref: '#/components/schemas/RelayErrorResponse'
      description: Missing or unknown API key.
    RelayRateLimited:
      content:
        application/json:
          example:
            error: RATE_LIMITED
            message: Rate limit exceeded for this API key.
          schema:
            $ref: '#/components/schemas/RelayErrorResponse'
      description: >-
        Rate limit exceeded for this API key: 10/s (burst 20) for sending, and
        separately 10/s (burst 20) for status lookups.
  securitySchemes:
    apiKey:
      in: header
      name: X-API-Key
      type: apiKey
    apiKeyQuery:
      description: >-
        Same key as `X-API-Key`, as a query parameter (`?api-key=YOUR_KEY`).
        Transaction relay only.
      in: query
      name: api-key
      type: apiKey

````

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