> ## Documentation Index > Fetch the complete documentation index at: https://docs.anthid.com/llms.txt > Use this file to discover all available pages before exploring further. # Get instrument > Returns a single instrument by this platform's id. The id is sufficient on its own - no asset class is required - and is stable across a venue renaming the symbol, which is why links and stored references use it rather than the symbol. ## OpenAPI ````yaml /api-reference/instruments.openapi.json get /v1/instruments/{instrument_id} openapi: 3.1.0 info: title: instruments description: '' license: name: '' version: 0.1.0 servers: - url: https://api.anthid.com description: Production security: [] tags: - name: Instruments description: Read the catalogue of instruments the platform can trade paths: /v1/instruments/{instrument_id}: get: tags: - Instruments summary: Get instrument description: >- Returns a single instrument by this platform's id. The id is sufficient on its own - no asset class is required - and is stable across a venue renaming the symbol, which is why links and stored references use it rather than the symbol. operationId: getInstrument parameters: - name: instrument_id in: path description: Instrument id required: true schema: type: string format: uuid example: 019eecb9-adaf-71d2-b439-f06a96a1c2d4 responses: '200': description: Instrument found content: application/json: schema: $ref: '#/components/schemas/InstrumentRecord' example: created_at: '2026-08-16T12:00:00Z' instrument: asset_class: PERPETUAL base: BTC funding: interval_seconds: 28800 multiplier: '1' quantity_increment: '1' quote: USD settlement: INVERSE symbol: XBTUSD tick_size: '0.5' underlying: CRYPTO venue: bitmex instrument_id: 019eecb9-adaf-71d2-b439-f06a96a1c2d4 last_seen_at: '2026-08-31T06:00:00Z' status: ACTIVE updated_at: '2026-08-16T12:00:00Z' '400': description: Instrument id is invalid content: text/plain: schema: type: string '401': description: Missing or invalid authentication credentials content: text/plain: schema: type: string '403': description: Caller cannot read instruments content: text/plain: schema: type: string '404': description: Instrument was not found content: text/plain: schema: type: string '429': description: Caller exceeded the request rate limit content: text/plain: schema: type: string '500': description: Unexpected server error while reading the instrument content: text/plain: schema: type: string security: - bearerAuth: [] - apiKeyAuth: [] components: schemas: InstrumentRecord: type: object description: >- One instrument as the catalogue holds it. The identity itself is [`Instrument`] from `rust_types`, unchanged - the same sum type the adapters and the order path work in, so a caller does not have to reassemble a futures contract from a bag of nullable fields to discover it has a multiplier. Everything outside `instrument` is catalogue bookkeeping rather than a property of the thing traded, which is why it sits beside it rather than inside it. required: - instrument_id - status - instrument - created_at - updated_at - last_seen_at properties: created_at: type: string format: date-time description: When the platform first learned of this instrument. instrument: $ref: '#/components/schemas/Instrument' description: |- What is traded, and the facts that make its price mean something. Tagged by `asset_class`, so a consumer reads the class once and gets only the fields that class actually has. instrument_id: type: string format: uuid description: >- This platform's id for the instrument. Stable across a venue renaming the symbol, which is why the API pages and links on it rather than on the symbol. last_seen_at: type: string format: date-time description: >- When a venue refresh last confirmed the instrument still exists. The staleness signal: a venue that stops listing a contract usually says nothing at all, so the only evidence is a row the sync stopped touching. status: $ref: '#/components/schemas/InstrumentStatus' updated_at: type: string format: date-time Instrument: oneOf: - allOf: - $ref: '#/components/schemas/Equity' - type: object required: - asset_class properties: asset_class: type: string enum: - EQUITY - allOf: - $ref: '#/components/schemas/Future' - type: object required: - asset_class properties: asset_class: type: string enum: - FUTURE - allOf: - $ref: '#/components/schemas/OptionInstrument' - type: object required: - asset_class properties: asset_class: type: string enum: - OPTION - allOf: - $ref: '#/components/schemas/Currency' - type: object required: - asset_class properties: asset_class: type: string enum: - CURRENCY - allOf: - $ref: '#/components/schemas/Crypto' - type: object required: - asset_class properties: asset_class: type: string enum: - CRYPTO - allOf: - $ref: '#/components/schemas/Perpetual' - type: object required: - asset_class properties: asset_class: type: string enum: - PERPETUAL - allOf: - $ref: '#/components/schemas/Prediction' - type: object required: - asset_class properties: asset_class: type: string enum: - PREDICTION description: >- A tradable instrument, with the facts that make its price mean something. Not `Copy` - every variant carries at least one venue-spelled string - and deliberately `Eq` and `Hash`, so it can key a position map and sit inside the order parameter types, which are hashed. InstrumentStatus: type: string description: >- Whether an instrument can be traded now. Rows are never deleted from the catalogue. A future that expired last quarter is still the instrument last quarter's fills refer to, so retirement is a status change and this is what carries it. enum: - ACTIVE - INACTIVE - EXPIRED - DELISTED Equity: type: object description: A share in a listed company. required: - symbol properties: exchange: type: - string - 'null' description: >- The primary listing venue, where it was resolved. Where the security *is listed*, which is a fact the instruments catalogue owns - not where an order on it is sent. That is [`OrderVenue`](crate::broker::order::order_venue::OrderVenue), it lives on the order, and the two differ constantly: an equity listed on one exchange is routable to several, and two orders on this instrument can name different destinations while this field says the same thing for both. Optional because an equity can be traded without the listing ever being resolved - the order carries its own destination - so most equities reach this type without one. symbol: type: string Future: type: object description: A dated futures contract. required: - symbol - root - exchange - expiration - tick_size - multiplier - currency properties: currency: type: string description: What a point is denominated in - `USD`. exchange: type: string description: >- The exchange, in that exchange's own spelling - `CME`, `CBOT`, `NYMEX`. A string rather than an enum because the set is open and every vendor spells it differently: Rithmic says `CME` where Databento says `GLBX.MDP3` for the same venue. An enum would have to pick one spelling and translate the rest, and this string goes back out on the order. expiration: type: string format: date-time description: |- Last trade, not settlement - the moment the contract stops being tradable, which is what an adapter needs to know before sending. multiplier: $ref: '#/components/schemas/Multiplier' description: Currency per full point of price movement - `50.0` for ES. root: type: string description: >- The contract family the month belongs to - `ES`. Held separately because it is what a strategy is actually expressed in. A position in "the ES front month" outlives any one `symbol`, and recovering the root by trimming characters off the end of a symbol is guesswork the venue already answered. symbol: type: string description: The venue's spelling of this contract month - `ESZ5`, or `ESZ25`. tick_size: $ref: '#/components/schemas/Price' OptionInstrument: type: object description: A listed option on an equity or an index. required: - symbol - underlying - expiration - strike - option_type - exercise_style - multiplier properties: exchange: type: - string - 'null' exercise_style: $ref: '#/components/schemas/ExerciseStyle' expiration: type: string format: date-time multiplier: $ref: '#/components/schemas/Multiplier' description: Shares per contract - `100.0` for a standard listed option. option_type: $ref: '#/components/schemas/OptionType' strike: $ref: '#/components/schemas/Price' symbol: type: string description: The OCC ticker. tick_size: oneOf: - type: 'null' - $ref: '#/components/schemas/Price' underlying: type: string Currency: type: object description: A currency pair. required: - symbol - base - quote properties: base: type: string description: The currency being bought or sold - `EUR`. quote: type: string description: The currency it is priced in - `USD`. symbol: type: string description: The pair as the venue spells it - `EURUSD`, or `EUR/USD`. Crypto: type: object description: >- Spot crypto: the asset itself, held outright. # Precision The type is not the constraint here, and this note exists to say so. [`Quantity`] holds eighteen decimal places, so a satoshi - `0.00000001` - has ten places to spare, and on-chain token amounts at their own native precision fit without rounding. Crypto is the asset class that used to make this worth reading: while the scale was six, a bitcoin size was silently rounded two places short of the asset's own divisibility, exact enough to order with and wrong for anything reconciling a balance. See [`SCALE`](crate::numeric::SCALE) for why that is no longer true of any value this crate carries. What does constrain a size is [`Self::quantity_increment`], which is the venue's own step and is data rather than a property of the type. A size that is exactly representable here can still be refused by the venue for being off the increment, so that field is the one to check against - not the width of the number. required: - symbol - base - quote - venue - price_increment - quantity_increment properties: base: type: string description: The asset being bought - `BTC`. price_increment: $ref: '#/components/schemas/Price' quantity_increment: $ref: '#/components/schemas/Quantity' description: >- The smallest size step the venue accepts. See the precision note above for what this type can and cannot express. quote: type: string description: The asset it is priced in - `USD`. symbol: type: string description: The venue's spelling - `BTC-USD` on Coinbase, `XXBTZUSD` on Kraken. venue: type: string Perpetual: type: object description: >- A perpetual contract: a derivative with no settlement date. It tracks its underlying without ever expiring, held in line by a funding payment exchanged between longs and shorts on a fixed schedule rather than by convergence to a settlement price. Two consequences matter more than the rest, and both are places where treating a perpetual as a future goes wrong quietly: 1. **There is no expiry.** [`Instrument::expiration`](super::Instrument::expiration) answers `None`, and that `None` means "never" rather than "unknown". Anything that rolls, ages or expires positions has to tell those apart. 2. **Settlement can invert the position.** See [`Settlement`]. Funding is carried as a schedule rather than a rate because the rate is market data that changes every interval, and an instrument identity that went stale every eight hours would be cached wrongly everywhere. What belongs here is *when* funding happens; what it costs belongs on a quote. required: - symbol - base - quote - venue - underlying - settlement - multiplier - funding - tick_size - quantity_increment properties: base: type: string funding: $ref: '#/components/schemas/FundingSchedule' multiplier: $ref: '#/components/schemas/Multiplier' description: >- Units of the underlying per contract. Read through [`Instrument::notional`](super::Instrument::notional). For an inverse contract this is an amount of the *quote* asset - one contract of `XBTUSD` is one dollar of bitcoin - which is why it cannot simply be multiplied through. quantity_increment: $ref: '#/components/schemas/Quantity' quote: type: string settlement: $ref: '#/components/schemas/Settlement' symbol: type: string description: The venue's spelling - `BTCUSDT`, `BTC-PERP`, `XBTUSD`. tick_size: $ref: '#/components/schemas/Price' underlying: $ref: '#/components/schemas/PerpetualUnderlying' description: >- What the contract tracks. Perpetuals started on crypto and did not stay there: the same structure now wraps equity indices and event outcomes, and the contract mechanics are identical in each. This says what the exposure actually is, so a risk check can ask what it is looking at without parsing a ticker. venue: type: string Prediction: type: object description: >- A binary event contract, settling at [`Self::payout`] or at nothing. The price is a probability rather than a value, which is what separates this from everything else here: a contract trading at `0.62` is the market saying sixty-two percent, and it pays `payout` if the event resolves true. Sizing it with a share-price formula produces a number with no meaning. required: - symbol - market - outcome - venue - payout - currency - tick_size properties: currency: type: string description: |- What the payout is denominated in - `USD` on Kalshi, `USDC` on Polymarket. expiration: type: - string - 'null' format: date-time description: >- When the event resolves, where the venue has published it. `None` for a market resolving on an event rather than a clock - "when the bill passes" has no date until it does. market: type: string description: >- The market this contract is one side of. Both sides of an event are separately tradable instruments with their own books, so the pair is only recoverable through this. outcome: $ref: '#/components/schemas/PredictionOutcome' description: Which side of the market this contract pays on. payout: $ref: '#/components/schemas/Price' description: >- What one contract pays if it resolves in its favour - `1.0` on Kalshi and Polymarket both. symbol: type: string description: >- The venue's identifier for this contract - a Kalshi market ticker, or a Polymarket token id. tick_size: $ref: '#/components/schemas/Price' venue: type: string Multiplier: type: string Price: type: string ExerciseStyle: type: string enum: - american - european OptionType: type: string enum: - call - put Quantity: type: string FundingSchedule: type: object description: >- How often a [`Perpetual`] exchanges funding. The schedule, not the rate - see the note on [`Perpetual`] for why the rate is deliberately absent. required: - interval_seconds properties: interval_seconds: type: integer format: int32 description: >- Seconds between funding exchanges. Eight hours on most venues, one hour on some, and a handful settle continuously. minimum: 0 Settlement: type: string description: >- Which asset a [`Perpetual`] pays out in. The difference is not bookkeeping. A linear contract is quoted and settled in the quote asset, so its value rises with price like anything else. An inverse contract is quoted in the quote asset and settled in the **base** one, which puts price in the denominator: the position is worth `multiplier * quantity / price`, and it is worth *less* as price rises. A venue commonly lists both against the same pair - `BTCUSDT` linear beside `XBTUSD` inverse - so the spelling is not a reliable guide and this field is the only thing that says which is which. enum: - LINEAR - INVERSE PerpetualUnderlying: type: string description: >- What a [`Perpetual`] is a perpetual *on*. The mechanics do not change between these; the exposure does, and so does which desk is allowed to hold it. enum: - UNSPECIFIED - CRYPTO - FUTURE - PREDICTION PredictionOutcome: type: string description: Which side of a prediction market a contract pays on. enum: - 'YES' - 'NO' securitySchemes: bearerAuth: type: http scheme: bearer bearerFormat: JWT apiKeyAuth: type: apiKey in: header name: x-api-key ````