Public Methods

Client Initialization

Public methods require nothing beyond the host URL. No signer, no credentials.

use openfish_client_sdk::clob::{Client, Config};

let client = Client::new("https://api.openfish.me", Config::default())?;

// Or use the default:
let client = Client::default(); // https://api.openfish.me

Health Check

ok

Confirm that the CLOB service is running.

let ok = client.ok().await?;
println!("Service status: {ok}");

REST: GET /

Server Time

server_time

Returns the server’s current Unix timestamp in seconds.

let time = client.server_time().await?;
println!("Server time: {time}");

REST: GET /time

Markets

market

Fetch details for a single market by condition ID.

let market = client.market("CONDITION_ID").await?;
println!("Question: {}", market.question);
println!("Tick size: {}", market.minimum_tick_size);
println!("Tokens: {:?}", market.tokens);

REST: GET /market?condition_id=CONDITION_ID

Key response fields:

Field	Type	Description
`condition_id`	string	Unique market identifier
`question`	string	Market question text
`minimum_tick_size`	number	Minimum price increment
`neg_risk`	boolean	Whether multi-outcome (neg risk)
`tokens`	array	Outcome tokens with `outcome`, `price`, `token_id`, `winner`
`accepting_orders`	boolean	Whether the market accepts orders
`taker_base_fee`	number	Taker fee in basis points

markets

Retrieve multiple markets with pagination support. Returns 100 markets per page. This endpoint has no search or filter parameters. To find markets by keyword, use GET /browse/markets?search=... instead.

let page = client.markets().await?;
println!("{} markets (limit {})", page.count, page.limit);
for market in &page.data {
    println!("  {}: {}", market.condition_id, market.question);
}

REST: GET /markets

simplified_markets

A lighter response format optimized for faster loading. Returns only core fields: accepting_orders, active, condition_id, tokens, and rewards.

let page = client.simplified_markets().await?;

REST: GET /simplified-markets

sampling_markets / sampling_simplified_markets

Markets that qualify for liquidity rewards.

let page = client.sampling_markets().await?;
let simplified = client.sampling_simplified_markets().await?;

REST: GET /sampling-markets, GET /sampling-simplified-markets

Orderbooks and Prices

order_book

Complete orderbook for a token.

use openfish_client_sdk::clob::types::request::OrderBookSummaryRequest;

let request = OrderBookSummaryRequest::builder()
    .token_id("TOKEN_ID".parse()?)
    .build();
let book = client.order_book(&request).await?;
println!("Bids: {:?}, Asks: {:?}", book.bids, book.asks);

REST: GET /book?token_id=TOKEN_ID

price

Best available price for a given side.

use openfish_client_sdk::clob::types::{Side, request::PriceRequest};

let request = PriceRequest::builder()
    .token_id("TOKEN_ID".parse()?)
    .side(Side::Buy)
    .build();
let price = client.price(&request).await?;
println!("Best ask: {}", price.price);

REST: GET /price?token_id=TOKEN_ID&side=BUY

midpoint

Mean of best bid and best ask.

use openfish_client_sdk::clob::types::request::MidpointRequest;

let request = MidpointRequest::builder()
    .token_id("TOKEN_ID".parse()?)
    .build();
let mid = client.midpoint(&request).await?;
println!("Midpoint: {}", mid.mid);

REST: GET /midpoint?token_id=TOKEN_ID

spread

Gap between best ask and best bid.

use openfish_client_sdk::clob::types::request::SpreadRequest;

let request = SpreadRequest::builder()
    .token_id("TOKEN_ID".parse()?)
    .build();
let spread = client.spread(&request).await?;
println!("Spread: {}", spread.spread);

REST: GET /spread?token_id=TOKEN_ID

last_trade_price

Most recent execution price and trade direction for a token.

use openfish_client_sdk::clob::types::request::LastTradePriceRequest;

let request = LastTradePriceRequest::builder()
    .token_id("TOKEN_ID".parse()?)
    .build();
let last = client.last_trade_price(&request).await?;
println!("Last: {} ({})", last.price, last.side);

REST: GET /last-trade-price?token_id=TOKEN_ID

Batch Methods

Every orderbook query has a batch counterpart that accepts arrays of token parameters.

Single	Batch	REST
`order_book()`	`order_books()`	`POST /books`
`price()`	`prices()`	`POST /prices`
`midpoint()`	`midpoints()`	`POST /midpoints`
`spread()`	`spreads()`	`POST /spreads`
`last_trade_price()`	`last_trades_prices()`	`POST /last-trades-prices`

use openfish_client_sdk::clob::types::{Side, request::PriceRequest};

let requests = vec![
    PriceRequest::builder().token_id("TOKEN_A".parse()?).side(Side::Buy).build(),
    PriceRequest::builder().token_id("TOKEN_B".parse()?).side(Side::Buy).build(),
];
let prices = client.prices(&requests).await?;

Market Parameters

fee_rate_bps

Fee rate in basis points for a token.

let fee = client.fee_rate_bps("TOKEN_ID".parse()?).await?;

REST: GET /fee-rate?token_id=TOKEN_ID

tick_size

Minimum price increment for a market.

let tick = client.tick_size("TOKEN_ID".parse()?).await?;

REST: GET /tick-size?token_id=TOKEN_ID

neg_risk

Whether a market uses negative risk (multi-outcome).

let is_neg = client.neg_risk("TOKEN_ID".parse()?).await?;

REST: GET /neg-risk?token_id=TOKEN_ID