FAQ: Trading Fundamentals
What every integrator should understand about stablecoin ↔ Bitcoin trading before they build.
What Is a Trade?
In its simplest form, a trade is an exchange of one asset for another.
You sell something (e.g. USDT)
You buy something else (e.g. Bitcoin)
The trade executes at a specific rate
There may be fees, spread, or slippage depending on how it’s structured
The Bitnob Trading API lets you do exactly this — programmatically — with USDT and Bitcoin. But to build a reliable experience, you need to understand what happens behind the scenes.
What Is a Quote?
A quote is a temporary offer to trade at a specific rate.
Think of it as:
“Right now, $100 will get you 225,000 sats — but only if you act within the next 30 seconds.”
Quotes have:
Rate – The exchange rate being offered (e.g. 2,250 sats per $0.01)
Amount – What you’re trying to trade (input) and what you’ll get (output)
Expiry – How long the quote is valid for (usually 30 seconds)
Quotes let you lock pricing, which is critical in volatile markets or UX-driven flows.
What Is a Spread?
The spread is the difference between the price someone gets and the actual market rate.
Example:
Real market rate: 2,300 sats per cent
Bitnob gives you: 2,250 sats per cent
Difference = your spread = potential earnings
Spreads are how trading desks and platforms earn revenue. In Bitnob, you can:
Use the raw rate
Apply your own spread (markup) to earn per trade
What Does "Atomic" Mean?
An atomic trade means:
It either executes fully or not at all
You’ll never receive a partial amount
If something goes wrong (e.g., price moved, balance insufficient), the trade fails cleanly
This gives you reliability when building user-facing products or treasury flows.
Why Do Quotes Expire?
Markets move. Fast.
If a quote was valid forever:
You’d be able to exploit pricing changes
It would create financial risk for whoever offered it
That’s why Bitnob quotes have an expiresAt. If you try to execute a trade after the expiry:
The API returns an error
You need to fetch a new quote
Good UX practice: show a timer or disable the “Confirm” button when expired.
How Are Prices Determined?
Bitnob sources pricing from:
Centralized exchanges (Binance, Kraken, etc.)
OTC desks (for high-volume execution) Internal routing and liquidity logic
You don’t need to manage any of that — just understand:
The quote is trusted and executable
Bitnob handles routing, slippage, and fill behind the scenes
Your system receives the rate and output it was promised, or nothing at all
What Are Sats and Cents?
Sats = Satoshis, the smallest unit of Bitcoin. Cents = Smallest unit of USDT (i.e., $0.01)
| Asset | Smallest Unit | Example |
|---|---|---|
| Bitcoin | 1 sat | 100,000 sats = 0.001 BTC |
| USDT | 1 cent | 10,000 cents = $100.00 |
The Bitnob API always uses these smallest units to avoid floating-point errors in money.
What Happens During Execution?
Here’s what you trigger when you call POST /trades/execute:
Bitnob validates the quote (if provided)
Checks wallet balance for source asset
Executes trade via internal engine
Credits output asset to destination wallet
Emits a trade.completed webhook You reconcile in your ledger or UI
If something fails (expired quote, balance issue), you get a clean error and no funds are moved.
What If I Just Want Live Pricing?
You can fetch quotes using GET /trades/quote without ever executing a trade.
This is useful if:
You want to show market rates to users in real time
You want to simulate pricing before initiating real trades
You’re building a quote engine for a remittance or pricing calculator
Bitnob does not charge for quotes. Use them freely, but cache responsibly.
What’s My Responsibility as an Integrator?
Handle quotes responsibly (don’t execute expired ones)
Be idempotent (use a unique reference for each trade)
Reconcile trades and wallet balances
Use webhooks to track state — don’t rely solely on HTTP responses
Educate your users if you’re exposing pricing to them
In Short:
You’re converting assets. You need to treat that with financial-grade care.
Bitnob abstracts the hard parts — liquidity, execution, settlement
You build the experience — rate transparency, user trust, and business logic
