> ## 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.

# Send a transaction

> Accepts a fully signed transaction and lands it. Returns the signature as soon as it is accepted (after preflight, unless `skipPreflight`), before it lands; track it with `GET /v1/send/{signature}`.

Send JSON, or raw bytes with `Content-Type: application/octet-stream`. With raw bytes, pass the options as query parameters: `?commitment=confirmed&maxRetries=3&skipPreflight=true`. In JSON, body fields take precedence over query parameters.

Re-submitting an already-accepted transaction returns the same signature and does not re-send it.



## OpenAPI

````yaml /openapi.json post /v1/send
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:
    servers:
      - description: Transaction relay
        url: https://send.archer.exchange
    post:
      tags:
        - Transaction Relay
      summary: Send a transaction
      description: >-
        Accepts a fully signed transaction and lands it. Returns the signature
        as soon as it is accepted (after preflight, unless `skipPreflight`),
        before it lands; track it with `GET /v1/send/{signature}`.


        Send JSON, or raw bytes with `Content-Type: application/octet-stream`.
        With raw bytes, pass the options as query parameters:
        `?commitment=confirmed&maxRetries=3&skipPreflight=true`. In JSON, body
        fields take precedence over query parameters.


        Re-submitting an already-accepted transaction returns the same signature
        and does not re-send it.
      operationId: relaySendTransaction
      parameters:
        - description: Same as the JSON field. Use with a raw-bytes body.
          in: query
          name: commitment
          required: false
          schema:
            default: processed
            enum:
              - processed
              - confirmed
              - finalized
            type: string
        - description: Same as the JSON field. Use with a raw-bytes body.
          in: query
          name: maxRetries
          required: false
          schema:
            default: 1
            minimum: 0
            type: integer
        - description: Same as the JSON field. Use with a raw-bytes body.
          in: query
          name: skipPreflight
          required: false
          schema:
            default: false
            type: boolean
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/SendTransactionRequest'
          application/octet-stream:
            schema:
              description: >-
                The serialized signed transaction, in any message format:
                legacy, v0 or v1 (max 1232 bytes for legacy and v0, 4096 bytes
                for v1).
              format: binary
              type: string
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendTransactionResponse'
          description: Accepted (or already accepted). The relay is now landing it.
        '400':
          content:
            application/json:
              examples:
                invalidOption:
                  summary: Invalid option
                  value:
                    error: INVALID_REQUEST
                    message: commitment must be "processed", "confirmed" or "finalized"
                invalidTransaction:
                  summary: Invalid transaction
                  value:
                    error: INVALID_TRANSACTION
                    message: transaction signature verification failed
                preflightFailed:
                  summary: Preflight failed
                  value:
                    err:
                      InstructionError:
                        - 2
                        - Custom: 1
                    error: PREFLIGHT_FAILED
                    logs:
                      - Program 11111111111111111111111111111111 invoke [1]
                      - 'Transfer: insufficient lamports 0, need 1'
                      - >-
                        Program 11111111111111111111111111111111 failed: custom
                        program error: 0x1
                    message: >-
                      Transaction simulation failed:
                      {"InstructionError":[2,{"Custom":1}]}
                    reason:
                      code: 1
                      instruction: 2
                      name: ResultWithNegativeLamports
                      program: '11111111111111111111111111111111'
                      programName: System Program
              schema:
                $ref: '#/components/schemas/RelayErrorResponse'
          description: >-
            Rejected: invalid body/options/transaction, or the preflight
            simulation failed.
        '401':
          $ref: '#/components/responses/RelayUnauthorized'
        '429':
          $ref: '#/components/responses/RelayRateLimited'
        '503':
          content:
            application/json:
              examples:
                overloaded:
                  summary: Overloaded
                  value:
                    error: OVERLOADED
                    message: Too many pending transactions; retry shortly.
                preflightUnavailable:
                  summary: Preflight unavailable
                  value:
                    error: PREFLIGHT_UNAVAILABLE
                    message: >-
                      Preflight simulation is unavailable right now; retry, or
                      send with skipPreflight=true.
              schema:
                $ref: '#/components/schemas/RelayErrorResponse'
          description: >-
            Too many transactions in flight across the relay, or preflight
            simulation is temporarily unavailable. Retry shortly (or send with
            `skipPreflight=true`).
      security:
        - apiKey: []
        - apiKeyQuery: []
components:
  schemas:
    SendTransactionRequest:
      additionalProperties: false
      properties:
        commitment:
          default: processed
          description: >-
            Commitment at which the transaction counts as landed (and re-sending
            stops). Also the commitment preflight simulates at.
          enum:
            - processed
            - confirmed
            - finalized
          type: string
        encoding:
          default: base64
          description: Encoding of `transaction`.
          enum:
            - base64
            - base58
          type: string
        maxRetries:
          default: 1
          description: >-
            Re-sends after the first send, ~400 ms apart, while it hasn't
            landed. Capped at 149.
          minimum: 0
          type: integer
        skipPreflight:
          default: false
          description: Skip simulating the transaction before sending it.
          type: boolean
        transaction:
          description: >-
            The fully signed transaction (legacy or v0), serialized and encoded
            as `encoding`.
          example: AQAAAA...base64...
          type: string
      required:
        - transaction
      type: object
    SendTransactionResponse:
      properties:
        signature:
          description: >-
            The transaction's first signature (base58). Returned as soon as the
            transaction is accepted, before it lands.
          example: >-
            5r5Zb67VfBe3cGp27z53XVcQbF7oTmf9N4q2WoqDxWL716mSq8uttuZeABVksZRQPa28fTfJvDYiDcCYN685bDRr
          type: string
      required:
        - signature
      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.