Developers · Updated 17 November 2026
Seeds API v1
A Binance-style REST API for the Seeds exchange. Public market data needs no key. Signed endpoints let a bot place and cancel orders for your account. API keys can never withdraw. Point an existing Binance-style client at the base URL below and most calls may work, but check the supported endpoints, parameters and non-custodial account model first.
Base URL https://seeds.honest.money/api/public/v1
Where things stand
Public market data
LiveDepth, trades, klines, tickers, exchange info, SSE stream and the CoinMarketCap feed. No key needed.
Signed reads
LiveAccount, open orders, order history, order status and your trades.
Order entry and cancel
LiveLIMIT / GTC orders join the same book as the website and match immediately. MARKET orders take the best prices within a price protection (default 2%) and cancel whatever is left.
Settlement from HME Wallet trading pockets
Being builtFills from accounts that trade through a linked HME Wallet pocket record as matched and wait for settlement. Fills settle on-chain right away only for accounts that still hold an earlier Seeds trading authorization.
Withdrawals
LiveNot possible through the API, by design. There is no withdrawal endpoint and no scope that adds one.
Quick start
- Sign in to Seeds with Honest.Money using your own account.
- On Profile, link your HME Wallet trading pocket. A link is not a deposit into a Seeds balance.
- Open Profile → API keys.
- Create a key with a descriptive label. Choose read for a dashboard, or read + trade for a bot that places and cancels orders. Optionally restrict it to your bot’s public outbound IP addresses.
- Copy the key ID and the secret immediately: the secret is shown once. Store them in your server’s secret manager or environment as
SEEDS_KEYandSEEDS_SECRET. If you lose the secret, create another key. - Check connectivity and server time with the unsigned requests below. Neither needs a key.
- Run one of the signed
GET /accountexamples below. InspecttradingPocketandauthorizationsbefore attempting any trading.
curl -sS "https://seeds.honest.money/api/public/v1/ping" curl -sS "https://seeds.honest.money/api/public/v1/time"
Public data, signed reads, order entry and cancellation are live. Settlement through linked HME Wallet pockets is still being built: a match is not proof of settlement. Only accounts with earlier Seeds trading authorizations currently settle immediately. A new pocket link alone does not make end-to-end bot settlement live.
Markets
Every market is priced in TSD except TSD/USDC. Symbols are base + quote with no separator. TXC_TSD, TXC/TSD and TXC-TSD are accepted too. Read /exchangeInfo at startup for the live list.
| Symbol | Market | Base settles as | Quote settles as |
|---|---|---|---|
| TXCTSD | TXC / TSD | TXC on TEXITcoin | TSD (Omni #39 on TEXITcoin) |
| TSDUSDC | TSD / USDC | TSD (Omni #39 on TEXITcoin) | USDC on EVM |
| LTCTSD | LTC / TSD | LTC on Litecoin | TSD (Omni #39 on TEXITcoin) |
| ISKTSD | ISK / TSD | ISK on Iskandercoin | TSD (Omni #39 on TEXITcoin) |
| ZCUTSD | ZCU / TSD | ZCU on ZeroChill | TSD (Omni #39 on TEXITcoin) |
| BTCTSD | BTC / TSD | BTC, settled as Omni #43 | TSD (Omni #39 on TEXITcoin) |
| ETHTSD | ETH / TSD | ETH, settled as Omni #45 | TSD (Omni #39 on TEXITcoin) |
| PLSTSD | PLS / TSD | PLS on PulseChain | TSD (Omni #39 on TEXITcoin) |
| HEXTSD | HEX / TSD | HEX on Ethereum | TSD (Omni #39 on TEXITcoin) |
| pHEXTSD | pHEX / TSD | pHEX (HEX on PulseChain) | TSD (Omni #39 on TEXITcoin) |
BTC and ETH trade as their native coins. Behind the scenes they settle as Omni tokens issued by TSD Swap. /exchangeInfo reports this as baseSettlementChain.
How Seeds differs from a normal exchange
- No exchange balance. Members sign in with Honest.Money and link a trading pocket from HME Wallet. Savings never leave the wallet.
/accountreturns that pocket and its addresses instead of exchange credits. - Two pocket modes. With instant access, Seeds can sign for the trading pocket while it stays linked. With approve every trade, the intended settlement flow requires approval in HME Wallet. Pocket settlement is still being built; neither mode implies it is live.
/accountreports the linked mode. - API keys can never withdraw. Scopes are
readandtradeonly. A stolen key can place or cancel orders but cannot withdraw, but unauthorized trades can still cause losses within your trading authorizations. Add an IP allowlist to limit access. - Fills settle on-chain. A settled fill is a real transfer between the two members.
/myTradesreturns each settlement leg with its txid and confirmations. See Where things stand for which accounts settle today. - No fees today. Maker and taker commission are both 0.
- Streams are SSE, not WebSocket. The same push updates over plain HTTP, and
EventSourcereconnects automatically.
Authentication
Create a key on the API keys page after signing in. The secret is shown once. Signed endpoints use HMAC-SHA256 the same way Binance does:
- Send your key ID in the
X-SEEDS-APIKEYheader. - Add
timestamp(unix ms) and, optionally,recvWindow(default 5000, max 60000 ms). Timestamps more than 1 second in the future are rejected. - Sign the query string, without
signature, followed by the raw request body if there is one. Appendsignature(hex) as the last query parameter.
Use the complete examples in Signing a request, step by step. Keep the secret on a trusted server, never in browser code.
Signing a request, step by step
- Build your parameters, including a fresh
timestampin Unix milliseconds and optionallyrecvWindow. Serialize once as a URL-encoded query string. Parameter order is not sorted by the server: use exactly the order and encoding you will send. - For GET and DELETE, the payload is that raw query string alone; bodies are ignored. For other methods, concatenate the query string with the raw body, with no added separator. Bodies are parsed as URL-encoded form fields, not JSON; body values override query values for parameter lookup.
- Compute HMAC-SHA256 over the UTF-8 payload using the secret’s literal UTF-8 text (do not hex-decode it). Encode the digest as hex. The examples use lowercase; the verifier also accepts uppercase hex.
- Append
&signature=and the digest as the last query parameter. Do not include the question mark, URL, method, headers or signature itself in the payload. Send the key ID inX-SEEDS-APIKEY. - Send the exact bytes you signed. Never re-sort or re-encode parameters afterward. The verifier slices the raw query at
&signature=, so parameters must not follow the signature.
The examples keep every parameter in the query and send no body, including for POST. This avoids query/body ambiguity. All three read credentials from your environment and make the same first signed call. Do not enable shell tracing or log signed URLs.
Bash + curl + OpenSSL
Requires Bash, curl, OpenSSL and Python 3 (only for a portable millisecond clock). Set your real credentials in the environment first.
#!/usr/bin/env bash
set -euo pipefail
: "${SEEDS_KEY:?Set SEEDS_KEY}" "${SEEDS_SECRET:?Set SEEDS_SECRET}"
BASE="https://seeds.honest.money/api/public/v1"
timestamp=$(python3 -c 'import time; print(int(time.time() * 1000))')
qs="recvWindow=5000×tamp=$timestamp"
# printf adds no newline. The secret is literal text, not hex bytes.
sig=$(printf '%s' "$qs" | openssl dgst -sha256 -hmac "$SEEDS_SECRET" | awk '{print $NF}')
curl -sS --header "X-SEEDS-APIKEY: $SEEDS_KEY" "$BASE/account?$qs&signature=$sig"OpenSSL’s command-line secret may be visible in the local process list. Run this demonstration only on a trusted machine; use an in-process HMAC library for a production bot.
Node.js (18+, save as bot.mjs)
import { createHmac } from "node:crypto";
const BASE = "https://seeds.honest.money/api/public/v1";
const { SEEDS_KEY: KEY, SEEDS_SECRET: SECRET } = process.env;
if (!KEY || !SECRET) throw new Error("Set SEEDS_KEY and SEEDS_SECRET");
async function signed(method, path, params = {}) {
const qs = new URLSearchParams({
...params, recvWindow: "5000", timestamp: String(Date.now()),
}).toString();
const sig = createHmac("sha256", SECRET).update(qs, "utf8").digest("hex");
const res = await fetch(`${BASE}${path}?${qs}&signature=${sig}`, {
method, headers: { "X-SEEDS-APIKEY": KEY },
});
const data = await res.json();
if (!res.ok) throw new Error(`HTTP ${res.status}: ${JSON.stringify(data)}`);
return data;
}
console.log(await signed("GET", "/account"));Python 3 + requests
Install the dependency with python3 -m pip install requests, then run this as a server-side script.
import hashlib, hmac, os, time
from urllib.parse import urlencode
import requests
BASE = "https://seeds.honest.money/api/public/v1"
KEY = os.environ["SEEDS_KEY"]
SECRET = os.environ["SEEDS_SECRET"].encode("utf-8")
def signed(method, path, **params):
params.update(recvWindow="5000", timestamp=str(int(time.time() * 1000)))
qs = urlencode(params)
sig = hmac.new(SECRET, qs.encode("utf-8"), hashlib.sha256).hexdigest()
res = requests.request(method, f"{BASE}{path}?{qs}&signature={sig}",
headers={"X-SEEDS-APIKEY": KEY}, timeout=30)
data = res.json()
if not res.ok:
raise RuntimeError(f"HTTP {res.status_code}: {data}")
return data
print(signed("GET", "/account"))Recipes
These snippets use the Node.js signed(method, path, params) helper above. Reads require read scope; order creation and cancellation require trade scope. Every invocation signs a fresh timestamp.
1. Place a limit order
Read /exchangeInfo first and choose a symbol, price and quantity matching its filters. This example is a real BUY if executed, not a sandbox. LIMIT with GTC is the default; MARKET is shown in the next example. The response includes orderId, fills and settlements; retain them.
const placed = await signed("POST", "/order", {
symbol: "TXCTSD", side: "BUY", type: "LIMIT", timeInForce: "GTC",
price: "0.05", quantity: "100",
});
console.log(placed);1b. Place a market order
A MARKET order sends quantity only, with no price or timeInForce. It fills against the best resting orders right away, never below (sell) or above (buy) maxSlippagePct from the best price at the moment it arrives (default 2, max 10). Anything left is cancelled and the order ends FILLED or EXPIRED; it never rests on the book. If nothing is on the other side, it is rejected with -2010. The response carries seedsPriceProtection (the worst price allowed) and a real cummulativeQuoteQty.
const bought = await signed("POST", "/order", {
symbol: "TXCTSD", side: "BUY", type: "MARKET",
quantity: "100", maxSlippagePct: "2",
});
console.log(bought.status, bought.executedQty, bought.cummulativeQuoteQty);A match may still await settlement. After a timeout, inspect open orders, order history and fills before deciding whether to place again. There is no client order ID/idempotency parameter in the handler; blindly retrying can create a second order.
2. Cancel an order
// Use the orderId returned by your own order, not a symbol or client ID.
console.log(await signed("DELETE", "/order", { orderId: placed.orderId }));Cancel only works for your open or partially filled orders. A fill can race with cancellation; reconcile order status and trades rather than assuming nothing executed.
3. List open orders
console.log(await signed("GET", "/openOrders", { symbol: "TXCTSD" }));
// Omit symbol to include all markets.
console.log(await signed("GET", "/openOrders"));The implementation returns at most 500 open/partial orders, newest first. There is no pagination parameter on this endpoint.
4. Poll my trades
const seen = new Set(); // Persist IDs in a database in production.
async function pollTrades() {
const trades = await signed("GET", "/myTrades", {
symbol: "TXCTSD", limit: "500",
});
for (const trade of trades) {
if (!seen.has(trade.id)) {
seen.add(trade.id);
console.log("New fill", trade);
}
// Reconcile settlement status/legs for already-seen IDs too.
}
}
await pollTrades(); // Schedule subsequent calls within your weight budget.symbol is optional. limit defaults to 500 and is clamped to 1–1000. There is no since/fromId cursor: poll frequently enough for your volume, persist IDs, and do not assume this bounded response is a complete historical ledger.
5. Subscribe to public market SSE
curl -N "https://seeds.honest.money/api/public/v1/stream?symbol=TXCTSD&streams=ticker,depth,trade&interval=2000"
No API key or signature is needed. This is public market data, not a private order/fill stream. Listen for named events; reconnect when the connection ends (curl does not do this automatically). Browser EventSource reconnects automatically, but a custom close handler must not call its permanent close() method if you expect reconnection. See the stream section for bounded history and event details.
Keeping your key safe
- Use an IP allowlist for a bot with stable outbound networking. Matching is exact string membership against the server-observed source IP, not CIDR/subnet matching. Include the public egress address, not a private LAN address. An empty list imposes no IP restriction.
- Use read-only keys for dashboards and separate keys for each bot. Enable trade scope only where needed. A trade-only key does not implicitly include read scope.
- Disable pauses a key and can be reversed; delete removes it permanently. Both prevent subsequent authentication; neither is an order-cancellation operation. Inspect and cancel unwanted open orders separately using another authorized key or the website.
- Rotate by creating a replacement, storing its one-time secret, deploying and testing it, then disabling/deleting the old key. For a suspected leak, disable/delete immediately rather than waiting for a graceful rollout.
- Never embed the secret in browser JavaScript, a mobile bundle, public repository or logs. Sign on a trusted server. Protect both credentials with a secret manager; avoid logging signed URLs and request headers.
- Synchronize the bot host’s clock (for example with NTP) and compare with
/time.recvWindowdefaults to 5000 ms and is capped at 60000 ms. Requests older than the window or more than 1000 ms ahead are rejected. Generate a new timestamp and signature for each request; widening the window is not a substitute for clock sync. - A leaked read key exposes account/order information. A leaked trade-capable key can place/cancel orders within your account’s trading authorizations and cause losses, but can never withdraw. Disable/delete it, inspect orders and trades, rotate credentials, and review/revoke wallet links and trading authorizations if needed.
Troubleshooting
Errors have numeric code and text msg. Branch on code; keep secrets and signed URLs out of diagnostic logs.
-1022— “Signature for this request is not valid”: check the secret belongs to this key, use literal secret text, remove any trailing newline, preserve exact query encoding/order, append signature last, and include the raw form body for POST (but not GET/DELETE).-1021— “Timestamp for this request is outside of the recvWindow”: use Unix milliseconds, sync your clock, avoid queued/stale signed URLs, and account for the 1000 ms future tolerance. Re-sign after adjusting time.-1004— “Source IP not in key allowlist”: check the bot’s public egress IPv4/IPv6 address and exact allowlist entries. A nonempty list also rejects requests where the server cannot identify a source IP.-1002— “API key lacks 'read' scope” or “API key lacks 'trade' scope”: use a key explicitly granted the scope required by that method. Trade scope does not grant read.-2015— “Missing X-SEEDS-APIKEY header” or “Invalid or disabled API key”: send the key ID (not the secret), check the environment and whether the key is disabled/deleted.-1102— “Missing signature”, “Missing timestamp” or “Missing orderId”: supply the required value in the correct location. Always explicitly send a numeric timestamp; omission is not a valid signing strategy.-1003, HTTP 429 — “Request weight limit exceeded, back off”: stop sending requests until the next fixed minute window, add jitter, and reduce polling across all processes sharing that key. The budget is 1200 weighted units, not 1200 calls.-1013: check the price/quantity validation message and/exchangeInfofilters.-1014: use LIMIT (GTC) or MARKET (no timeInForce, no price).-1121: use a listed symbol.-1130: use BUY/SELL.-2010: read the order rejection message and check your linked trading setup/authorizations. Do not treat a pending settlement as a settled transfer.-2011: refresh order status; it may already be filled/canceled or not yours.-2013: verify the order ID and account; the status handler searches the latest 1000 orders.-1100: check the named parameter, such as kline interval.-1000: back off on server failures; for an ambiguous order submission, reconcile before retrying.
Endpoints
All paths below are relative to https://seeds.honest.money. The public in the path means the address is reachable without a website login. Signed endpoints still need a key.
| Method | Path | Weight | Notes |
|---|---|---|---|
| GET | /api/public/v1 | — | Endpoint index (JSON). |
| GET | /api/public/v1/openapi.json | — | OpenAPI 3 spec. |
| GET | /api/public/v1/ping | — | Connectivity check. |
| GET | /api/public/v1/time | — | Server time in unix ms. Sync before signing. |
| GET | /api/public/v1/exchangeInfo | — | Symbols, filters, precision, rate limits. |
| GET | /api/public/v1/depth | — | Order book. symbol, limit (default 100, max 1000). |
| GET | /api/public/v1/trades | — | Recent public trades. symbol, limit (default 500, max 1000). |
| GET | /api/public/v1/klines | — | OHLCV candles. symbol, interval, limit (default 500, max 1000). |
| GET | /api/public/v1/ticker/24hr | — | 24h stats for one symbol, or every market when omitted. |
| GET | /api/public/v1/ticker/price | — | Last price for one symbol, or every market when omitted. |
| GET | /api/public/v1/stream | — | SSE stream of ticker, depth and trade events. |
| GET | /api/public/v1/account | 10 | SIGNED, read. Trading pocket, addresses and live trading authorizations. |
| GET | /api/public/v1/openOrders | 6 | SIGNED, read. Working orders, optional symbol. |
| GET | /api/public/v1/allOrders | 10 | SIGNED, read. Order history, optional symbol, limit (max 1000). |
| GET | /api/public/v1/order | 4 | SIGNED, read. One order by orderId. |
| GET | /api/public/v1/myTrades | 10 | SIGNED, read. Fills with settlement legs and txids, limit (max 1000). |
| POST | /api/public/v1/order | 20 | SIGNED, trade. New LIMIT / GTC or MARKET order. |
| DELETE | /api/public/v1/order | 4 | SIGNED, trade. Cancel by orderId. |
A new order returns Binance’s usual fields plus fills (trade IDs) and settlements (what happened to each matched trade).
Account response
GET /api/public/v1/account
{
"accountType": "SPOT",
"custody": "non-custodial",
"canTrade": false, // true when at least one unexpired, unrevoked legacy authorization exists
"canWithdraw": false, // always false
"makerCommission": 0,
"takerCommission": 0,
"tradingPocket": { // null when no HME Wallet pocket is linked
"mode": "instant", // "instant" or "approve"
"account": 1106, // HME Wallet pocket number
"linkedAt": 1794900000000,
"addresses": { "TXC": "T...", "LTC": "ltc1...", "EVM": "0x..." }
},
"addresses": { ... }, // earlier Seeds wallet addresses, if any
"authorizations": [ ... ] // earlier capped, expiring trading authorizations
}Pocket numbers change when a member revokes and relinks, because HME Wallet moves them to a fresh pocket. Read /account again rather than caching addresses.
Filters
Every current market quotes in a stable dollar (TSD or USDC). Those markets share these filters. /exchangeInfo is always the source of truth.
PRICE_FILTER tickSize 0.000001 minPrice 0.00000001 maxPrice 1000000 LOT_SIZE stepSize 0.00000001 minQty 0.0001 maxQty 100000000 MIN_NOTIONAL 1.00 (price × quantity, in the quote asset) Order types LIMIT (timeInForce GTC) and MARKET (quantity only, maxSlippagePct default 2, max 10)
Rate limits
Signed endpoints share a budget of 1200 request weight per key per minute, counted in a fixed one-minute window. Going over returns HTTP 429 with code -1003. Wait for the next minute.
Public endpoints aren’t counted per key. Many market-data responses advertise 2–5 seconds of caching; this is not a guarantee that repeated requests return identical data. Use the stream for ongoing market updates.
Streaming (SSE)
curl -N "https://seeds.honest.money/api/public/v1/stream?symbol=TXCTSD&streams=ticker,depth,trade&interval=2000"
event: open
data: {"symbol":"TXCTSD","streams":["ticker","depth","trade"],"intervalMs":2000}
event: ticker
data: {"symbol":"TXCTSD","lastPrice":"0.05000000", ...}interval: how often to push, 1000–30000 ms (default 2000).depthevents carry the top 50 levels.tradeevents start with the latest trade, then send new trades from the most recent 50 since the previous poll. This is not a durable replay feed: reconnects can duplicate events and busy periods can lose history. Deduplicate by trade ID and reconcile with REST.- Connections close after 10 minutes with a
closeevent ({"reconnect":true}). Reconnect, whichEventSourcedoes for you. - Event types:
open,ticker,depth,trade,close,error.
Klines
Intervals: 1m 3m 5m 15m 30m 1h 2h 4h 6h 12h 1d 1w. Candles are built from the most recent 1000 trades. Intervals with no trades are skipped rather than filled, so treat a gap as “no trades.” Each row is [openTime, open, high, low, close, volume, closeTime, quoteVolume, trades].
CoinMarketCap feed
Listing sites can read Seeds in CoinMarketCap’s “Ideal API” format. Pairs use BASE_QUOTE form, for example TXC_TSD.
| /api/public/cmc | Index and market list |
| /api/public/cmc/assets | Asset list |
| /api/public/cmc/summary | Market summary |
| /api/public/cmc/ticker | 24h ticker |
| /api/public/cmc/orderbook/{market_pair} | Order book. depth (default 100, max 500), level 1, 2 or 3 |
| /api/public/cmc/trades/{market_pair} | Recent trades. limit (default 100, max 500) |
Errors
Errors return a numeric code and a message, so bots branch on the code, not the text: {"code":-1022,"msg":"Signature for this request is not valid"}
| -1000 | Unknown server error, retry later |
| -1002 | API key lacks the scope this endpoint needs |
| -1003 | Request weight limit exceeded (HTTP 429) |
| -1004 | Source IP not in the key's allowlist |
| -1013 | Price or quantity outside the symbol's filters |
| -1014 | Unsupported order type or time in force |
| -1021 | Timestamp outside recvWindow |
| -1022 | Signature not valid |
| -1100 | Invalid parameter value (for example a kline interval) |
| -1102 | Missing required parameter |
| -1121 | Invalid symbol |
| -1130 | side must be BUY or SELL |
| -2010 | Order rejected |
| -2011 | Cancel rejected: order not open or not yours |
| -2013 | Order does not exist |
| -2015 | Missing, invalid or disabled API key |

