List Markets

The TradeMire Platform API

v1 · Initial release · Apr 2026

One signed REST API covering the entire TradeMire platform: public market data (markets, assets, exchanges, chains, macro indicators) and your private vaults, strategies, nodes, and orders - all authenticated with HMAC-SHA256 and paginated throughout.

Base URL https://trademire.ai/api/v1

Path prefix /v1/{apiKey}

Version v1

Auth HMAC-SHA256

Rate limit Varies per endpoint

SDK @trademire/platform-api

GETTING STARTED QUICK START

Quick Start

Three steps to your first signed call: install the SDK, set your credentials, and call markets.list().

1 - Install the SDK

npm install @trademire/platform-api

2 - Configure the client

import { PlatformApiClient } from "@trademire/platform-api";

let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,   // only required for private endpoints
});

3 - Make your first call

let res = await client.markets.list({ pagination: { page: 1, limit: 10 } });

if (!res.success) {
  console.error("Auth or upstream failure:", res.message);
} else {
  for (let m of res.items) {
    console.log(m.pair, m.lastPrice, m.priceQuote);
  }
}

The SDK signs each request, attaches the required headers, and parses the JSON response - you never touch the signing primitives. To call the API without the SDK (cURL, custom HTTP clients, other languages), see Authentication below for the manual signing recipe.

GETTING STARTED AUTHENTICATION

Authentication

Every Platform API request is signed with HMAC-SHA256 over the raw JSON request body. Three auth headers travel with each request: an API key, the signature, and a timestamp valid for 5 minutes. Public endpoints need only these three; private endpoints additionally require a poolKey in the body to scope the call to your pool.

Each endpoint declares an HTTP method: GET for body-less reads, POST for body-carrying queries (list, search, OHLC), and PUT for state-changing writes (set runtime profile, lifecycle actions). The SDK signs and dispatches the documented method automatically; raw HTTP callers must use the verb declared on each endpoint.

What gets signed

// Generate HMAC-SHA256 signature from the raw request body as lowercase hex
signature = HMAC_SHA256(apiSecret, requestBody).toHex()

Only the raw JSON body is signed. Path, {apiKey}, query string, and timestamp are not part of the signed payload. The body must be byte-identical to what you transmit - serialize once, sign that exact string, and send it as the request body.

When you build the body, sort object keys in ascending alphabetical order (canonical JSON). Arrays keep their declared order and undefined values are dropped. The SDK applies this automatically; manual signers must match it byte for byte or the signature will not verify.

Required headers

Name	Required	Description
`Content-Type`	required	Must be `application/json`.
`X-API-Key`	required	Public identifier of the API key issued from the platform dashboard. Never share the matching secret.
`X-API-Signature`	required	Lowercase hex-encoded HMAC-SHA256 of the raw request body, computed with the API secret as key.
`X-API-Timestamp`	required	Request creation time in Unix epoch milliseconds. Server rejects timestamps outside a 5-minute drift window (replay protection).

Request URL

Every endpoint follows the same shape:

POST /:path

Every endpoint sits under /v1/{apiKey}. The {apiKey} path component is your public API key (the same value sent in the X-API-Key header) and is not part of the signed payload.

Signing the request

Compute the HMAC over the exact byte sequence of the body you transmit. Pick your language:

import crypto from "crypto";

// 1. Build the request body and per-request metadata
let apiKey = process.env.API_KEY;
let body = JSON.stringify({ pagination: { page: 1, limit: 50 } });
let timestamp = Date.now().toString();

// 2. Sign the raw body with HMAC-SHA256 using your API secret
let signature = crypto
  .createHmac("sha256", process.env.API_SECRET)
  .update(body)
  .digest("hex");

// 3. Send the signed request with all four required auth headers
let res = await fetch(`https://trademire.ai/api/v1/${apiKey}/markets/list`, {
  method: "POST",
  headers: {
    "Content-Type":    "application/json",
    "X-API-Key":       apiKey,
    "X-API-Signature": signature,
    "X-API-Timestamp": timestamp,
  },
  body,
});

BODY='{"pagination":{"page":1,"limit":50}}'
TS=$(date +%s%3N)
SIG=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "$API_SECRET" -hex | awk '{print $2}')
curl -X POST "https://trademire.ai/api/v1/$API_KEY/markets/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data "$BODY"

Public vs Private endpoints

Scope	HMAC headers	Body shape	Examples
PUBLIC	required	No `poolKey`; only listing/filter/sort/pagination fields.	`/markets/list`, `/asset/:symbol`, `/exchanges/list`, `/chains/list`, `/macro/types`
PRIVATE	required	Must include `poolKey` to scope to your pool. The SDK auto-fills it from `config.poolKey` when you do not pass one explicitly.	`/vaults/list`, `/strategies/list`, `/orders/list`, `/trades/list`

Auth failure behaviour

For any authentication failure - missing header, malformed signature, expired timestamp, suspended key, blocked IP, or unauthorized category - the server returns the same generic MessageAccessForbidden response. The specific reason is intentionally not surfaced to the caller (prevents credential enumeration and oracle attacks). Inspect your local request before retrying:

Is the body byte-identical to the string you signed? Re-serialize whitespace and key order can both break the hash.
Is your local clock within 5 minutes of UTC? X-API-Timestamp is in milliseconds, not seconds.
Did you sign with the API secret (not the API key)?
Is the signature lowercase hex (0-9a-f)?
Is your IP in your key's allowlist (if you configured one in the dashboard)?

GETTING STARTED ERRORS

Errors

These error codes apply to every endpoint. Each error response carries a rayId you can quote when contacting support.

Code	Description
`MessageAccessForbidden`	Returned for any authentication failure.
`MessageMissingParameter`	A required URL parameter (e.g. :pair on per-market endpoints) is absent, malformed, or fails the alphanumeric / length validation.
`MessageRateLimitExceeded`	Per-key rate limit for this endpoint has been exceeded. Inspect the Retry-After response header before retrying.
`MessageInternalError`	An unexpected internal error occurred. The response includes a rayId you can quote when contacting support.

PUBLIC MARKETS

List Markets

Returns the canonical lean listing of every market currently tracked by the platform. Each entry carries the latest aggregated price across venues, the quote currency the price is denominated in, and a flag indicating whether the market is active. Use the body to apply filtering, sorting, and pagination - per-pair detail (full ticker, listing, limit, profile, OHLC) lives on the sharded /market/:pair/* endpoints.

POST /markets/list

Auth HMAC-SHA256 Rate limit 15 req/min Pagination Content application/json

Body Parameters

Name	In	Type	Required	Description
REQUEST BODY
`filtering`	body	object	optional	List filter object: { search?: string, where?: { field, op, value }[] }. Search is matched against the pair, base symbol, and quote symbol fields.
`sorting`	body	object	optional	Sort object: { field, direction }. Common fields are pair, lastPrice, and isActive. Direction is asc or desc.
`pagination`	body	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is 10-100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Response Schema

items[]

Field	Type	Description
`pair`	string	Canonical market pair key in BASE_QUOTE form (e.g. BTC_USDT).
`baseSymbol`	string	Base asset symbol of the market.
`quoteSymbol`	string	Quote asset symbol of the market.
`isActive`	boolean	Whether the market is currently active and trading on at least one tracked venue.
`lastPrice`	number	Latest aggregated price across venues, denominated in priceQuote.
`priceQuote`	string	Quote currency the lastPrice is denominated in (typically USDT or USD).

pagination

Field	Type	Description
`currentPage`	integer	1-based index of the page returned by this response.
`totalPages`	integer	Total number of pages available for the current filter and limit.
`pageSize`	integer	Effective page size applied by the server (may be lower than the requested limit).
`totalRows`	integer	Total number of rows matching the filter across all pages.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "pair": "BTC_USDT",
      "baseSymbol": "BTC",
      "quoteSymbol": "USDT",
      "isActive": true,
      "lastPrice": 64803.7,
      "priceQuote": "USDT"
    },
    {
      "pair": "ETH_USDT",
      "baseSymbol": "ETH",
      "quoteSymbol": "USDT",
      "isActive": true,
      "lastPrice": 3421.18,
      "priceQuote": "USDT"
    }
  ],
  "pagination": {
    "currentPage": 1,
    "totalPages": 5,
    "pageSize": 50,
    "totalRows": 247
  }
}

PUBLIC MARKETS

Get Market Ticker

Returns the live ticker shape for a single trading pair: last price, 24h high/low, change, bid/ask with sizes, and base/quote volume.

GET /market/:pair/ticker

Auth HMAC-SHA256 Rate limit 60 req/min URL param :pair

URL parameters

Name	Required	Description
`pair`	required	Canonical pair key in BASE_QUOTE form (e.g. BTC_USDT). Alphanumeric, underscore and dash only, max 64 chars.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/market/BTC_USDT/ticker" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.markets.getTicker("BTC_USDT");

// 3. Inspect the parsed response
console.log(res);

Response schema

ticker

Field	Type	Description
`isActive`	boolean	Whether the market is active on the venue.
`apiTrading`	boolean	Whether API trading is enabled.
`lastPrice`	number	Last traded price.
`highPrice24h`	number	Highest trade price in the last 24 hours.
`lowPrice24h`	number	Lowest trade price in the last 24 hours.
`change`	number	Absolute price change over 24h (in quote currency).
`bidPrice`	number	Current best bid price.
`askPrice`	number	Current best ask price.
`bidQuantity`	number	Quantity available at the best bid.
`askQuantity`	number	Quantity available at the best ask.
`volume`	number	24h base-currency volume.
`quoteVolume`	number	24h quote-currency volume.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "isActive": true,
    "apiTrading": true,
    "lastPrice": 67234.5,
    "highPrice24h": 68500,
    "lowPrice24h": 66800,
    "change": 1.23,
    "bidPrice": 67230,
    "askPrice": 67235,
    "bidQuantity": 0.5,
    "askQuantity": 0.3,
    "volume": 12500.5,
    "quoteVolume": 845000000
  }
}

PUBLIC MARKETS

Ticker per Exchange

Returns ticker data for the same trading pair broken out across every venue that lists it - useful for arbitrage, trust-score checks, and routing decisions.

GET /market/ticker/:pair/exchanges

Auth HMAC-SHA256 Rate limit 60 req/min Returns listing Pagination

URL parameters

Name	Required	Description
`pair`	required	Canonical pair key (BASE_QUOTE).

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/market/ticker/BTC_USDT/exchanges" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.markets.getTickerExchanges("BTC_USDT");

// 3. Inspect the parsed response
console.log(res);

Response schema

items[]

Each item shares the ticker shape from Get Market Ticker, with the venue identifier surfaced via the exchangeKey field.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "isActive": true,
      "apiTrading": true,
      "lastPrice": 67234.5,
      "highPrice24h": 68500,
      "lowPrice24h": 66800,
      "change": 1.23,
      "bidPrice": 67230,
      "askPrice": 67235,
      "bidQuantity": 0.5,
      "askQuantity": 0.3,
      "volume": 12500.5,
      "quoteVolume": 845000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC MARKETS

Get Market Listing

Returns the listing-availability shape for a single market - a compact set of flags describing whether the pair is listed, active, openly tradable, and whether margin trading is supported.

GET /market/:pair/listing

Auth HMAC-SHA256 Rate limit 60 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/market/BTC_USDT/listing" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.markets.getListing("BTC_USDT");

// 3. Inspect the parsed response
console.log(res);

Response schema

listing

Field	Type	Description
`baseSymbol`	string	Base asset symbol.
`quoteSymbol`	string	Quote asset symbol.
`isListed`	boolean	Whether the market is currently listed.
`isActive`	boolean	Whether the market is currently active.
`openTrading`	boolean	Whether trading is open at all.
`openApiTrading`	boolean	Whether API trading is open.
`hasMarginTrading`	boolean	Whether margin trading is supported.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "baseSymbol": "BTC",
    "quoteSymbol": "USDT",
    "isListed": true,
    "isActive": true,
    "openTrading": true,
    "openApiTrading": true,
    "hasMarginTrading": false
  }
}

PUBLIC MARKETS

Get Market Limit

Returns the sanitized trading limits and fees for a single market: precision, price/quantity bounds, tick sizes, notional bounds, and maker/taker fee rates.

GET /market/:pair/limit

Auth HMAC-SHA256 Rate limit 60 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/market/BTC_USDT/limit" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.markets.getLimit("BTC_USDT");

// 3. Inspect the parsed response
console.log(res);

Response schema

limit

Field	Type	Description
`basePrecision`	number	Base asset decimal precision.
`quotePrecision`	number	Quote asset decimal precision.
`priceMin` / `priceMax` / `priceTick`	number	Price bounds and tick size.
`quantityMin` / `quantityMax` / `quantityTick`	number	Quantity bounds and tick size.
`totalMin` / `totalMax`	number	Notional value bounds.
`feeMaker` / `feeTaker`	number	Maker / taker fee rates.
`feeIsTiered`	boolean	Whether fees are tiered by 30d volume.
`maxNumOrders`	number	Maximum number of open orders allowed.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "basePrecision": 8,
    "quotePrecision": 2,
    "priceMin": 0.01,
    "priceMax": 1000000,
    "priceTick": 0.01,
    "quantityMin": 0.00001,
    "quantityMax": 9000,
    "quantityTick": 0.00001,
    "totalMin": 5,
    "totalMax": 9000000,
    "feeMaker": 0.001,
    "feeTaker": 0.001,
    "feeIsTiered": true,
    "maxNumOrders": 200
  }
}

PUBLIC MARKETS

Get Market Profile

Returns the market profile shape: tags plus the same listing/activity metadata as Get Market Listing. Use this when you want descriptive metadata alongside availability flags in a single call.

GET /market/:pair/profile

Auth HMAC-SHA256 Rate limit 60 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/market/BTC_USDT/profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.markets.getProfile("BTC_USDT");

// 3. Inspect the parsed response
console.log(res);

Response schema

profile

Field	Type	Description
`baseSymbol` / `quoteSymbol`	string	Base / quote asset symbols.
`isListed` / `isActive`	boolean	Whether the market is listed and active.
`openTrading` / `openApiTrading`	boolean	Whether trading and API trading are open.
`hasMarginTrading`	boolean	Whether margin trading is supported.
`tags`	array	Array of tag keys associated with the market.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "baseSymbol": "BTC",
    "quoteSymbol": "USDT",
    "isListed": true,
    "isActive": true,
    "openTrading": true,
    "openApiTrading": true,
    "hasMarginTrading": false,
    "tags": [
      "spot",
      "major"
    ]
  }
}

PUBLIC MARKETS

Get Market OHLC

Returns OHLC candle series for a single market. Defaults to aggLast (last-trade) candles, with aggVol available for volume candles. Timeframe and time range are passed in the body.

POST /market/:pair/ohlc

Auth HMAC-SHA256 Rate limit 20 req/min

Body parameters

Name	Type	Required	Description
`field`	string	optional	One of `aggLast` (default) or `aggVol`.
`timeframe`	string	optional	SnapshotManager sampler key (`hour`, `day`, `week`, ...).
`tOldest`	integer	optional	Oldest bin time, ms epoch (inclusive).
`tNewest`	integer	optional	Newest bin time, ms epoch (inclusive).

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/market/BTC_USDT/ohlc" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"timeframe":"day"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.markets.getOhlc("BTC_USDT", { timeframe: "day" });

// 3. Inspect the parsed response
console.log(res);

Response schema

ohlc

Field	Type	Description
`field`	string	Snapshotted field that drove the bins.
`timeframe`	string	Sampler key used to bucket the series.
`series`	array	Sorted bins: `{ tOpen, tClose, open, high, low, close, volume }`.
`summary`	object	Aggregate change summary over the requested window.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "field": "aggLast",
    "timeframe": "hour",
    "series": [
      {
        "tOpen": 1700000000000,
        "tClose": 1700003600000,
        "open": 67200,
        "high": 67800,
        "low": 67000,
        "close": 67500
      }
    ],
    "summary": {
      "open": 67000,
      "high": 68500,
      "low": 66800,
      "close": 67500,
      "change": 0.75
    }
  }
}

PUBLIC MARKETS

Markets Help Map

Returns a structured JSON map of every endpoint in the Markets category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /markets/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/markets/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.markets.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "markets",
  "help": {
    "paths": {
      "/markets/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PUBLIC ASSETS

List Assets

Canonical lean listing of every asset tracked by the platform - last aggregated price, asset type, and listing status. Filtering, sorting, and pagination are supported.

POST /assets/list

Auth HMAC-SHA256 Rate limit 15 req/min Pagination

Body parameters

Same shape as List Markets: filtering, sorting, pagination. Search matches the asset symbol and name fields.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/assets/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.assets.list({ pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

items[]

Field	Type	Description
`assetType`	string	Asset classification (e.g. crypto, stable, fiat).
`isListed`	boolean	Whether the asset is currently listed.
`lastPrice`	number	Latest aggregated price.
`priceQuote`	string	Quote currency the price is denominated in.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "assetType": "crypto",
      "isListed": true,
      "lastPrice": 67234.5,
      "priceQuote": "USDT"
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC ASSETS

Get Asset

Returns a single asset with price, 24h volume, change, dominance, aggregated limits, and per-network chain limits keyed by network identifier.

GET /asset/:symbol

Auth HMAC-SHA256 Rate limit 60 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/asset/BTC" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.assets.get("BTC");

// 3. Inspect the parsed response
console.log(res);

Response schema

asset

Field	Type	Description
`assetType` / `isListed`	string / bool	Type and listing flag.
`lastPrice` / `priceQuote`	number / string	Latest aggregated price and its quote currency.
`volume24h` / `change24h` / `dominance`	number	24h volume, percent change, and market dominance share.
`limits`	object	Aggregated limits: `precision`, `orderMin/Max`, `depositMin/Max`, `withdrawalMin/Max`.
`chains[":network"]`	object	Per-network limits: `depositEnabled`, `withdrawEnabled`, `withdrawFee`, `withdrawMin/Max`, `depositMin`, `confirmations`, `isDefault`.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "assetType": "crypto",
    "isListed": true,
    "lastPrice": 67234.5,
    "priceQuote": "USDT",
    "volume24h": 12500.5,
    "change24h": 1.23,
    "dominance": 52.4,
    "limits": {
      "precision": 8,
      "orderMin": 0.00001,
      "orderMax": 9000,
      "depositMin": 0.0001,
      "depositMax": 1000000,
      "withdrawalMin": 0.0005,
      "withdrawalMax": 100
    },
    "chains": {
      "ETH": {
        "depositEnabled": true,
        "withdrawEnabled": true,
        "withdrawFee": 0.0005,
        "withdrawMin": 0.001,
        "withdrawMax": 100,
        "depositMin": 0.0001,
        "confirmations": 12,
        "isDefault": true
      }
    }
  }
}

PUBLIC ASSETS

Get Asset Profile

Returns descriptive profile metadata for a single asset: description, supply figures, social/web URLs, tag keys, and rating entries.

GET /asset/:symbol/profile

Auth HMAC-SHA256 Rate limit 60 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/asset/BTC/profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.assets.getProfile("BTC");

// 3. Inspect the parsed response
console.log(res);

Response schema

profile

Field	Type	Description
`description`	string	Asset description text.
`supplyCirculating` / `supplyTotal` / `supplyMax`	number	Supply figures.
`urls`	array	Array of `{ key, value }` URL entries (social, web, explorer).
`tags`	array	Array of tag keys.
`ratings`	array	Array of `{ key, value }` rating entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "description": "Bitcoin is a decentralized digital currency.",
    "supplyCirculating": 19700000,
    "supplyTotal": 19700000,
    "supplyMax": 21000000,
    "urls": [
      {
        "key": "website",
        "value": "https://bitcoin.org"
      },
      {
        "key": "twitter",
        "value": "https://twitter.com/bitcoin"
      }
    ],
    "tags": [
      "layer-1",
      "pow",
      "store-of-value"
    ],
    "ratings": [
      {
        "key": "cmcRank",
        "value": 1
      }
    ]
  }
}

PUBLIC ASSETS

Get Asset OHLC

Returns OHLC candle series for a single asset price. Timeframe is selectable from the platform sampler keys.

POST /asset/:symbol/ohlc

Auth HMAC-SHA256 Rate limit 20 req/min

Body parameters

Same shape as Get Market OHLC but without the field selector (aggLast is the only sampled field for asset prices).

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/asset/BTC/ohlc" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"timeframe":"day"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.assets.getOhlc("BTC", { timeframe: "day" });

// 3. Inspect the parsed response
console.log(res);

Response schema

asset-ohlc[":symbol"]

Field	Type	Description
`timeframe`	string	Sampler key: hour
`series`	array	Sorted OHLC bins: { tOpen, tClose, open, high, low, close, volume }
`summary`	object	Aggregate change summary over the timeframe window

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "timeframe": "day",
    "series": [
      {
        "tOpen": 1700000000000,
        "tClose": 1700086400000,
        "open": 67000,
        "high": 68500,
        "low": 66800,
        "close": 67500,
        "volume": 12500.5
      }
    ],
    "summary": {
      "open": 67000,
      "high": 68500,
      "low": 66800,
      "close": 67500,
      "change": 0.75
    }
  }
}

PUBLIC ASSETS

Assets Help Map

Returns a structured JSON map of every endpoint in the Assets category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /assets/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/assets/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.assets.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "assets",
  "help": {
    "paths": {
      "/assets/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PUBLIC EXCHANGES

List Exchanges

Returns all tracked exchanges with unified listing data: number of assets and markets, 24h volume, trust score and rank, country, year established, capabilities, and dominance.

POST /exchanges/list

Auth HMAC-SHA256 Rate limit 15 req/min Pagination

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchanges/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.list({ pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

items[]

Field	Type	Description
`nrOfAssets` / `nrOfMarkets`	number	Number of listed assets and trading pairs.
`exchangeVolume24h`	number	24h trading volume in BTC.
`trustScore` / `trustScoreRank` / `exchangeRank`	number	Trust score (0-10) and ranks.
`companyYear` / `companyCountry`	number / string	Year established and country.
`isCentralized` / `isActive`	boolean	CEX/DEX flag and active flag.
`dominance`	number	Volume dominance percentage.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "nrOfAssets": 350,
      "nrOfMarkets": 1500,
      "exchangeVolume24h": 250000,
      "trustScore": 9.5,
      "trustScoreRank": 1,
      "exchangeRank": 1,
      "companyYear": 2017,
      "companyCountry": "KY",
      "isCentralized": true,
      "isActive": true,
      "hasVolumeData": true,
      "hasTrustScore": true,
      "hasApiSupport": true,
      "dominance": 22.5
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Get Exchange

Returns the listing entry for a single exchange by its key. Same shape as List Exchanges items.

GET /exchange/:exchangeKey

Auth HMAC-SHA256 Rate limit 60 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/exchange/binance" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.get("binance");

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange[":exchangeKey"]

Field	Type	Description
`nrOfAssets`	number	Number of assets listed on exchange
`nrOfMarkets`	number	Number of trading pairs on exchange
`exchangeVolume24h`	number	24h trading volume in BTC
`trustScore`	number	Trust score (0-10)
`trustScoreRank`	number	Trust score rank
`exchangeRank`	number	Exchange rank
`companyYear`	number	Year the company was established
`companyCountry`	string	Country where exchange company is based
`isCentralized`	boolean	Whether exchange is centralized (CEX)
`isActive`	boolean	Whether exchange is active
`hasVolumeData`	boolean	Whether volume data is available
`hasTrustScore`	boolean	Whether trust score is available
`hasApiSupport`	boolean	Whether exchange has API support
`dominance`	number	Exchange volume dominance percentage

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "nrOfAssets": 350,
    "nrOfMarkets": 1500,
    "exchangeVolume24h": 250000,
    "trustScore": 9.5,
    "trustScoreRank": 1,
    "exchangeRank": 1,
    "companyYear": 2017,
    "companyCountry": "KY",
    "isCentralized": true,
    "isActive": true,
    "hasVolumeData": true,
    "hasTrustScore": true,
    "hasApiSupport": true,
    "dominance": 22.5
  }
}

PUBLIC EXCHANGES

List Exchange Profiles

Returns all exchange profiles with detailed information.

POST /exchanges/profiles/list

Auth HMAC-SHA256 Rate limit 15 req/min Pagination

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchanges/profiles/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.listProfiles({ pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

profile[":exchangeKey"]

Field	Type	Description
`isCentralized`	boolean	Whether exchange is centralized (CEX)
`yearEstablished`	number	Year the exchange was established
`country`	string	Country where exchange is based
`description`	string	Exchange description text
`nrOfAssets`	number	Number of assets listed
`nrOfMarkets`	number	Number of trading pairs
`exchangeVolume24h`	number	24h trading volume
`trustScore`	number	Trust score (0-10)
`tickersCount`	number	Total number of tickers
`statusUpdatesCount`	number	Number of status updates
`hasVolumeData`	boolean	Whether volume data is available
`hasTrustScore`	boolean	Whether trust score is available
`hasCompanyInfo`	boolean	Whether company info is available
`hasUrlData`	boolean	Whether URL data is available
`hasStatusUpdates`	boolean	Whether status updates are available
`hasTickerData`	boolean	Whether ticker data is available

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "isCentralized": true,
      "yearEstablished": 2017,
      "country": "KY",
      "description": "Binance is a global cryptocurrency exchange.",
      "nrOfAssets": 350,
      "nrOfMarkets": 1500,
      "exchangeVolume24h": 250000,
      "trustScore": 9.5,
      "tickersCount": 1500,
      "statusUpdatesCount": 25,
      "hasVolumeData": true,
      "hasTrustScore": true,
      "hasCompanyInfo": true,
      "hasUrlData": true,
      "hasStatusUpdates": true,
      "hasTickerData": true
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Get Exchange Profile

Returns exchange profile (description, urls, tags, ratings, capabilities).

GET /exchange/:exchangeKey/profile

Auth HMAC-SHA256 Rate limit 60 req/min URL params :exchangeKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/exchange/binance/profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getProfile("binance");

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-profile[":exchangeKey"]

Field	Type	Description
`description`	string	Exchange description
`companyCountry`	string	Country of company
`companyYear`	number	Year established
`capabilities`	object	Capability flags (spot/futures/margin/p2p/otc/staking)
`urls`	array	Array of { key, value } url entries
`tags`	array	Array of tag keys
`ratings`	array	Array of { key, value } rating entries

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "description": "Binance is a global cryptocurrency exchange.",
    "companyCountry": "KY",
    "companyYear": 2017,
    "capabilities": {
      "spot": true,
      "futures": true,
      "margin": true,
      "p2p": true,
      "otc": true,
      "staking": true
    },
    "urls": [
      {
        "key": "website",
        "value": "https://binance.com"
      }
    ],
    "tags": [
      "cex",
      "global"
    ],
    "ratings": [
      {
        "key": "trustScore",
        "value": 9.5
      }
    ]
  }
}

PUBLIC EXCHANGES

Exchange Volume OHLC

Returns OHLC candle series for the exchange (aggVol default, aggDom optional).

POST /exchange/:exchangeKey/ohlc

Auth HMAC-SHA256 Rate limit 20 req/min URL params :exchangeKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).

Body parameters

Name	Type	Required	Description
`field`	string	optional	Snapshotted field selector (e.g. aggLast or aggVol).
`timeframe`	string	optional	Sampler key: hour, day, week, month, year, all.
`tOldest`	integer	optional	Oldest bin time, ms epoch (inclusive).
`tNewest`	integer	optional	Newest bin time, ms epoch (inclusive).

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/ohlc" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"timeframe":"day"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getOhlc("binance", { timeframe: "day" });

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-ohlc[":exchangeKey"]

Field	Type	Description
`field`	string	Snapshotted field: aggVol (default) or aggDom
`timeframe`	string	SnapshotManager sampler key
`series`	array	Sorted OHLC bins for the requested field
`summary`	object	Change summary over the window

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "field": "aggVol",
    "timeframe": "hour",
    "series": [
      {
        "tOpen": 1700000000000,
        "tClose": 1700003600000,
        "open": 240000,
        "high": 260000,
        "low": 230000,
        "close": 250000
      }
    ],
    "summary": {
      "open": 230000,
      "high": 260000,
      "low": 220000,
      "close": 250000,
      "change": 8.7
    }
  }
}

PUBLIC EXCHANGES

Exchange Markets

Returns the list of markets available on a specific exchange, scoped to that venue. Supports filtering, sorting, and pagination via the body.

POST /exchange/:exchangeKey/markets/list

Auth HMAC-SHA256 Rate limit 30 req/min Pagination

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/markets/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.listMarkets("binance", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

items[]

Field	Type	Description
`isActive`	boolean	Whether the market is active on this venue.
`lastPrice`	number	Last traded price on this venue.
`volume`	number	24h trading volume.
`bidPrice` / `askPrice`	number	Top of book bid / ask.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "isActive": true,
      "lastPrice": 67234.5,
      "volume": 12500.5,
      "bidPrice": 67230,
      "askPrice": 67235
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Exchange Tickers

Per-exchange market tickers with full live price data: last, 24h high/low, change, volume, bid/ask, and spread for every pair on the venue.

POST /exchange/:exchangeKey/markets/tickers

Auth HMAC-SHA256 Rate limit 30 req/min Pagination

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/markets/tickers" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.listMarketsTickers("binance", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

items[]

Each item carries marketKey, localPair, baseSymbol, quoteSymbol, lastPrice, highPrice24h, lowPrice24h, change, volume, bidPrice, askPrice, spread, and isActive.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "marketKey": "BTC_USDT",
      "localPair": "BTCUSDT",
      "baseSymbol": "BTC",
      "quoteSymbol": "USDT",
      "lastPrice": 67234.5,
      "highPrice24h": 68500,
      "lowPrice24h": 66800,
      "change": 1.23,
      "volume": 12500.5,
      "bidPrice": 67230,
      "askPrice": 67235,
      "spread": 5,
      "isActive": true
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Exchange Markets OHLC

Returns the latest OHLC candle for each market on an exchange.

POST /exchange/:exchangeKey/markets/ohlc

Auth HMAC-SHA256 Rate limit 20 req/min Pagination URL params :exchangeKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).

Body parameters

Name	Type	Required	Description
`timeframe`	string	optional	Sampler key: hour, day, week, month, year, all.
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/markets/ohlc" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50},"timeframe":"day"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getMarketsOhlc("binance", { pagination: { page: 1, limit: 50 }, timeframe: "day" });

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-market-ohlc-list[":marketKey"]

Field	Type	Description
`tOpen`	number	Bin open time (ms epoch)
`tClose`	number	Bin close time (ms epoch)
`open`	number	Bin open price
`high`	number	Bin high price
`low`	number	Bin low price
`close`	number	Bin close price
`volume`	number	Bin aggregate volume

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "tOpen": 1700000000000,
      "tClose": 1700003600000,
      "open": 67200,
      "high": 67800,
      "low": 67000,
      "close": 67500,
      "volume": 12500.5
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Exchange Markets Limits

Returns per-exchange market limits (trading rules + fees).

POST /exchange/:exchangeKey/markets/limits

Auth HMAC-SHA256 Rate limit 30 req/min Pagination URL params :exchangeKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/markets/limits" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.listMarketsLimits("binance", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-market-limit[":marketKey"]

Field	Type	Description
`priceMin`	number	Minimum price
`priceMax`	number	Maximum price
`priceTick`	number	Price tick size
`quantityMin`	number	Minimum quantity
`quantityMax`	number	Maximum quantity
`quantityTick`	number	Quantity tick size
`totalMin`	number	Minimum notional
`totalMax`	number	Maximum notional
`feeMaker`	number	Maker fee rate
`feeTaker`	number	Taker fee rate
`feeIsTiered`	boolean	Whether fees are tiered

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "priceMin": 0.01,
      "priceMax": 1000000,
      "priceTick": 0.01,
      "quantityMin": 0.00001,
      "quantityMax": 9000,
      "quantityTick": 0.00001,
      "totalMin": 5,
      "totalMax": 9000000,
      "feeMaker": 0.001,
      "feeTaker": 0.001,
      "feeIsTiered": true
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Get Exchange Market

Returns a single market for a specific exchange.

GET /exchange/:exchangeKey/market/:marketKey

Auth HMAC-SHA256 Rate limit 60 req/min URL params :exchangeKey, :marketKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).
`marketKey`	required	Market key as listed on the exchange.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/exchange/binance/market/BTCUSDT" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getMarket("binance", "BTCUSDT");

// 3. Inspect the parsed response
console.log(res);

Response schema

exchangeMarket[":marketKey"]

Field	Type	Description
`isActive`	boolean	Whether market is active
`lastPrice`	number	Last traded price
`volume`	number	24h trading volume
`bidPrice`	number	Current bid price
`askPrice`	number	Current ask price

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "isActive": true,
    "lastPrice": 67234.5,
    "volume": 12500.5,
    "bidPrice": 67230,
    "askPrice": 67235
  }
}

PUBLIC EXCHANGES

Exchange Market Ticker

Returns a single market ticker on an exchange.

GET /exchange/:exchangeKey/market/:marketKey/ticker

Auth HMAC-SHA256 Rate limit 60 req/min URL params :exchangeKey, :marketKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).
`marketKey`	required	Market key as listed on the exchange.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/exchange/binance/market/BTCUSDT/ticker" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getMarketTicker("binance", "BTCUSDT");

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-market-ticker[":marketKey"]

Field	Type	Description
`marketKey`	string	Global pair symbol
`localPair`	string	Local pair on exchange
`baseSymbol`	string	Base symbol
`quoteSymbol`	string	Quote symbol
`lastPrice`	number	Last traded price
`highPrice24h`	number	24h high
`lowPrice24h`	number	24h low
`change`	number	24h price change
`volume`	number	24h volume
`bidPrice`	number	Current bid price
`askPrice`	number	Current ask price
`spread`	number	Bid/ask spread
`isActive`	boolean	Whether market is active

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "marketKey": "BTC_USDT",
    "localPair": "BTCUSDT",
    "baseSymbol": "BTC",
    "quoteSymbol": "USDT",
    "lastPrice": 67234.5,
    "highPrice24h": 68500,
    "lowPrice24h": 66800,
    "change": 1.23,
    "volume": 12500.5,
    "bidPrice": 67230,
    "askPrice": 67235,
    "spread": 5,
    "isActive": true
  }
}

PUBLIC EXCHANGES

Exchange Market Profile

Returns profile metadata for a single market on an exchange (tags + status).

GET /exchange/:exchangeKey/market/:marketKey/profile

Auth HMAC-SHA256 Rate limit 60 req/min URL params :exchangeKey, :marketKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).
`marketKey`	required	Market key as listed on the exchange.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/exchange/binance/market/BTCUSDT/profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getMarketProfile("binance", "BTCUSDT");

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-market-profile[":marketKey"]

Field	Type	Description
`localPair`	string	Local pair on exchange
`baseSymbol`	string	Base symbol
`quoteSymbol`	string	Quote symbol
`globalPair`	string	Global pair symbol
`isListed`	boolean	Whether market is listed
`isActive`	boolean	Whether market is active
`openTrading`	boolean	Trading enabled
`openApiTrading`	boolean	API trading enabled
`limitsFetchedOn`	number	Last limit fetch timestamp (ms epoch)
`tags`	array	Array of tag keys

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "localPair": "BTCUSDT",
    "baseSymbol": "BTC",
    "quoteSymbol": "USDT",
    "globalPair": "BTC_USDT",
    "isListed": true,
    "isActive": true,
    "openTrading": true,
    "openApiTrading": true,
    "limitsFetchedOn": 1700000000000,
    "tags": [
      "spot",
      "major"
    ]
  }
}

PUBLIC EXCHANGES

Exchange Market OHLC

Returns OHLC series for a single market on an exchange (lastPrice).

POST /exchange/:exchangeKey/market/:marketKey/ohlc

Auth HMAC-SHA256 Rate limit 20 req/min URL params :exchangeKey, :marketKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).
`marketKey`	required	Market key as listed on the exchange.

Body parameters

Name	Type	Required	Description
`timeframe`	string	optional	Sampler key: hour, day, week, month, year, all.
`tOldest`	integer	optional	Oldest bin time, ms epoch (inclusive).
`tNewest`	integer	optional	Newest bin time, ms epoch (inclusive).

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/market/BTCUSDT/ohlc" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"timeframe":"day"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getMarketOhlc("binance", "BTCUSDT", { timeframe: "day" });

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-market-ohlc[":marketKey"]

Field	Type	Description
`timeframe`	string	Sampler key
`series`	array	Sorted OHLC bins on lastPrice
`summary`	object	Change summary over the window

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "timeframe": "hour",
    "series": [
      {
        "tOpen": 1700000000000,
        "tClose": 1700003600000,
        "open": 67200,
        "high": 67800,
        "low": 67000,
        "close": 67500
      }
    ],
    "summary": {
      "open": 67000,
      "high": 68500,
      "low": 66800,
      "close": 67500,
      "change": 0.75
    }
  }
}

PUBLIC EXCHANGES

Exchange Assets

Returns assets listed on a specific exchange.

POST /exchange/:exchangeKey/assets/list

Auth HMAC-SHA256 Rate limit 30 req/min Pagination URL params :exchangeKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/assets/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.listAssets("binance", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

exchangeAsset[":assetKey"]

Field	Type	Description
`symbol`	string	Asset symbol
`depositEnabled`	boolean	Whether deposits are enabled
`withdrawEnabled`	boolean	Whether withdrawals are enabled
`tradingEnabled`	boolean	Whether trading is enabled

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "symbol": "BTC",
      "depositEnabled": true,
      "withdrawEnabled": true,
      "tradingEnabled": true
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Exchange Asset Tickers

Returns per-exchange asset tickers with live price data (paginated).

POST /exchange/:exchangeKey/assets/tickers

Auth HMAC-SHA256 Rate limit 30 req/min Pagination URL params :exchangeKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/assets/tickers" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.listAssetsTickers("binance", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-asset-ticker[":assetKey"]

Field	Type	Description
`assetKey`	string	Global asset symbol
`localSymbol`	string	Local symbol on exchange
`lastPrice`	number	Latest aggregated price
`priceQuote`	string	Quote currency of lastPrice
`volume24h`	number	24h aggregated volume
`change24h`	number	24h price change percentage
`dominance`	number	Market dominance share

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "assetKey": "BTC",
      "localSymbol": "BTC",
      "lastPrice": 67234.5,
      "priceQuote": "USDT",
      "volume24h": 12500.5,
      "change24h": 1.23,
      "dominance": 52.4
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Exchange Asset Limits

Returns per-exchange asset limits (precision + order/deposit/withdrawal bounds + fees).

POST /exchange/:exchangeKey/assets/limits

Auth HMAC-SHA256 Rate limit 30 req/min Pagination URL params :exchangeKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/assets/limits" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.listAssetsLimits("binance", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-asset-limit[":assetKey"]

Field	Type	Description
`precision`	number	Decimal precision
`orderMin`	number	Minimum order size
`orderMax`	number	Maximum order size
`depositMin`	number	Minimum deposit amount
`depositMax`	number	Maximum deposit amount
`withdrawalMin`	number	Minimum withdrawal amount
`withdrawalMax`	number	Maximum withdrawal amount
`withdrawFee`	number	Withdrawal fee
`depositEnabled`	boolean	Whether deposits are enabled
`withdrawEnabled`	boolean	Whether withdrawals are enabled
`tradingEnabled`	boolean	Whether trading is enabled

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "precision": 8,
      "orderMin": 0.00001,
      "orderMax": 9000,
      "depositMin": 0.0001,
      "depositMax": 1000000,
      "withdrawalMin": 0.001,
      "withdrawalMax": 100,
      "withdrawFee": 0.0005,
      "depositEnabled": true,
      "withdrawEnabled": true,
      "tradingEnabled": true
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC EXCHANGES

Get Exchange Asset

Returns a single asset for a specific exchange.

GET /exchange/:exchangeKey/asset/:assetKey

Auth HMAC-SHA256 Rate limit 60 req/min URL params :exchangeKey, :assetKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).
`assetKey`	required	Asset key as listed on the exchange.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/exchange/binance/asset/BTC" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getAsset("binance", "BTC");

// 3. Inspect the parsed response
console.log(res);

Response schema

exchangeAsset[":assetKey"]

Field	Type	Description
`symbol`	string	Asset symbol
`depositEnabled`	boolean	Whether deposits are enabled
`withdrawEnabled`	boolean	Whether withdrawals are enabled
`tradingEnabled`	boolean	Whether trading is enabled

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "symbol": "BTC",
    "depositEnabled": true,
    "withdrawEnabled": true,
    "tradingEnabled": true
  }
}

PUBLIC EXCHANGES

Exchange Asset Profile

Returns profile metadata for a single asset on an exchange (tags + status).

GET /exchange/:exchangeKey/asset/:assetKey/profile

Auth HMAC-SHA256 Rate limit 60 req/min URL params :exchangeKey, :assetKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).
`assetKey`	required	Asset key as listed on the exchange.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/exchange/binance/asset/BTC/profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getAssetProfile("binance", "BTC");

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-asset-profile[":assetKey"]

Field	Type	Description
`localSymbol`	string	Local symbol on exchange
`localName`	string	Local display name
`isListed`	boolean	Whether asset is currently listed
`depositEnabled`	boolean	Deposits enabled
`withdrawEnabled`	boolean	Withdrawals enabled
`tradingEnabled`	boolean	Trading enabled
`precision`	number	Decimal precision
`limitsFetchedOn`	number	Last limit fetch timestamp (ms epoch)
`isWarning`	boolean	Warning flag
`tags`	array	Array of tag keys

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "localSymbol": "BTC",
    "localName": "Bitcoin",
    "isListed": true,
    "depositEnabled": true,
    "withdrawEnabled": true,
    "tradingEnabled": true,
    "precision": 8,
    "limitsFetchedOn": 1700000000000,
    "isWarning": false,
    "tags": [
      "major"
    ]
  }
}

PUBLIC EXCHANGES

Exchange Asset OHLC

Returns OHLC series for a single asset on an exchange (aggLast).

POST /exchange/:exchangeKey/asset/:assetKey/ohlc

Auth HMAC-SHA256 Rate limit 20 req/min URL params :exchangeKey, :assetKey

URL parameters

Name	Required	Description
`exchangeKey`	required	Exchange key (e.g. binance, kraken, coinbase).
`assetKey`	required	Asset key as listed on the exchange.

Body parameters

Name	Type	Required	Description
`timeframe`	string	optional	Sampler key: hour, day, week, month, year, all.
`tOldest`	integer	optional	Oldest bin time, ms epoch (inclusive).
`tNewest`	integer	optional	Newest bin time, ms epoch (inclusive).

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/exchange/binance/asset/BTC/ohlc" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"timeframe":"day"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.getAssetOhlc("binance", "BTC", { timeframe: "day" });

// 3. Inspect the parsed response
console.log(res);

Response schema

exchange-asset-ohlc[":assetKey"]

Field	Type	Description
`timeframe`	string	Sampler key
`series`	array	Sorted OHLC bins on aggLast
`summary`	object	Change summary over the window

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "timeframe": "hour",
    "series": [
      {
        "tOpen": 1700000000000,
        "tClose": 1700003600000,
        "open": 67200,
        "high": 67800,
        "low": 67000,
        "close": 67500
      }
    ],
    "summary": {
      "open": 67000,
      "high": 68500,
      "low": 66800,
      "close": 67500,
      "change": 0.75
    }
  }
}

PUBLIC EXCHANGES

Exchanges Help Map

Returns a structured JSON map of every endpoint in the Exchanges category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /exchanges/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/exchanges/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.exchanges.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "exchanges",
  "help": {
    "paths": {
      "/exchanges/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PUBLIC CHAINS

List Chains

Returns the list of every blockchain network the platform tracks, with unified listing data. Filtering, sorting, and pagination are supported.

POST /chains/list

Auth HMAC-SHA256 Rate limit 15 req/min Pagination

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/chains/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.list({ pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

chain[":chainId"]

Field	Type	Description
`name`	string	Chain name
`nativeToken`	string	Native token symbol
`icon`	string	Chain icon URL
`tvl`	number	Total value locked
`chainId`	number	Chain identifier

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "name": "Ethereum",
      "nativeToken": "ETH",
      "icon": "https://cdn.example.com/chains/ethereum.png",
      "tvl": 45000000000,
      "chainId": 1
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC CHAINS

Get Chain

Returns a single chain by chain ID.

GET /chain/:chainId

Auth HMAC-SHA256 Rate limit 60 req/min URL params :chainId

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chain/ethereum" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.get("ethereum");

// 3. Inspect the parsed response
console.log(res);

Response schema

chain[":chainId"]

Field	Type	Description
`name`	string	Chain name
`nativeToken`	string	Native token symbol
`icon`	string	Chain icon URL
`tvl`	number	Total value locked
`chainId`	number	Chain identifier

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "name": "Ethereum",
    "nativeToken": "ETH",
    "icon": "https://cdn.example.com/chains/ethereum.png",
    "tvl": 45000000000,
    "chainId": 1
  }
}

PUBLIC CHAINS

Chain Profile

Returns chain profile (description, urls, tags, ratings).

GET /chain/:chainId/profile

Auth HMAC-SHA256 Rate limit 60 req/min URL params :chainId

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.getProfile("ethereum");

// 3. Inspect the parsed response
console.log(res);

Response schema

chain-profile[":chainId"]

Field	Type	Description
`description`	string	Chain description
`urls`	array	Array of { key, value } url entries
`tags`	array	Array of tag keys
`ratings`	array	Array of { key, value } rating entries

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "description": "Ethereum is a decentralized smart contract platform.",
    "urls": [
      {
        "key": "website",
        "value": "https://ethereum.org"
      },
      {
        "key": "explorer",
        "value": "https://etherscan.io"
      }
    ],
    "tags": [
      "layer-1",
      "evm",
      "pos"
    ],
    "ratings": [
      {
        "key": "cmcRank",
        "value": 2
      }
    ]
  }
}

PUBLIC CHAINS

Gas Prices

Returns current gas prices for every supported chain in a single payload. Use this to drive a multi-chain fee selector or routing layer.

GET /chains/gas-prices/list

Auth HMAC-SHA256 Rate limit 10 req/min Pagination

Related endpoint

Per-chain price: GET /v1/chain/:chainId/gas-price. Same shape, scoped to a single chain.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chains/gas-prices/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.listGasPrices();

// 3. Inspect the parsed response
console.log(res);

Response schema

gas[":chainId"]

Field	Type	Description
`gasPrice`	number	Current gas price
`gasPriceGwei`	number	Gas price in gwei
`gasPriceWei`	string	Gas price in wei (raw)
`baseFee`	string	Base fee (raw wei or gwei)
`baseFeeGwei`	number	Base fee in gwei
`priorityFee`	number	Priority fee (tip)
`priorityFeeGwei`	number	Priority fee in gwei
`safeGasPrice`	number	Safe/slow gas price recommendation
`proposeGasPrice`	number	Proposed/average gas price recommendation
`fastGasPrice`	number	Fast gas price recommendation
`gasCostUsd`	number	Gas cost in USD
`gasQuoteRate`	number	Native token to USD exchange rate
`blockNumber`	number	Current block number
`timestamp`	number	Measurement timestamp (unix)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "gasPrice": 32,
      "gasPriceGwei": 32,
      "gasPriceWei": "32000000000",
      "baseFee": "28000000000",
      "baseFeeGwei": 28,
      "priorityFee": 2,
      "priorityFeeGwei": 2,
      "safeGasPrice": 28,
      "proposeGasPrice": 32,
      "fastGasPrice": 38,
      "gasCostUsd": 1.45,
      "gasQuoteRate": 3500,
      "blockNumber": 18900000,
      "timestamp": 1700000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC CHAINS

Get Chain Gas Price

Returns gas price for a specific chain.

GET /chain/:chainId/gas-price

Auth HMAC-SHA256 Rate limit 10 req/min URL params :chainId

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/gas-price" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.getGasPrice("ethereum");

// 3. Inspect the parsed response
console.log(res);

Response schema

gas[":chainId"]

Field	Type	Description
`gasPrice`	number	Current gas price
`gasPriceGwei`	number	Gas price in gwei
`gasPriceWei`	string	Gas price in wei (raw)
`baseFee`	string	Base fee (raw wei or gwei)
`baseFeeGwei`	number	Base fee in gwei
`priorityFee`	number	Priority fee (tip)
`priorityFeeGwei`	number	Priority fee in gwei
`safeGasPrice`	number	Safe/slow gas price recommendation
`proposeGasPrice`	number	Proposed/average gas price recommendation
`fastGasPrice`	number	Fast gas price recommendation
`gasCostUsd`	number	Gas cost in USD
`gasQuoteRate`	number	Native token to USD exchange rate
`blockNumber`	number	Current block number
`timestamp`	number	Measurement timestamp (unix)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "gasPrice": 32,
    "gasPriceGwei": 32,
    "gasPriceWei": "32000000000",
    "baseFee": "28000000000",
    "baseFeeGwei": 28,
    "priorityFee": 2,
    "priorityFeeGwei": 2,
    "safeGasPrice": 28,
    "proposeGasPrice": 32,
    "fastGasPrice": 38,
    "gasCostUsd": 1.45,
    "gasQuoteRate": 3500,
    "blockNumber": 18900000,
    "timestamp": 1700000000
  }
}

PUBLIC CHAINS

Chain Gas OHLC

Returns OHLC candle series for the chain gas price (SnapshotManager).

POST /chain/:chainId/gas-ohlc

Auth HMAC-SHA256 Rate limit 20 req/min URL params :chainId

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).

Body parameters

Name	Type	Required	Description
`timeframe`	string	optional	Sampler key: hour, day, week, month, year, all.
`tOldest`	integer	optional	Oldest bin time, ms epoch (inclusive).
`tNewest`	integer	optional	Newest bin time, ms epoch (inclusive).

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/gas-ohlc" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"timeframe":"day"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.getGasOhlc("ethereum", { timeframe: "day" });

// 3. Inspect the parsed response
console.log(res);

Response schema

chain-gas-ohlc[":chainId"]

Field	Type	Description
`timeframe`	string	SnapshotManager sampler key (hour
`series`	array	Sorted OHLC bins on gasPrice
`summary`	object	Change summary over the window

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "timeframe": "hour",
    "series": [
      {
        "tOpen": 1700000000000,
        "tClose": 1700003600000,
        "open": 30,
        "high": 35,
        "low": 28,
        "close": 32
      }
    ],
    "summary": {
      "open": 28,
      "high": 38,
      "low": 26,
      "close": 32,
      "change": 14.3
    }
  }
}

PUBLIC CHAINS

Chain Tokens

Returns the token list for a specific chain, including ERC-20-style metadata. Filtering, sorting, and pagination supported.

POST /chain/:chainId/tokens

Auth HMAC-SHA256 Rate limit 10 req/min Pagination

Body parameters

Name	Type	Required	Description
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Related endpoints

Single token: POST /v1/chain/:chainId/token/:tokenAddress
Holders: POST /v1/chain/:chainId/token/:tokenAddress/holders
Transfers: POST /v1/chain/:chainId/token/:tokenAddress/transfers
Wallet portfolio: POST /v1/chain/:chainId/wallet/:walletAddress/portfolio

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/tokens" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.listTokens("ethereum", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

token[":tokenAddress"]

Field	Type	Description
`circulatingSupply`	number	Circulating supply
`holderCount`	number	Number of token holders
`priceUsd`	number	Current token price in USD
`volumeUsd24h`	number	24h trading volume in USD
`marketCapUsd`	number	Market capitalization in USD
`verified`	boolean	Whether token contract is verified

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "circulatingSupply": 1000000000,
      "holderCount": 250000,
      "priceUsd": 1,
      "volumeUsd24h": 5000000000,
      "marketCapUsd": 1000000000,
      "verified": true
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC CHAINS

Get Token

Returns detailed info for a specific token on a chain.

GET /chain/:chainId/token/:tokenAddress

Auth HMAC-SHA256 Rate limit 10 req/min URL params :chainId, :tokenAddress

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).
`tokenAddress`	required	Token contract address (chain-specific format).

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.getToken("ethereum", "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");

// 3. Inspect the parsed response
console.log(res);

Response schema

token[":tokenAddress"]

Field	Type	Description
`circulatingSupply`	number	Circulating supply
`holderCount`	number	Number of token holders
`priceUsd`	number	Current token price in USD
`volumeUsd24h`	number	24h trading volume in USD
`marketCapUsd`	number	Market capitalization in USD
`verified`	boolean	Whether token contract is verified

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "circulatingSupply": 1000000000,
    "holderCount": 250000,
    "priceUsd": 1,
    "volumeUsd24h": 5000000000,
    "marketCapUsd": 1000000000,
    "verified": true
  }
}

PUBLIC CHAINS

Token Holders

Returns holder list for a specific token.

POST /chain/:chainId/token/:tokenAddress/holders

Auth HMAC-SHA256 Rate limit 10 req/min Pagination URL params :chainId, :tokenAddress

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).
`tokenAddress`	required	Token contract address (chain-specific format).

Body parameters

Name	Type	Required	Description
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/holders" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.listTokenHolders("ethereum", "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

holder[":holderAddress"]

Field	Type	Description
`balance`	string	Raw balance held
`balanceFormatted`	number	Human-readable balance
`balanceUsd`	number	USD value of holdings
`percentageOfSupply`	number	Percentage of total supply held

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "balance": "5000000000000000000",
      "balanceFormatted": 5,
      "balanceUsd": 17500,
      "percentageOfSupply": 0.0005
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC CHAINS

Get Token Holder

Returns details for a specific token holder.

GET /chain/:chainId/token/:tokenAddress/holder/:holderAddress

Auth HMAC-SHA256 Rate limit 10 req/min URL params :chainId, :tokenAddress, :holderAddress

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).
`tokenAddress`	required	Token contract address (chain-specific format).
`holderAddress`	required	Token holder wallet address.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/holder/0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.getTokenHolder("ethereum", "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1");

// 3. Inspect the parsed response
console.log(res);

Response schema

holder[":holderAddress"]

Field	Type	Description
`balance`	string	Raw balance held
`balanceFormatted`	number	Human-readable balance
`balanceUsd`	number	USD value of holdings
`percentageOfSupply`	number	Percentage of total supply held

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "balance": "5000000000000000000",
    "balanceFormatted": 5,
    "balanceUsd": 17500,
    "percentageOfSupply": 0.0005
  }
}

PUBLIC CHAINS

Token Transfers

Returns transfer history for a specific token.

POST /chain/:chainId/token/:tokenAddress/transfers

Auth HMAC-SHA256 Rate limit 10 req/min Pagination URL params :chainId, :tokenAddress

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).
`tokenAddress`	required	Token contract address (chain-specific format).

Body parameters

Name	Type	Required	Description
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/transfers" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.listTokenTransfers("ethereum", "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

transfer[":txHash"]

Field	Type	Description
`fromAddress`	string	Sender address
`toAddress`	string	Recipient address
`value`	string	Transfer amount in smallest unit (raw)
`valueFormatted`	number	Human-readable transfer amount
`valueUsd`	number	USD value of transfer
`gasSpent`	number	Gas consumed
`gasFeeUsd`	number	Gas fee in USD
`successful`	boolean	Transaction success status
`timestamp`	number	Transfer timestamp (unix)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "fromAddress": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
      "toAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "value": "1000000000000000000",
      "valueFormatted": 1,
      "valueUsd": 3500,
      "gasSpent": 21000,
      "gasFeeUsd": 1.45,
      "successful": true,
      "timestamp": 1700000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC CHAINS

Get Token Transfer

Returns details for a specific token transfer.

GET /chain/:chainId/token/:tokenAddress/transfer/:txHash

Auth HMAC-SHA256 Rate limit 10 req/min URL params :chainId, :tokenAddress, :txHash

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).
`tokenAddress`	required	Token contract address (chain-specific format).
`txHash`	required	Transaction hash on the chain.

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/transfer/0x1234abcd5678ef901234567890abcdef1234567890abcdef1234567890abcdef" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.getTokenTransfer("ethereum", "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "0x1234abcd5678ef901234567890abcdef1234567890abcdef1234567890abcdef");

// 3. Inspect the parsed response
console.log(res);

Response schema

transfer[":txHash"]

Field	Type	Description
`fromAddress`	string	Sender address
`toAddress`	string	Recipient address
`value`	string	Transfer amount in smallest unit (raw)
`valueFormatted`	number	Human-readable transfer amount
`valueUsd`	number	USD value of transfer
`gasSpent`	number	Gas consumed
`gasFeeUsd`	number	Gas fee in USD
`successful`	boolean	Transaction success status
`timestamp`	number	Transfer timestamp (unix)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "fromAddress": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    "toAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    "value": "1000000000000000000",
    "valueFormatted": 1,
    "valueUsd": 3500,
    "gasSpent": 21000,
    "gasFeeUsd": 1.45,
    "successful": true,
    "timestamp": 1700000000
  }
}

PUBLIC CHAINS

Wallet Portfolio

Returns portfolio balance for a wallet on a chain.

GET /chain/:chainId/wallet/:walletAddress/portfolio

Auth HMAC-SHA256 Rate limit 10 req/min URL params :chainId, :walletAddress

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).
`walletAddress`	required	Wallet address (chain-specific format).

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/wallet/0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1/portfolio" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.getWalletPortfolio("ethereum", "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1");

// 3. Inspect the parsed response
console.log(res);

Response schema

walletPortfolio[":walletAddress"]

Field	Type	Description
`totalBalanceUsd`	number	Total portfolio value in USD
`totalTokenCount`	number	Total number of tokens held

Response schema

walletPortfolio[":walletAddress"].tokens[0]

Field	Type	Description
`balance`	string	Token raw balance
`balanceUsd`	number	Token balance in USD
`priceUsd`	number	Token price in USD

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "totalBalanceUsd": 25000,
    "totalTokenCount": 12,
    "tokens": [
      {
        "balance": "5000000000000000000",
        "balanceUsd": 17500,
        "priceUsd": 3500
      }
    ]
  }
}

PUBLIC CHAINS

Wallet Token Balance

Returns balance for a specific token in a wallet.

GET /chain/:chainId/wallet/:walletAddress/balance/:tokenAddress

Auth HMAC-SHA256 Rate limit 10 req/min URL params :chainId, :walletAddress, :tokenAddress

URL parameters

Name	Required	Description
`chainId`	required	Chain identifier (e.g. ethereum, polygon, base).
`walletAddress`	required	Wallet address (chain-specific format).
`tokenAddress`	required	Token contract address (chain-specific format).

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chain/ethereum/wallet/0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1/balance/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.getWalletBalance("ethereum", "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1", "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");

// 3. Inspect the parsed response
console.log(res);

Response schema

walletBalance[":walletAddress"][":tokenAddress"]

Field	Type	Description
`balance`	string	Raw token balance
`balanceFormatted`	number	Human-readable balance
`balanceUsd`	number	USD value of balance
`priceUsd`	number	Current token price in USD
`priceUsd24h`	number	Token price 24h ago in USD
`nativeToken`	boolean	Whether this is the native gas token
`isSpam`	boolean	Whether token is suspected spam

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "balance": "5000000000000000000",
    "balanceFormatted": 5,
    "balanceUsd": 17500,
    "priceUsd": 3500,
    "priceUsd24h": 3450,
    "nativeToken": true,
    "isSpam": false
  }
}

PUBLIC CHAINS

Chains Help Map

Returns a structured JSON map of every endpoint in the Chains category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /chains/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/chains/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.chains.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "blockchain",
  "help": {
    "paths": {
      "/chains/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PUBLIC MACRO

List Macro Types

Returns every macro indicator type tracked by the platform (e.g. reference rates, volatility indices). Use the returned macroType keys with the values and OHLC endpoints below.

GET /macro/types

Auth HMAC-SHA256 Rate limit 15 req/min Pagination

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/macro/types" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.macro.types();

// 3. Inspect the parsed response
console.log(res);

Response schema

macro-type[":key"]

Field	Type	Description
`label`	string	Human-readable type label
`description`	string	Type description
`params`	array	Required parameters for value lookup
`ohlcParams`	array	Required parameters for OHLC
`additionalFields`	array	Type-specific output fields beyond country/date/value/isLatest

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "label": "Inflation Rate",
      "description": "Year-over-year change in CPI",
      "params": [
        "country"
      ],
      "ohlcParams": [
        "country"
      ],
      "additionalFields": [
        "inflationIndex"
      ]
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC MACRO

Macro Values

Returns the latest values for a given macro indicator type (e.g. reference-rates). Use the listing endpoint to discover available types.

POST /macro/values/:macroType

Auth HMAC-SHA256 Rate limit 15 req/min Pagination

Body parameters

Name	Type	Required	Description
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/macro/values/reference-rates" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.macro.getValues("reference-rates", { pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

macro-value[":country"]

Field	Type	Description
`value`	number	Type-specific numeric value
`date`	string	Observation date (YYYY-MM-DD)
`isLatest`	boolean	Whether this is the most recent observation
`centralBankKey`	string	Central bank identifier (policyRate only)
`inflationIndex`	number	CPI index value (inflationRate only)
`currency`	string	Currency code (moneySupply only)
`scale`	string	Scale indicator (moneySupply only)
`maturity`	string	Maturity period (bondYield only)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "value": 3.2,
      "date": "2026-04-30",
      "isLatest": true,
      "centralBankKey": "FED",
      "inflationIndex": 312.4,
      "currency": "USD",
      "scale": "billions",
      "maturity": "10Y"
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PUBLIC MACRO

Get Macro Value

Returns the latest macro value for a single country (bondYield additionally requires maturity).

POST /macro/value/:macroType

Auth HMAC-SHA256 Rate limit 60 req/min URL params :macroType

URL parameters

Name	Required	Description
`macroType`	required	Macro indicator type key (see List Macro Types).

Body parameters

Name	Type	Required	Description
`country`	-	required	-
`maturity`	-	optional	-

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/macro/value/reference-rates" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"country":"TR"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.macro.getValue("reference-rates", { country: "TR" });

// 3. Inspect the parsed response
console.log(res);

Response schema

macro-value[":country"]

Field	Type	Description
`value`	number	Type-specific numeric value
`date`	string	Observation date (YYYY-MM-DD)
`isLatest`	boolean	Whether this is the most recent observation
`centralBankKey`	string	Central bank identifier (policyRate only)
`inflationIndex`	number	CPI index value (inflationRate only)
`currency`	string	Currency code (moneySupply only)
`scale`	string	Scale indicator (moneySupply only)
`maturity`	string	Maturity period (bondYield only)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "value": 3.2,
    "date": "2026-04-30",
    "isLatest": true,
    "centralBankKey": "FED",
    "inflationIndex": 312.4,
    "currency": "USD",
    "scale": "billions",
    "maturity": "10Y"
  }
}

PUBLIC MACRO

Macro OHLC

Returns OHLC candle series for a macro indicator type. Standard timeframe, tOldest, tNewest body parameters apply.

POST /macro/ohlc/:macroType

Auth HMAC-SHA256 Rate limit 20 req/min

Body parameters

Name	Type	Required	Description
`country`	-	required	-
`timeframe`	string	optional	Sampler key: hour, day, week, month, year, all.
`tOldest`	integer	optional	Oldest bin time, ms epoch (inclusive).
`tNewest`	integer	optional	Newest bin time, ms epoch (inclusive).

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/macro/ohlc/reference-rates" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"country":"TR","timeframe":"day"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.macro.getOhlc("reference-rates", { timeframe: "day", country: "TR" });

// 3. Inspect the parsed response
console.log(res);

Response schema

macro-ohlc[":macroType"]

Field	Type	Description
`timeframe`	string	SnapshotManager sampler key for the OHLC bucket
`series`	array	OHLC bars: {tOpen, tClose, open, high, low, close}. For sparse macro observations the bar is degenerate (open = high = low = close = value).

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "timeframe": "month",
    "series": [
      {
        "tOpen": 1700000000000,
        "tClose": 1702592000000,
        "open": 3.1,
        "high": 3.3,
        "low": 3.1,
        "close": 3.2
      }
    ]
  }
}

PUBLIC MACRO

Macro Help Map

Returns a structured JSON map of every endpoint in the Macro category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /macro/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/macro/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS"

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.macro.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "macro",
  "help": {
    "paths": {
      "/macro/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PRIVATE VAULTS

List Vaults

Returns the lean summary list of every vault belonging to a pool: identifier, name, and status. Sorting, search, and pagination supported.

POST /vaults/list

Auth HMAC + poolKey Rate limit 30 req/min Pagination

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key. Falls back to the API key's bound pool when omitted.
`search`	string	optional	Free-text search over vault name and id.
`sorting`	object	optional	Standard `{ field, direction }`.
`pagination`	object	optional	Standard `{ page, limit }`.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/vaults/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.vaults.list({ poolKey, pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

vault-summary[":vaultId"]

Field	Type	Description
`fullName`	string	Human-readable vault name
`status`	number	Current lifecycle status enum
`targetStatus`	number	Target lifecycle status
`exchangeKey`	string	Exchange store item key (e.g., binance)
`relPoolKey`	string	Owning pool key
`attachedStrategyId`	string	Attached strategy id (if any)
`reportedOn`	number	Last status report timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "fullName": "binance-spot-main",
      "status": 1000,
      "targetStatus": 1000,
      "exchangeKey": "binance",
      "relPoolKey": "pool_main",
      "attachedStrategyId": "stg_1",
      "reportedOn": 1700000000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PRIVATE VAULTS

Vault Summary

Returns the lean vault summary (id, name, status) for a single vault. Cheap and cacheable - prefer this when you only need the headline status.

POST /vault/:vaultId/summary

Auth HMAC + poolKey Rate limit 60 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/vault/vlt-abc123/summary" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.vaults.getSummary("vlt-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

vault-summary[":vaultId"]

Field	Type	Description
`fullName`	string	Human-readable vault name
`status`	number	Current lifecycle status enum
`targetStatus`	number	Target lifecycle status
`exchangeKey`	string	Exchange store item key (e.g., binance)
`relPoolKey`	string	Owning pool key
`attachedStrategyId`	string	Attached strategy id (if any)
`reportedOn`	number	Last status report timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "fullName": "binance-spot-main",
    "status": 1000,
    "targetStatus": 1000,
    "exchangeKey": "binance",
    "relPoolKey": "pool_main",
    "attachedStrategyId": "stg_1",
    "reportedOn": 1700000000000
  }
}

PRIVATE VAULTS

Vault Detail

Returns the full vault detail by id - configuration, allocation, performance metrics, and runtime status.

POST /vault/:vaultId

Auth HMAC + poolKey Rate limit 60 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/vault/vlt-abc123" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.vaults.get("vlt-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

vault[":vaultId"]

Field	Type	Description
`fullName`	string	Vault full name
`exchangeKey`	string	Exchange key
`provider`	string	Provider identifier
`status`	string	Status as string
`isActive`	boolean	Is the vault active
`createdOn`	number	Creation timestamp
`updatedOn`	number	Last update timestamp

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "fullName": "binance-spot-main",
    "exchangeKey": "binance",
    "provider": "ccxt",
    "status": "active",
    "isActive": true,
    "createdOn": 1690000000000,
    "updatedOn": 1700000000000
  }
}

PRIVATE VAULTS

Vault Runtime Profile

Returns the runtime profile for a vault as { profile: object, hash: string }. The hash lets clients short-circuit re-rendering when the profile is unchanged.

POST /vault/:vaultId/runtime-profile

Auth HMAC + poolKey Rate limit 60 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/vault/vlt-abc123/runtime-profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.vaults.getRuntimeProfile("vlt-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

vault-runtime-profile[":vaultId"]

Field	Type	Description
`profile`	object	Runtime profile JSON payload
`hash`	string	Content hash for optimistic concurrency
`updatedOn`	number	Last update timestamp

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "profile": {
      "riskLimit": 100000,
      "allowedAssets": [
        "BTC",
        "ETH"
      ]
    },
    "hash": "sha256:a1b2c3...",
    "updatedOn": 1700000000000
  }
}

PRIVATE VAULTS

Set Vault Runtime Profile

Replaces the runtime profile of a vault with the provided payload (optimistic via expectedHash).

PUT /vault/:vaultId/runtime-profile/set

Auth HMAC + poolKey Rate limit 5 req/min URL params :vaultId

URL parameters

Name	Required	Description
`vaultId`	required	Vault identifier.

Body parameters

Name	Type	Required	Description
`profile`	object	required	Runtime profile body to apply.
`poolKey`	string	optional	Override the client-default pool key for this call.
`expectedHash`	string	optional	Expected runtime-profile hash for optimistic concurrency.

Request Example

cURL

curl -X PUT "https://trademire.ai/api/v1/$API_KEY/vault/vlt-abc123/runtime-profile/set" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","profile":{}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.vaults.setRuntimeProfile("vlt-abc123", { poolKey, profile: {} });

// 3. Inspect the parsed response
console.log(res);

Response Example

200 OK APPLICATION/JSON

{
  "success": true
}

PRIVATE VAULTS

Vault Action

PUT /vaults/action

Auth HMAC + poolKey Rate limit 5 req/min

Body parameters

Name	Type	Required	Description
`vaultId`	string	required	Vault identifier.
`action`	string	required	Action key (e.g. deploy, start, pause, stop).
`poolKey`	string	optional	Override the client-default pool key for this call.
`params`	object	optional	Action-specific parameters object.

Request Example

cURL

curl -X PUT "https://trademire.ai/api/v1/$API_KEY/vaults/action" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","vaultId":"vlt-abc123","action":"deploy"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.vaults.action({ poolKey, vaultId: "vlt-abc123", action: "deploy" });

// 3. Inspect the parsed response
console.log(res);

Response Example

200 OK APPLICATION/JSON

{
  "success": true
}

PRIVATE VAULTS

Vaults Help Map

Returns a structured JSON map of every endpoint in the Vaults category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /vaults/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/vaults/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.vaults.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "vaults",
  "help": {
    "paths": {
      "/vaults/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PRIVATE STRATEGIES

List Strategies

Returns the lean summary list of every strategy belonging to a pool: identifier, name, and status. Sorting, search, and pagination supported.

POST /strategies/list

Auth HMAC + poolKey Rate limit 30 req/min Pagination

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/strategies/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.strategies.list({ poolKey, pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

strategy-summary[":strategyId"]

Field	Type	Description
`name`	string	Human-readable strategy name
`status`	number	Current lifecycle status enum
`targetStatus`	number	Target lifecycle status
`relPoolKey`	string	Owning pool key
`relNodeId`	string	Host node id (if deployed)
`reportedOn`	number	Last status report timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "name": "arbitrage-btc-usdt",
      "status": 1000,
      "targetStatus": 1000,
      "relPoolKey": "pool_main",
      "relNodeId": "node_1",
      "reportedOn": 1700000000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PRIVATE STRATEGIES

Strategy Summary

Returns a single strategy summary by its ID (lean shape).

POST /strategy/:strategyId/summary

Auth HMAC + poolKey Rate limit 60 req/min URL params :strategyId

URL parameters

Name	Required	Description
`strategyId`	required	Strategy identifier.

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/strategy/str-abc123/summary" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.strategies.getSummary("str-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

strategy-summary[":strategyId"]

Field	Type	Description
`name`	string	Human-readable strategy name
`status`	number	Current lifecycle status enum
`targetStatus`	number	Target lifecycle status
`relPoolKey`	string	Owning pool key
`relNodeId`	string	Host node id (if deployed)
`reportedOn`	number	Last status report timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "name": "arbitrage-btc-usdt",
    "status": 1000,
    "targetStatus": 1000,
    "relPoolKey": "pool_main",
    "relNodeId": "node_1",
    "reportedOn": 1700000000000
  }
}

PRIVATE STRATEGIES

Strategy Detail

Returns the full strategy detail by id - configuration, signal pipeline, exposure rules, and runtime status. Pair with POST /v1/strategy/:strategyId/runtime-profile to fetch the runtime side.

POST /strategy/:strategyId

Auth HMAC + poolKey Rate limit 60 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/strategy/str-abc123" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.strategies.get("str-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

strategy[":strategyId"]

Field	Type	Description
`name`	string	Strategy name
`type`	string	Strategy type
`status`	string	Status as string
`isActive`	boolean	Is the strategy active
`createdOn`	number	Creation timestamp
`updatedOn`	number	Last update timestamp

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "name": "arbitrage-btc-usdt",
    "type": "arbitrage",
    "status": "active",
    "isActive": true,
    "createdOn": 1690000000000,
    "updatedOn": 1700000000000
  }
}

PRIVATE STRATEGIES

Strategy Runtime Profile

Returns the runtime profile (JSON + hash + controlDetails) for a strategy.

POST /strategy/:strategyId/runtime-profile

Auth HMAC + poolKey Rate limit 60 req/min URL params :strategyId

URL parameters

Name	Required	Description
`strategyId`	required	Strategy identifier.

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/strategy/str-abc123/runtime-profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.strategies.getRuntimeProfile("str-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

strategy-runtime-profile[":strategyId"]

Field	Type	Description
`profile`	object	Runtime profile JSON payload
`hash`	string	Content hash for optimistic concurrency
`controlDetails`	object	Control details blob from the parent strategy row
`tuneProfile`	boolean	Whether the strategy has profile tuning capabilities activated. When false, runtime profile updates are rejected.
`updatedOn`	number	Last update timestamp

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "profile": {
      "entrySpread": 0.002,
      "exitSpread": 0.0005
    },
    "hash": "sha256:a1b2c3...",
    "controlDetails": {
      "lastTunedBy": "user_1",
      "lastTunedOn": 1700000000000
    },
    "tuneProfile": true,
    "updatedOn": 1700000000000
  }
}

PRIVATE STRATEGIES

Set Strategy Runtime Profile

Replaces the runtime profile of a strategy with the provided payload (optimistic via expectedHash; rejected when the strategy has no profile tuning capabilities activated).

PUT /strategy/:strategyId/runtime-profile/set

Auth HMAC + poolKey Rate limit 5 req/min URL params :strategyId

URL parameters

Name	Required	Description
`strategyId`	required	Strategy identifier.

Body parameters

Name	Type	Required	Description
`profile`	object	required	Runtime profile body to apply.
`poolKey`	string	optional	Override the client-default pool key for this call.
`expectedHash`	string	optional	Expected runtime-profile hash for optimistic concurrency.

Request Example

cURL

curl -X PUT "https://trademire.ai/api/v1/$API_KEY/strategy/str-abc123/runtime-profile/set" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","profile":{}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.strategies.setRuntimeProfile("str-abc123", { poolKey, profile: {} });

// 3. Inspect the parsed response
console.log(res);

Response Example

200 OK APPLICATION/JSON

{
  "success": true
}

PRIVATE STRATEGIES

Strategy Action

PUT /strategies/action

Auth HMAC + poolKey Rate limit 5 req/min

Body parameters

Name	Type	Required	Description
`strategyId`	string	required	Strategy identifier.
`action`	string	required	Action key (e.g. deploy, start, pause, stop).
`poolKey`	string	optional	Override the client-default pool key for this call.
`params`	object	optional	Action-specific parameters object.

Request Example

cURL

curl -X PUT "https://trademire.ai/api/v1/$API_KEY/strategies/action" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","strategyId":"str-abc123","action":"deploy"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.strategies.action({ poolKey, strategyId: "str-abc123", action: "deploy" });

// 3. Inspect the parsed response
console.log(res);

Response Example

200 OK APPLICATION/JSON

{
  "success": true
}

PRIVATE STRATEGIES

Strategies Help Map

Returns a structured JSON map of every endpoint in the Strategies category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /strategies/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/strategies/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.strategies.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "strategies",
  "help": {
    "paths": {
      "/strategies/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PRIVATE NODES

List Nodes

Returns the lean summary list of every node belonging to a pool: identifier, name, and status. Sorting, search, and pagination supported.

POST /nodes/list

Auth HMAC + poolKey Rate limit 30 req/min Pagination

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/nodes/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.nodes.list({ poolKey, pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

node-summary[":nodeId"]

Field	Type	Description
`name`	string	Human-readable node name
`status`	number	Current lifecycle status enum
`targetStatus`	number	Target lifecycle status
`relPoolKey`	string	Owning pool key
`relServerId`	string	Host server id (if deployed)
`reportedOn`	number	Last status report timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "name": "eth-mainnet-1",
      "status": 1000,
      "targetStatus": 1000,
      "relPoolKey": "pool_main",
      "relServerId": "srv_1",
      "reportedOn": 1700000000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PRIVATE NODES

Node Summary

Returns a single node summary by its ID (lean shape).

POST /node/:nodeId/summary

Auth HMAC + poolKey Rate limit 60 req/min URL params :nodeId

URL parameters

Name	Required	Description
`nodeId`	required	Node identifier.

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/node/nod-abc123/summary" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.nodes.getSummary("nod-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

node-summary[":nodeId"]

Field	Type	Description
`name`	string	Human-readable node name
`status`	number	Current lifecycle status enum
`targetStatus`	number	Target lifecycle status
`relPoolKey`	string	Owning pool key
`relServerId`	string	Host server id (if deployed)
`reportedOn`	number	Last status report timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "name": "eth-mainnet-1",
    "status": 1000,
    "targetStatus": 1000,
    "relPoolKey": "pool_main",
    "relServerId": "srv_1",
    "reportedOn": 1700000000000
  }
}

PRIVATE NODES

Node Detail

Returns the full node detail by id - configuration, attached strategies, and runtime status. Use POST /v1/nodes/action to drive lifecycle (start, stop, restart) on the node.

POST /node/:nodeId

Auth HMAC + poolKey Rate limit 60 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/node/nod-abc123" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.nodes.get("nod-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

node[":nodeId"]

Field	Type	Description
`name`	string	Node name
`type`	string	Node type
`status`	string	Status as string
`isActive`	boolean	Is the node active
`ipAddress`	string	Latest reported IP address
`createdOn`	number	Creation timestamp
`updatedOn`	number	Last update timestamp

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "name": "eth-mainnet-1",
    "type": "execution",
    "status": "active",
    "isActive": true,
    "ipAddress": "10.0.0.42",
    "createdOn": 1690000000000,
    "updatedOn": 1700000000000
  }
}

PRIVATE NODES

Node Runtime Profile

Returns the runtime profile (JSON + hash) for a node.

POST /node/:nodeId/runtime-profile

Auth HMAC + poolKey Rate limit 60 req/min URL params :nodeId

URL parameters

Name	Required	Description
`nodeId`	required	Node identifier.

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/node/nod-abc123/runtime-profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.nodes.getRuntimeProfile("nod-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

node-runtime-profile[":nodeId"]

Field	Type	Description
`profile`	object	Runtime profile JSON payload
`hash`	string	Content hash for optimistic concurrency
`updatedOn`	number	Last update timestamp

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "profile": {
      "rpcUrl": "https://rpc.example",
      "maxConnections": 50
    },
    "hash": "sha256:a1b2c3...",
    "updatedOn": 1700000000000
  }
}

PRIVATE NODES

Set Node Runtime Profile

Replaces the runtime profile of a node with the provided payload (optimistic via expectedHash).

PUT /node/:nodeId/runtime-profile/set

Auth HMAC + poolKey Rate limit 5 req/min URL params :nodeId

URL parameters

Name	Required	Description
`nodeId`	required	Node identifier.

Body parameters

Name	Type	Required	Description
`profile`	object	required	Runtime profile body to apply.
`poolKey`	string	optional	Override the client-default pool key for this call.
`expectedHash`	string	optional	Expected runtime-profile hash for optimistic concurrency.

Request Example

cURL

curl -X PUT "https://trademire.ai/api/v1/$API_KEY/node/nod-abc123/runtime-profile/set" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","profile":{}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.nodes.setRuntimeProfile("nod-abc123", { poolKey, profile: {} });

// 3. Inspect the parsed response
console.log(res);

Response Example

200 OK APPLICATION/JSON

{
  "success": true
}

PRIVATE NODES

Node Action

PUT /nodes/action

Auth HMAC + poolKey Rate limit 5 req/min

Body parameters

Name	Type	Required	Description
`nodeId`	string	required	Node identifier.
`action`	string	required	Action key (e.g. deploy, start, pause, stop).
`poolKey`	string	optional	Override the client-default pool key for this call.
`params`	object	optional	Action-specific parameters object.

Request Example

cURL

curl -X PUT "https://trademire.ai/api/v1/$API_KEY/nodes/action" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","nodeId":"nod-abc123","action":"deploy"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.nodes.action({ poolKey, nodeId: "nod-abc123", action: "deploy" });

// 3. Inspect the parsed response
console.log(res);

Response Example

200 OK APPLICATION/JSON

{
  "success": true
}

PRIVATE NODES

Nodes Help Map

Returns a structured JSON map of every endpoint in the Nodes category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /nodes/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/nodes/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.nodes.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "nodes",
  "help": {
    "paths": {
      "/nodes/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PRIVATE SERVERS

List Servers

Returns the lean summary list of every server provisioned for a pool. Standard list shape with poolKey, search, sorting, and pagination.

POST /servers/list

Auth HMAC + poolKey Rate limit 30 req/min Pagination

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/servers/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.servers.list({ poolKey, pagination: { page: 1, limit: 50 } });

// 3. Inspect the parsed response
console.log(res);

Response schema

server-summary[":serverId"]

Field	Type	Description
`name`	string	Human-readable server name
`status`	number	Current lifecycle status enum
`targetStatus`	number	Target lifecycle status
`progress`	number	Lifecycle progress percentage (0-100)
`storeTypeKey`	string	Store type identifier (provider class)
`relPoolKey`	string	Owning pool key
`reportedOn`	number	Last status report timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "name": "srv-frankfurt-1",
      "status": 1000,
      "targetStatus": 1000,
      "progress": 100,
      "storeTypeKey": "aws-ec2",
      "relPoolKey": "pool_main",
      "reportedOn": 1700000000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PRIVATE SERVERS

Server Summary

Returns a single server summary by its ID (lean shape).

POST /server/:serverId/summary

Auth HMAC + poolKey Rate limit 60 req/min URL params :serverId

URL parameters

Name	Required	Description
`serverId`	required	Server identifier.

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/server/srv-abc123/summary" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.servers.getSummary("srv-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

server-summary[":serverId"]

Field	Type	Description
`name`	string	Human-readable server name
`status`	number	Current lifecycle status enum
`targetStatus`	number	Target lifecycle status
`progress`	number	Lifecycle progress percentage (0-100)
`storeTypeKey`	string	Store type identifier (provider class)
`relPoolKey`	string	Owning pool key
`reportedOn`	number	Last status report timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "name": "srv-frankfurt-1",
    "status": 1000,
    "targetStatus": 1000,
    "progress": 100,
    "storeTypeKey": "aws-ec2",
    "relPoolKey": "pool_main",
    "reportedOn": 1700000000000
  }
}

PRIVATE SERVERS

Server Detail

Returns the full server detail by id - hardware profile, network state, and runtime status. Pair with POST /v1/servers/action for lifecycle operations.

POST /server/:serverId

Auth HMAC + poolKey Rate limit 60 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/server/srv-abc123" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.servers.get("srv-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

server[":serverId"]

Field	Type	Description
`name`	string	Server name
`type`	string	Server type
`status`	string	Status as string
`isActive`	boolean	Is the server active
`ipAddress`	string	Latest reported IP address
`createdOn`	number	Creation timestamp
`updatedOn`	number	Last update timestamp

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "name": "srv-frankfurt-1",
    "type": "compute",
    "status": "active",
    "isActive": true,
    "ipAddress": "10.0.0.10",
    "createdOn": 1690000000000,
    "updatedOn": 1700000000000
  }
}

PRIVATE SERVERS

Server Runtime Profile

Returns the runtime profile (JSON + hash + controlDetails) for a server.

POST /server/:serverId/runtime-profile

Auth HMAC + poolKey Rate limit 60 req/min URL params :serverId

URL parameters

Name	Required	Description
`serverId`	required	Server identifier.

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/server/srv-abc123/runtime-profile" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.servers.getRuntimeProfile("srv-abc123", { poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

server-runtime-profile[":serverId"]

Field	Type	Description
`profile`	object	Runtime profile JSON payload
`hash`	string	Content hash for optimistic concurrency
`controlDetails`	object	Control details blob from the parent server row
`updatedOn`	number	Last update timestamp

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "profile": {
      "region": "eu-central-1",
      "instanceType": "t3.medium"
    },
    "hash": "sha256:a1b2c3...",
    "controlDetails": {
      "lastDeployBy": "user_1",
      "lastDeployedOn": 1700000000000
    },
    "updatedOn": 1700000000000
  }
}

PRIVATE SERVERS

Set Server Runtime Profile

Replaces the runtime profile of a server with the provided payload (optimistic via expectedHash).

PUT /server/:serverId/runtime-profile/set

Auth HMAC + poolKey Rate limit 5 req/min URL params :serverId

URL parameters

Name	Required	Description
`serverId`	required	Server identifier.

Body parameters

Name	Type	Required	Description
`profile`	object	required	Runtime profile body to apply.
`poolKey`	string	optional	Override the client-default pool key for this call.
`expectedHash`	string	optional	Expected runtime-profile hash for optimistic concurrency.

Request Example

cURL

curl -X PUT "https://trademire.ai/api/v1/$API_KEY/server/srv-abc123/runtime-profile/set" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","profile":{}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.servers.setRuntimeProfile("srv-abc123", { poolKey, profile: {} });

// 3. Inspect the parsed response
console.log(res);

Response Example

200 OK APPLICATION/JSON

{
  "success": true
}

PRIVATE SERVERS

Server Action

PUT /servers/action

Auth HMAC + poolKey Rate limit 5 req/min

Body parameters

Name	Type	Required	Description
`serverId`	string	required	Server identifier.
`action`	string	required	Action key (e.g. deploy, start, pause, stop).
`poolKey`	string	optional	Override the client-default pool key for this call.
`params`	object	optional	Action-specific parameters object.

Request Example

cURL

curl -X PUT "https://trademire.ai/api/v1/$API_KEY/servers/action" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","serverId":"srv-abc123","action":"deploy"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.servers.action({ poolKey, serverId: "srv-abc123", action: "deploy" });

// 3. Inspect the parsed response
console.log(res);

Response Example

200 OK APPLICATION/JSON

{
  "success": true
}

PRIVATE SERVERS

Servers Help Map

Returns a structured JSON map of every endpoint in the Servers category - HTTP method, description, rate limit, required and optional parameters, plus the field groups each endpoint returns. Useful for SDK and agent introspection.

GET /servers/help

Auth None Rate limit 30 req/min

Request Example

cURL

curl -X GET "https://trademire.ai/api/v1/$API_KEY/servers/help" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.servers.help();

// 3. Inspect the parsed response
console.log(res);

Response Schema

Field	Type	Description
`success`	boolean	Whether the call succeeded.
`category`	string	The category this help map describes.
`help`	object	Help map container. `paths` maps each endpoint path to its metadata (HTTP method, description, rate limit, required and optional parameters, `isListing` flag when applicable, and the field groups it references). `fieldGroups` maps each group name to its field descriptors (type and description) referenced from the path entries.

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "category": "servers",
  "help": {
    "paths": {
      "/servers/help": {
        "method": "GET",
        "description": "Returns this help map",
        "rateLimit": 30,
        "params": { "required": [], "optional": [] },
        "fieldGroups": []
      }
    },
    "fieldGroups": {}
  }
}

PRIVATE TRADING

List Orders

Returns the order history for a pool, scoped by the bound API key permissions. Supports search, sorting, and pagination; use the filter object to scope by status, market, or date range.

POST /orders/list

Auth HMAC + poolKey Rate limit 30 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/orders/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.trading.orders.list({ poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

order[":orderId"]

Field	Type	Description
`pair`	string	Trading pair (e.g. BTC_USDT)
`side`	string	Order side (buy or sell)
`type`	string	Order type (limit, market, stop, ...)
`status`	string	Lifecycle status (open, filled, cancelled, ...)
`price`	number	Order price (quote currency)
`quantity`	number	Order base quantity
`filled`	number	Filled base quantity
`fee`	number	Cumulative fee paid
`createdOn`	number	Creation timestamp (ms epoch)
`updatedOn`	number	Last update timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "pair": "BTC_USDT",
      "side": "buy",
      "type": "limit",
      "status": "filled",
      "price": 67200,
      "quantity": 0.05,
      "filled": 0.05,
      "fee": 3.36,
      "createdOn": 1700000000000,
      "updatedOn": 1700000060000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PRIVATE TRADING

Get Order

Returns the full detail for a single order - state, fills, fees, and lifecycle timestamps.

POST /order/:orderId

Auth HMAC + poolKey Rate limit 60 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/order/ord-abc123" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY"}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.trading.orders.get("ord-abc123", poolKey);

// 3. Inspect the parsed response
console.log(res);

Response schema

order[":orderId"]

Field	Type	Description
`pair`	string	Trading pair (e.g. BTC_USDT)
`side`	string	Order side (buy or sell)
`type`	string	Order type (limit, market, stop, ...)
`status`	string	Lifecycle status (open, filled, cancelled, ...)
`price`	number	Order price (quote currency)
`quantity`	number	Order base quantity
`filled`	number	Filled base quantity
`fee`	number	Cumulative fee paid
`createdOn`	number	Creation timestamp (ms epoch)
`updatedOn`	number	Last update timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "item": {
    "pair": "BTC_USDT",
    "side": "buy",
    "type": "limit",
    "status": "filled",
    "price": 67200,
    "quantity": 0.05,
    "filled": 0.05,
    "fee": 3.36,
    "createdOn": 1700000000000,
    "updatedOn": 1700000060000
  }
}

PRIVATE TRADING

List Trades

Returns the trade history for a pool. Each item is a fill (maker or taker) with price, quantity, fee, role, and the parent order id. Standard search / sort / pagination supported.

POST /trades/list

Auth HMAC + poolKey Rate limit 30 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/trades/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.trading.trades.list({ poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

trade[":tradeId"]

Field	Type	Description
`pair`	string	Trading pair
`side`	string	Trade side (buy or sell)
`price`	number	Execution price
`quantity`	number	Executed base quantity
`fee`	number	Fee paid for this fill
`createdOn`	number	Execution timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "pair": "BTC_USDT",
      "side": "buy",
      "price": 67200,
      "quantity": 0.05,
      "fee": 3.36,
      "createdOn": 1700000000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PRIVATE TRADING

List Balances

Returns balances per asset for a pool. Each item carries available (free for new orders), locked (reserved by open orders), and total. Standard search / sort / pagination supported.

POST /balances/list

Auth HMAC + poolKey Rate limit 30 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/balances/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.trading.balances.list({ poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

balance[":symbol"]

Field	Type	Description
`symbol`	string	Asset symbol (e.g. BTC, USDT)
`available`	number	Available balance for new orders
`locked`	number	Balance reserved by open orders
`total`	number	available + locked

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "symbol": "BTC",
      "available": 0.5,
      "locked": 0.05,
      "total": 0.55
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

PRIVATE TRADING

List Transactions

Returns the on/off-ramp ledger for a pool: deposits, withdrawals, and platform fees. Each item carries type, asset, amount, status, and an optional on-chain tx hash. Standard search / sort / pagination supported.

POST /transactions/list

Auth HMAC + poolKey Rate limit 30 req/min

Body parameters

Name	Type	Required	Description
`poolKey`	string	optional	Override the client-default pool key for this call.
`filtering`	object	optional	List filter object: search?: string, where?: { field, op, value }[].
`sorting`	object	optional	Sort object: { field, direction }. Direction is asc or desc.
`pagination`	object	optional	Page-based pagination: { page: number, limit: number }. page is 1-based; limit is between 10 and 100 (default 10). Response carries { currentPage, totalPages, pageSize, totalRows }.

Request Example

cURL

curl -X POST "https://trademire.ai/api/v1/$API_KEY/transactions/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data '{"poolKey":"YOUR_POOL_KEY","pagination":{"page":1,"limit":50}}'

Node.js

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
  poolKey:   process.env.POOL_KEY,
});

// 2. Send the signed request through the typed SDK method
let res = await client.trading.transactions.list({ poolKey });

// 3. Inspect the parsed response
console.log(res);

Response schema

transaction[":transactionId"]

Field	Type	Description
`type`	string	Transaction type (deposit, withdrawal, fee, ...)
`symbol`	string	Asset symbol
`amount`	number	Transaction amount
`fee`	number	Network or platform fee
`status`	string	Transaction status (pending, confirmed, failed, ...)
`txHash`	string	On-chain transaction hash if applicable
`createdOn`	number	Creation timestamp (ms epoch)

Response Example

200 OK APPLICATION/JSON

{
  "success": true,
  "items": [
    {
      "type": "deposit",
      "symbol": "BTC",
      "amount": 0.5,
      "fee": 0.0005,
      "status": "confirmed",
      "txHash": "0xabc",
      "createdOn": 1700000000000
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 1
  }
}

POST /v1/markets/list

BODY='{"pagination":{"page":1,"limit":50}}'
TS=$(date +%s%3N)
SIG=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "$API_SECRET" -hex | awk '{print $2}')
curl -X POST "https://trademire.ai/api/v1/$API_KEY/markets/list" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-API-Signature: $SIG" \
  -H "X-API-Timestamp: $TS" \
  --data "$BODY"

import { PlatformApiClient } from "@trademire/platform-api";

// 1. Configure the client with your API credentials
let client = new PlatformApiClient({
  baseUrl:   "https://trademire.ai/api/v1",
  apiKey:    process.env.API_KEY!,
  apiSecret: process.env.API_SECRET!,
});

// 2. Send the signed request through the typed SDK method
let res = await client.markets.list({
  pagination: { page: 1, limit: 50 },
});

// 3. Inspect the parsed response
if (!res.success) {
  console.error("List markets failed:", res.message);
} else {
  console.log(res.items.length, "markets");
}