FAQ: Trading Fundamentals

What every integrator should understand about stablecoin, Bitcoin, and naira (NGN) trading before they build.

What Is a Trade?

In its simplest form, a trade is an exchange of one asset for another — on the API it is an order, created with Create Order.

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, USDC, Bitcoin, and NGN. 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, created with the Quotes endpoint and re-readable with Get Quote by ID.

Think of it as:

“Right now, $100 will get you 225,000 sats but only if you act within the next few 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 (about 30 seconds in development, 10 seconds in production)

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. (For an indicative rate with no expiry attached, use Get Prices instead of locking a quote.)

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 uses these smallest units for USDT and Bitcoin to avoid floating-point errors in money. NGN is the exception — it trades in whole naira (major units), not a smaller sub-unit.

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