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

# Reset a paper box

> POST /v1/ironbox/{id}/reset restores the starting balance and clears positions, orders and fills.

See the [Ironbox guide](https://docs.ironflow.sh/guides/ironbox.md) for the full flow.


## OpenAPI

````yaml POST /v1/ironbox/{id}/reset
openapi: 3.1.0
info:
  title: Ironflow API
  version: 1.0.0
  description: >
    Hyperliquid market data from Ironflow's own nodes: tick-level fills and

    trades, candles, funding rates, liquidations, mark prices, open interest,

    markets and wallet analytics over REST, live Server-Sent Events streams and

    read-only SQL. One schema across native HL perps, HIP-3 builder markets,

    HIP-4 outcome contracts and HL spot.


    The same data is a hosted MCP server for AI agents at

    `https://mcp.ironflow.sh/mcp`, and agents with a USDC wallet on Base can pay

    per call with x402, no key: the data GET endpoints are also served at

    `/x402/v1/...` (discovery: `https://api.ironflow.sh/openapi.json` and

    `https://api.ironflow.sh/.well-known/x402`).


    **Base URL:** `https://api.ironflow.sh`


    **Authentication:** Read endpoints work without a key (keyless access) or

    with a Bearer token in the `Authorization` header. Writes always need a key.

    ```

    Authorization: Bearer if_your_api_key

    ```

    Get a free key at https://ironflow.sh/key.


    **Access levels:**


    | Access | Requests per minute | History | Max range per request |

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

    | No key | 30 per IP (300 a day) | 24 hours | 1 hour |

    | Free key | 60 | 14 days | 6 hours |

    | Explorer | 100 | 90 days | 24 hours |

    | Builder | 1,000 | 1 year | 7 days |

    | Enterprise | 10,000 | full | unlimited |


    Without a market filter, high-volume endpoints allow at most 4 hours per
    request.

    `/v1/trades` filtered to one perp or spot market allows 24 hours per request

    without a key and on a free key.

    Each caller can also read a set number of rows per hour: 2 billion without a
    key,

    10 billion on a free key, 100 billion on Explorer, 500 billion on Builder,
    none set

    on Enterprise. REST and SQL count separately. Over it, REST answers 429

    `READ_BUDGET_EXCEEDED` until the next hour.

    A header that is present but malformed returns 401; keyless access applies
    only

    when no `Authorization` header is sent. The keyless 300 a day is a rolling
    24

    hours per IP: past it, `KEYLESS_DAILY_LIMIT` (429, or 402 with x402 payment

    terms) carries a `Retry-After` of the seconds until the next call is
    allowed.


    **Data availability:** fills and trades start on 25 May 2025; other

    datasets start later (funding 2025-09-27, open interest and mark prices

    2026-04-29). Bulk history is free to download from

    https://huggingface.co/ironflow.


    **Timestamps:** All timestamps are Unix milliseconds (int64).


    **Pagination:** Paginated endpoints return a `cursor` in
    `pagination.next_cursor`.

    Pass it as the `cursor` query parameter to fetch the next page.

    When `pagination.has_more` is `false`, you have reached the last page.


    **Notices:** a successful JSON object may start with `notice`, the

    `X-Ironflow-Notice` header in the body: what was served when it differs from

    what was asked (a keyless sample, a shortened history, a guessed path) and

    how to get the rest.


    **Guessed paths:** a few paths callers guess are answered by the endpoint

    they mean, with a `notice` and the `X-Ironflow-Canonical` header naming it:

    `/v1/liquidations/aggregate`, `/v1/summary/liquidations` and similar by

    `/v1/liquidations/summary`, `/v1/liquidations/buckets` and `heatmap` by

    `/v1/analytics/liquidation-levels`, and `/v1/liquidations/map/BTC-PERP` by

    `/v1/liquidations/map?market=BTC-PERP`. A path with trailing `.`, `,`, `;`
    or

    `)` (`/v1/query.`, copied from a sentence) is answered by the endpoint
    without

    them, with the same method, query and body. OpenAI-style paths
    (`/v1/models`,

    `/v1/chat/completions`) answer 404: this is not an LLM API, and agents use
    the

    MCP server above.
  contact:
    name: Ironflow Support
    url: https://ironflow.sh
servers:
  - url: https://api.ironflow.sh
    description: Production
security:
  - bearerAuth: []
  - {}
tags:
  - name: Hyperliquid RPC
    description: Your API key as a Hyperliquid /info URL, on your plan's limits.
  - name: Market Data
    description: Historical tick-level market data stored in ClickHouse.
  - name: Analytics
    description: >-
      Aggregated analytics. Net flows, funding stats and the liquidation map
      markets work without a key; liquidation levels, the liquidation map and
      the vault leaderboard return a sample without one; order flow needs a key
      (a free key works).
  - name: Cohorts
    description: Predefined and custom address groups for filtering market data.
  - name: Alerts
    description: >-
      Liquidation alerts that Ironflow posts to your webhook, Discord channel,
      Slack channel or Telegram chat.
  - name: Ironbox
    description: >-
      Secure, sandboxed environments in Tokyo, next to Hyperliquid, where a
      trading agent runs with Ironflow's data, analytics, alerts and execution.
      Any API key, free included.
  - name: Query
    description: >-
      Read-only ClickHouse SQL over curated Hyperliquid tables (hl.*), limited
      by tier.
  - name: Billing
    description: >-
      Paid plans, paid in USDC on Hyperliquid or with x402 on Base. No card, no
      account page.
  - name: System
    description: Health checks and metadata endpoints.
  - name: TradingApp
    description: >-
      The trading terminal's own endpoints (terminal.ironflow.sh),
      wallet-session auth. Not part of the public data API; left out of the docs
      copy.
paths:
  /v1/ironbox/{id}/reset:
    post:
      tags:
        - Ironbox
      summary: Reset a paper box
      description: >-
        Back to the starting balance with no positions, orders or fills. The
        wallet binding stays. Paper boxes only.
      operationId: resetIronbox
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
            pattern: ^ibx_[0-9a-f]{12}$
          example: ibx_3f9a0c7e12d4
      responses:
        '200':
          description: The box, reset.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Ironbox'
        '400':
          description: Not a paper box (`NOT_A_PAPER_BOX`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          $ref: '#/components/responses/IronboxKeyRequired'
        '404':
          description: No Ironbox with that id on this account.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '503':
          description: The paper engine is not reachable (`IRONBOX_UNAVAILABLE`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
      security:
        - bearerAuth: []
components:
  schemas:
    Ironbox:
      type: object
      required:
        - id
        - name
        - state
        - size
        - mode
        - runtime
        - markets
        - region
        - created_at
        - url
        - dashboard
        - message
      properties:
        id:
          type: string
          pattern: ^ibx_[0-9a-f]{12}$
          example: ibx_3f9a0c7e12d4
        name:
          type: string
          description: Empty when none was given.
          example: grid-bot
        state:
          type: string
          enum:
            - creating
            - running
            - stopped
            - deleted
            - error
        size:
          type: string
          enum:
            - small
            - medium
            - large
        mode:
          type: string
          enum:
            - paper
          description: Ironbox is paper only.
        runtime:
          type: string
          enum:
            - python
            - node
        markets:
          type: array
          items:
            type: string
            enum:
              - perps
              - outcomes
              - spot
        region:
          type: string
          enum:
            - tokyo
            - paper
        created_at:
          type: integer
          format: int64
          description: Unix milliseconds
        url:
          type: string
          format: uri
          description: GET it for the box's state; DELETE it to delete the box.
        dashboard:
          type: string
          format: uri
        message:
          type: string
          description: What the state means
          in one line.: null
        paper:
          type: boolean
          description: 'True for a paper box: your own simulated Hyperliquid account.'
        trial:
          type: boolean
          description: True on the answer that creates a keyless trial box.
        expires_at:
          type: integer
          format: int64
          description: >-
            When a trial box ends at the latest, Unix milliseconds. It ends
            sooner after 2 hours with no requests and no strategy running. Only
            on a keyless trial box.
        strategies_url:
          type: string
          format: uri
          description: Where to start strategies on this box. Shown only with base_url.
        activity_url:
          type: string
          format: uri
          description: Where to watch this box. Shown only with base_url.
        base_url:
          type: string
          format: uri
          description: >-
            Set `base_url` in the official Hyperliquid SDK to this. Shown only
            when the box is created or rotated. Treat it as a low-value secret.
          example: >-
            https://api.ironflow.sh/box/ibxs_1f2e3d4c5b6a7890123456789abcdef0123456789abcdef0123456789abcdef0
        snippet:
          type: string
          description: >-
            A first Python program for this box. Shown only when the box is
            created or rotated.
        starting_balance_usd:
          type: number
          description: Starting balance of a new paper box.
        stats:
          type: object
          description: >-
            A paper box's account, on GET. `as_of` is `live` or, if the engine
            cannot be reached, `snapshot`.
          required:
            - equity_usd
            - pnl_usd
            - fees_usd
            - funding_usd
            - positions
            - fill_count
            - data_gap_seconds
            - liquidated
            - as_of
          properties:
            equity_usd:
              type: number
            pnl_usd:
              type: number
            fees_usd:
              type: number
            funding_usd:
              type: number
              description: Net funding, negative when paid.
            positions:
              type: array
              items:
                type: object
                properties:
                  coin:
                    type: string
                  szi:
                    type: string
                  entry_px:
                    type: string
                  unrealized_pnl:
                    type: string
                  leverage:
                    type: integer
            fill_count:
              type: integer
            data_gap_seconds:
              type: integer
              description: Seconds the box held something on a market with no live data.
            liquidated:
              type: boolean
            as_of:
              type: string
              enum:
                - live
                - snapshot
      example:
        id: ibx_3f9a0c7e12d4
        name: grid-bot
        state: creating
        size: small
        mode: paper
        runtime: python
        markets:
          - perps
          - outcomes
        region: tokyo
        created_at: 1762520000000
        url: https://api.ironflow.sh/v1/ironbox/ibx_3f9a0c7e12d4
        dashboard: https://ironflow.sh/ironbox
        message: Your Ironbox is being set up. We email you when it is ready.
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              description: Machine-readable error code.
              example: RATE_LIMIT_EXCEEDED
            message:
              type: string
              description: Human-readable error description.
              example: Rate limit exceeded. Retry after 60 seconds.
            upgrade:
              type: object
              description: >-
                On a limit a higher plan lifts, the next plan, its price, what
                it lifts and the call that gets it.
              properties:
                plan:
                  type: string
                  example: explorer
                price_usdc:
                  type: number
                  example: 49
                days:
                  type: integer
                  example: 30
                unlocks:
                  type: string
                  description: >-
                    What the plan adds, starting with SQL export to Parquet or
                    CSV
                limit:
                  type: string
                  description: >-
                    The limit this error hit: rate, history, window, sql_budget,
                    read_budget, streams, alerts, keyless_day or tier
                  example: rate
                lifts:
                  type: string
                  description: What the plan changes about that limit
                  example: 60 requests a minute now, 100 on Explorer
                url:
                  type: string
                  format: uri
                  description: Where to upgrade; the link carries the plan and the limit
                how:
                  type: string
                  description: The API call that opens the upgrade request
                buy_url:
                  type: string
                  format: uri
                  description: Buy this plan in one x402 call (USDC on Base)
                  when x402 is on: null
                pay_per_call:
                  type: object
                  description: On limits one paid call lifts
                  how to pay for this call with x402: null
                offer:
                  type: string
                  description: Founding-member offer
                  while seats remain: null
            get_key:
              type: object
              description: >-
                On every keyless 429 (daily cap, per-minute rate, SQL and read
                budgets, stream cap) and keyless history refusal, the one call
                that gets a free key. `page` is the key page tagged with the
                refusal (utm_campaign).
              properties:
                method:
                  type: string
                  example: POST
                url:
                  type: string
                  format: uri
                  example: https://api.ironflow.sh/v1/keys
                body:
                  type: object
                  additionalProperties:
                    type: string
                  example:
                    email: you@example.com
                page:
                  type: string
                  format: uri
            dataset:
              type: object
              description: >-
                On `HISTORY_OUT_OF_RANGE`, and on a rate limit for a closed past
                range, the free download that holds the requested rows, when one
                does. The message repeats it with its dates.
              properties:
                name:
                  type: string
                  example: Hyperliquid Liquidations
                url:
                  type: string
                  format: uri
                  example: >-
                    https://huggingface.co/datasets/ironflow/hyperliquid-liquidations?utm_source=api
                holds:
                  type: string
                  example: every liquidation
                from:
                  type: string
                  format: date
                  example: '2025-05-25'
                through:
                  type: string
                  format: date
                  example: '2026-10-31'
            ironbox:
              type: object
              description: >-
                On a rate limit, the keyless daily cap, the stream limit, the
                SQL budget and the read budget, how to run the agent in an
                Ironbox instead.
              properties:
                why:
                  type: string
                  example: >-
                    No rate limits inside an Ironbox: your agent runs next to
                    Hyperliquid with the data on the box.
                create:
                  type: string
                  example: POST https://api.ironflow.sh/v1/ironbox
                url:
                  type: string
                  format: uri
                  example: https://ironflow.sh/ironbox?utm_source=api
            stream:
              type: string
              description: >-
                On the keyless daily limit, a per-minute rate limit, the read
                budget and a keyless history refusal of `/v1/liquidations` and
                `/v1/trades`, the live stream that replaces polling.
              example: >-
                GET https://api.ironflow.sh/v1/liquidations/stream (no daily
                limit for keyless streams)
            allowed_from:
              type: integer
              format: int64
              description: >-
                On `HISTORY_OUT_OF_RANGE`, the earliest `from` (Unix ms; `at` on
                `/v1/positions`) the caller's history reaches; a request from
                there is served.
              example: 1794394800000
            did_you_mean:
              type: array
              items:
                type: string
              description: >-
                On an unknown market (the liquidation map, the order book), the
                markets the name most likely meant. The message repeats them.
              example:
                - xyz:GOLD-PERP
                - PAXG-PERP
  responses:
    IronboxKeyRequired:
      description: No API key. Any key works, a free one included.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error:
              code: UNAUTHORIZED
              message: >-
                this request needs an API key. Free keys:
                https://ironflow.sh/key?utm_source=api, or POST
                https://api.ironflow.sh/v1/keys with {"email":
                "you@example.com"} (the key is emailed to that address, never
                returned, so a person has to open the email)
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Ironflow API key, format `if_xxxx`. Free keys at
        https://ironflow.sh/key. Optional on read endpoints.

````

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