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

# REST API

> Every REST namespace and method exposed by StructClient.

Every `StructClient` instance exposes 11 namespaces, each a thin wrapper around a group of REST endpoints. Methods share the same shape:

```typescript theme={null}
await client.{namespace}.{method}(params?): Promise<HttpResponse<T>>
```

* `params` is a typed object matching the endpoint's query and path params.
* The return value is wrapped in an `HttpResponse<T>` envelope.

## Response envelope

```typescript theme={null}
interface HttpResponse<T> {
  data: T;
  message: string | null;
  success: boolean;
  info?: {
    version: string;
    credits_consumed: number;
  };
  pagination?: {
    has_more: boolean;
    pagination_key: string | number | null;
  };
}
```

All parameter and response types are re-exported from the package root. Pull them in with `import type { GetMarketsParams, MarketResponse } from "@structbuild/sdk"`.

## Markets

```typescript theme={null}
client.markets.getMarkets(params?): HttpResponse<MarketResponse[]>
client.markets.getMarket({ conditionId }): HttpResponse<MarketResponse>
client.markets.getMarketBySlug({ marketSlug }): HttpResponse<MarketResponse>
client.markets.getMarketChart(params): HttpResponse<PositionChartOutcome[]>
client.markets.getMarketMetrics(params): HttpResponse<ConditionMetricsResponse>
client.markets.getMarketVolumeChart(params): HttpResponse<MarketVolumeDataPoint[]>
client.markets.getTrades(params?): HttpResponse<Trade[]>
client.markets.getCandlestick(params): HttpResponse<CandlestickResponse>
client.markets.getPositionCandlestick(params): HttpResponse<CandlestickResponse>
client.markets.getPositionMetrics(params): HttpResponse<PositionMetricsResponse>
client.markets.getPositionVolumeChart(params): HttpResponse<PositionVolumeDataPoint[]>
client.markets.getPriceJumps(params?): HttpResponse<PriceJump[]>
```

```typescript theme={null}
const { data: markets } = await client.markets.getMarkets({ limit: 10, tags: "politics" });

const { data: market } = await client.markets.getMarket({
  conditionId: "0xabc...",
});

const { data: candles } = await client.markets.getCandlestick({
  condition_id: "0xabc...",
  resolution: "1h",
});
```

Trade responses return a discriminated union. See [Trade Types](/sdk/trade-types) for how to narrow on `trade_type`.

## Events

```typescript theme={null}
client.events.getEvents(params?): HttpResponse<Event[]>
client.events.getEvent({ identifier }): HttpResponse<Event>
client.events.getEventBySlug({ slug }): HttpResponse<Event>
client.events.getEventChart(params): HttpResponse<EventMarketChartOutcome[]>
client.events.getEventMetrics(params): HttpResponse<EventMetricsResponse>
client.events.getEventOutcomes(params): HttpResponse<Record<string, string>>
```

```typescript theme={null}
const { data: event } = await client.events.getEventBySlug({ slug: "us-election-2028" });

const { data: metrics } = await client.events.getEventMetrics({
  event_slug: "us-election-2028",
  timeframe: "24h",
});
```

## Trader

```typescript theme={null}
client.trader.getTraderTrades(params): HttpResponse<Trade[]>
client.trader.getTraderProfile({ address }): HttpResponse<UserProfile>
client.trader.getTraderProfilesBatch({ addresses }): HttpResponse<UserProfile[]>
client.trader.getTraderVolumeChart(params): HttpResponse<TraderVolumeDataPoint[]>
client.trader.getTraderPnl(params): HttpResponse<TraderPnlSummary>
client.trader.getTraderMarketPnl(params): HttpResponse<TraderMarketPnlEntry[]>
client.trader.getTraderEventPnl(params): HttpResponse<TraderEventPnlEntry[]>
client.trader.getTraderOutcomePnl(params): HttpResponse<TraderOutcomePnlEntry[]>
client.trader.getTraderPnlCandles(params): HttpResponse<PnlCandleEntry[]>
client.trader.getTraderPnlCalendar(params): HttpResponse<PnlCandleEntry[]>
client.trader.getGlobalPnl(params?): HttpResponse<GlobalPnlTrader[]>
client.trader.getLeaderboard(params?): HttpResponse<LeaderboardEntry[]>
```

```typescript theme={null}
const { data: profile } = await client.trader.getTraderProfile({
  address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
});

const { data: pnl } = await client.trader.getTraderPnl({
  address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
});

const { data: globalPnl } = await client.trader.getGlobalPnl({ limit: 100 });

const { data: leaderboard } = await client.trader.getLeaderboard({
  timeframe: "7d",
  sort_by: "pnl",
  category: "crypto",
  limit: 50,
});
```

## Holders

```typescript theme={null}
client.holders.getMarketHolders(params): HttpResponse<MarketHoldersResponse>
client.holders.getPositionHolders({ positionId }): HttpResponse<PositionHoldersResponse>
client.holders.getMarketHoldersHistory(params): HttpResponse<HolderHistoryCandle[]>
client.holders.getPositionHoldersHistory({ positionId }): HttpResponse<HolderHistoryCandle[]>
```

```typescript theme={null}
const { data: holders } = await client.holders.getMarketHolders({
  condition_id: "0xabc...",
});
```

## Order Book

```typescript theme={null}
client.orderBook.getOrderBook({ position_id }): HttpResponse<unknown>
client.orderBook.getOrderBookHistory(params?): HttpResponse<unknown>
client.orderBook.getMarketOrderBook(params?): HttpResponse<unknown>
client.orderBook.getSpreadHistory(params?): HttpResponse<unknown>
```

```typescript theme={null}
const { data } = await client.orderBook.getOrderBook({ position_id: "0xabc..." });
```

## Series

```typescript theme={null}
client.series.getSeriesList(params?): HttpResponse<Series[]>
client.series.getSeriesOutcomes({ series_slug }): HttpResponse<Record<string, string>>
client.series.getSeriesEvents(params): HttpResponse<Event[]>
```

## Assets

```typescript theme={null}
client.assets.getAssetHistory(params): HttpResponse<AssetPriceHistoryRow[]>
```

```typescript theme={null}
const { data } = await client.assets.getAssetHistory({
  asset_symbol: "BTC",
  variant: "1d",
});
```

## Tags

```typescript theme={null}
client.tags.getTags(params?): HttpResponse<Tag[]>
client.tags.getTag({ identifier }): HttpResponse<Tag>
```

## Bonds

```typescript theme={null}
client.bonds.getBonds(params?): HttpResponse<BondMarket[]>
```

## Search

```typescript theme={null}
client.search.search({ q }): HttpResponse<SearchResponse>
```

```typescript theme={null}
const { data: results } = await client.search.search({
  q: "bitcoin",
  limit: 25,
});
```

## Webhooks

```typescript theme={null}
client.webhooks.list(params?): HttpResponse<WebhookListResponseBody>
client.webhooks.create(body): HttpResponse<WebhookResponse>
client.webhooks.getWebhook({ webhookId }): HttpResponse<WebhookResponse>
client.webhooks.update(params): HttpResponse<WebhookResponse>
client.webhooks.deleteWebhook({ webhookId }): HttpResponse<DeleteWebhookResponse>
client.webhooks.test({ webhookId }): HttpResponse<WebhookTestResponseBody>
client.webhooks.rotateSecret({ webhookId }): HttpResponse<RotateSecretResponse>
client.webhooks.listEvents(): HttpResponse<ListEventsResponse>
```

See [Managing Webhooks](/sdk/webhooks) for full examples, filter options, and how to verify delivery signatures.