By Felix – founder of unCoded, trading crypto since 2016.

Something important to share about where unCoded is heading.

Until now, unCoded has supported Binance Spot only. That was a deliberate constraint – doing one exchange properly before trying to do many poorly. It's also been the most common reason people couldn't use unCoded: they trade on Kraken, Coinbase, or somewhere else, and the product wasn't there yet.

That's about to change – carefully.

We've just completed the foundational architecture work to support 16 major crypto exchanges. All 16 are currently in internal alpha testing. They're not publicly available yet, and there's no firm release date, because we take security and stability seriously enough to not rush this.

Here's the honest status.

The 16 exchanges coming to unCoded

These are the exchanges being prepared for production support:

Global majors

Binance (already live)
Binance.US
Coinbase Advanced
Kraken
KuCoin
OKX
Bybit
Crypto.com
HTX (Huobi)
MEXC
Gate
BitMart
Bitfinex
BingX
Poloniex

EU-specific (MiCA-compliant)

Bitvavo (EUR-based, no USDT)
Bybit EU (USDC-based, no USDT)

These cover the exchanges where serious Spot traders actually operate. Each has been architected for properly – not bolted on through generic wrapper code, but handled with dedicated care for the specific quirks that make each exchange different from the others.

The hardest part: real-time execution across completely different architectures

Here's something worth understanding about how unCoded actually works, because it's the single biggest reason this rollout is taking longer than it looks like it should.

Most retail trading bots poll for data. The bot asks the exchange "what's the current price?" every 30 seconds, or 2 minutes, or 5 minutes depending on the platform. Between those checks, the bot is effectively blind. If price moves significantly within a check interval, the bot doesn't know until the next poll cycle. Stop losses can miss triggers. Take profits can execute late. Fast markets destroy strategies that depend on precise entries and exits.

unCoded doesn't work that way. unCoded operates on ticks – every single order book movement, every single trade, every single price change is processed as it happens. The bot maintains a live, continuously updated picture of each market it trades. When price moves, the bot knows within milliseconds, not minutes. When a stop level is approached, the bot is already watching. When execution windows open, the bot is already there.

This matters enormously for the strategies unCoded is built around. Micro-Trading relies on catching small price movements that would be invisible at 5-minute polling intervals. Per-split trailing stops require continuous price tracking to work correctly. Sell Time Curves need accurate timing data to adjust targets correctly. None of this functions on polling architecture. All of it requires tick-level market data processed in real time.

Implementing this on Binance took years. Binance has mature WebSocket infrastructure, well-documented streams, and behavior that's been stable enough to build against reliably. We know exactly how their order book stream behaves under load. We know how their trade stream handles reconnection. We know how their user data stream reports fills. We've tuned our processing pipeline specifically to Binance's characteristics.

Extending this to 16 other exchanges isn't a matter of changing a hostname. Every exchange has its own WebSocket behavior.

Some exchanges have excellent WebSocket support for everything we need. Others have it for market data but not for user account updates. Some have it but with latency characteristics that vary significantly by region. Some have it but disconnect more frequently than Binance, requiring different reconnection logic. Some have undocumented behavior that only emerges under specific load conditions.

A few exchanges don't have WebSocket support for certain critical data at all. For those, we've built REST polling fallbacks with cooperative cancel patterns, running at intervals calibrated not to exceed rate limits while still catching relevant events. But polling fallbacks are strictly inferior to true tick processing. A strategy that works beautifully on Binance's tick stream may behave differently on a REST-polled exchange, and we need to understand those differences before we tell users a strategy is safe to deploy.

The user-facing experience should be identical across exchanges. The underlying complexity varies dramatically. Making the first match despite the second is the engineering work that actually takes time.

Why it's taking time

Beyond the tick-processing architecture, every exchange has its own distinct quirks that have to be handled correctly.

Symbol conventions differ by exchange. Binance uses BTCUSDT. Kraken uses XXBTZUSD with an XBTUSD alias. BitMart uses BTC_USDT. HTX uses btcusdt lowercase. Bitfinex uses tBTCUSD with a t prefix. Getting all of these to resolve correctly when a user enters a symbol is non-trivial.

Error code formats differ. Binance uses numeric codes like -2015 for authentication failures. Coinbase uses gRPC-style strings like UNAUTHENTICATED. OKX has its own code scheme. HTX has another. Classifying these correctly matters because the bot's retry behavior depends on whether an error is "try again" versus "stop trading immediately."

Authentication models differ. Most exchanges use HMAC signatures. Coinbase Advanced uses PEM-based ES256 JWT signing. KuCoin and OKX require a passphrase in addition to key and secret. BitMart requires a UID (Memo) field. Each has to be handled correctly or the bot can't place orders.

Fee tokens and rebate systems differ. Binance has BNB discounts plus a broker rebate program through clientOrderId prefixes. Kraken has no fee token but uses userref as a 32-bit integer (not a string). OKX has its own broker tag mechanism. These details matter for users who care about squeezing every basis point of efficiency out of their trading.

Regional variants add complexity. Bybit EU uses the same API structure as Bybit Global but a different hostname (bybit.eu) and can't trade USDT due to MiCA regulations. Binance.US has the same API but different listed pairs and lower minimum order sizes. These regional differences can't be papered over – they have to be explicitly handled.

Testing all of this properly is the hardest part. We're not just checking that orders can be placed. We're verifying at the HTTP level what each exchange actually receives, testing error classification against 10-27 realistic error strings per exchange, and running 100+ checks per exchange against live public APIs. We're validating that tick streams maintain accurate order book state during reconnection events. We're checking that user data streams report fills correctly under load. We're measuring actual latency characteristics during periods of market volatility.

Every exchange so far has revealed bugs in our initial implementation that needed fixing before production use.

This is slow work. It should be slow work. Trading bot bugs on real capital are not the kind of thing you want to discover during live trading.

Where we are in the process

Here's the honest state of things.

All 16 exchanges have functioning adapters. They can authenticate, fetch market data, place and cancel orders, and stream trade events through real WebSocket connections or polling fallbacks where WebSocket support doesn't cover specific endpoints.

Each exchange has been tested with over 1,000 checks covering symbol normalization, error classification, API call structure, credential handling, order lifecycle management, and stream behavior under various network conditions.

We've already found and fixed bugs we would never have caught without deep testing. Some examples: misclassified error codes that would have caused wrong retry behavior during exchange outages. Symbol lookup failures that only emerged when testing against live data. Authentication issues that only surfaced with real production credentials. WebSocket reconnection behavior that differed between exchanges in ways that affected state consistency. Each of these would have hurt users in production if we'd released without finding them.

Despite all this work, we're still in internal alpha. That means small-scale testing with selected users, controlled environments, and extensive monitoring. It's not ready for broad release.

Why we're not rushing it

The temptation to ship faster is real. Every week we delay is a week users on other exchanges can't use unCoded. Competitors advertise "14+ exchanges" without nearly this level of architectural work and their users trade on those exchanges today.

But most of those competitors also don't process ticks. They poll every few minutes and call the result "multi-exchange support." When your competitor's architecture is fundamentally simpler, adding exchanges is fundamentally simpler. That's not the product we're building. The whole point of unCoded is execution quality that actually reflects what's happening in the market in real time, and extending that properly to new exchanges is genuinely harder than extending polling-based execution.

The commitments that built unCoded in the first place don't bend for release pressure:

Profit-sharing pricing means we only make money when users make money. A bot that loses user capital due to release bugs doesn't just hurt those users – it hurts the entire business model. We can't afford shortcuts the way subscription platforms can.

Self-hosted custody means bugs have different consequences. Users run this software on their own infrastructure with their own API keys. Mistakes in our code translate directly to mistakes on their exchange accounts. That's a different responsibility profile than cloud-hosted platforms where the company absorbs some of the operational risk.

Every exchange is genuinely different. The systematic audit of each exchange has revealed specific quirks – timestamp synchronization issues on OKX, balance-endpoint authentication on BitMart, symbol case sensitivity on HTX, userref integer conversion on Kraken, WebSocket reconnection behavior that varies across the entire set – that would have caused production failures if we'd released without addressing them. We expect to find more as testing continues.

The plan isn't to release all 16 exchanges on the same day. The plan is to graduate each exchange to production when it's ready, one at a time, with real user validation at each step. Some will be ready sooner than others.

What this means for current users

If you're using unCoded on Binance today, nothing changes. Your setup continues working exactly as before. No configuration changes needed. No migration required. The architecture work was specifically designed to preserve byte-identical Binance behavior while adding the foundation for other exchanges.

If you've been waiting for another exchange, the short answer is: it's coming, but we're not giving firm dates. The available information at any given time will be at uncoded.ch when specific exchanges move from alpha to production availability.

If you're curious about a specific exchange from the list, let us know through the account dashboard. Real user interest helps us prioritize which exchanges graduate first.

The honest summary

Supporting 16 exchanges properly is harder than supporting 50 exchanges loosely. The retail bot market has trained users to expect big numbers in marketing materials regardless of underlying quality. We're deliberately taking the opposite approach: smaller claims, higher quality, slower release cadence, and honesty about what's ready versus what's still being validated.

The tick-processing architecture that makes unCoded what it is also makes multi-exchange support fundamentally harder than the polling-based alternatives. That's a trade-off we accept because the alternative – slower execution, missed stops, polling intervals that turn into opportunity loss – isn't what serious traders need from a bot.

This is slower than our users want. It's also the only approach consistent with the pricing model, the custody model, and the execution architecture that make unCoded different from the subscription platforms it's designed to replace.

We'll announce exchange-by-exchange as each one graduates to production status. Until then, the 16 listed above are in active internal alpha. No timelines. No pre-sales. No early access. Just the slow work of making sure each one is ready before it touches user capital.

That's where we are. Honestly.

Felix is the founder of unCoded — a self-hosted, non-custodial crypto Spot trading bot with profit-sharing pricing. Documentation at uncoded.ch/docs. ArrowTrade AG, Switzerland.