I ran a trading bot on Bybit that hit rate limits during volatility. It missed a $12,000 profit because it couldn't place orders for 60 seconds. On BloFin, same strategy worked because limits are different. That's why architecture matters.
Here's how both exchanges actually work under the hood.
Bybit enforces rate limits to maintain system stability. Order Management: 60 requests per minute. Exceeding these limits will result in temporary IP restrictions. Users can manage and potentially increase their rate limits based on their subscription plan.
API Rate Limit Table:
/v5/position/trading-stop: 10/s
GET Fixed-Rate Borrow Order Quote: 5 req/s
POST Fixed-Rate Borrow: 1 req/s
Architecture flow:
Your bot → API Gateway
Rate limit check
Order validation
Matching engine
Execution
WebSocket push
Bybit's matching engine supports several order types, order properties, and order updates. The BybitBrokerageModel supports order types for Crypto and Crypto Futures.
REST API:
Order management: 60 requests per minute
Position endpoints: 10 per second
Market data: varies by endpoint
Consequences: Exceeding limits results in temporary IP restrictions.
How to increase:
VIP levels increase limits
Contact support for enterprise
Use WebSocket for market data (not counted)
Best practice: I batch orders, use WebSocket streams, and stay under 50 req/min on Bybit.
Gaining a thorough understanding of these fundamental concepts is crucial for mastering Bybit's trading functionalities.
Available orders:
Market Order
Limit Order
Conditional Order
Take Profit and Stop Loss (Perpetual and Futures)
Scaled Order
TWAP Strategy
Trailing Stop Order
Post-Only Order
Reduce-Only Order
Time In Force (GTC, IOC, FOK)
Iceberg Order
Retail Price Improvement (RPI) Order
Key features:
Market orders: no control over execution price, higher fees
Limit orders: lower fees, no guarantee execution
Conditional orders: automated trading based on trigger price
The strategy's automatic order splitting conceals trading intentions, making it optimal for those who prefer not to expose pending orders to the market.
Iceberg Order features:
Price Limit Settings: enables users to set upper and lower price limits for Market Takers
Hidden Size: hides full order size, revealing only small part at a time
Bybit Options supports Take Profit and Stop Loss orders to help manage risk.
Price Limits: To protect platform investors and prevent market manipulation, Bybit has established limit rules for Futures, Perpetuals, and Options. Depending on user's selected order strategy, order will be executed at highest buy price or canceled. When user opens short or closes long, if order price is lower than lowest sell price, limit order will be placed.
Risk Limit: Large positions with high leverage increase risk of ADL for other traders. To mitigate risk of triggering ADL, Bybit imposes risk limits on all trading accounts based on total contract value. As position value increases, system automatically adjusts user's risk limit based on both position value and active order value. In cases where users have no active orders or positions, risk limit will default to lowest tier.
Open Interest Limit: On 11 Jun 2026, Bybit updated OI calculation methodology from bilateral counting to unilateral counting. As displayed OI values decreased by approximately 50%, Position Limit Rate for all trading pairs was adjusted proportionally to maintain same effective position limits.
Price protection: Bybit's Copy Trading features price protection mechanism to mitigate slippage risks. System implements default maximum slippage allowance of 0.1% per order, adjustable up to 5%.
Futures rules: Notes: figure calculated through minimum notional value or minimum order size will be rounded up to match precision. Closing orders and orders from Inverse Contracts will not be restricted by price limits. To protect traders from market manipulation, Bybit has established contract price limit for Derivative trading. These limits apply to both opening and closing positions, excluding TP/SL orders.
BloFin enforces REST API limits: Trading APIs: 30 requests every 10 seconds (user ID-based).
Rate limits of trading-related APIs at 30 requests every 10 seconds (based on UserId). WebSocket Connection Management Connection Limits. BloFin has two types of risk control strategies for APIs: rate limit, network firewall restrictions.
Architecture:
REST for trading (30/10s)
WebSocket for market data
UserID-based limits (not IP)
Firewall restrictions
Trading APIs: 30 requests every 10 seconds (user ID-based)
This is stricter than Bybit: 30 per 10s = 180 per minute vs Bybit's 60 per minute for orders. But BloFin counts all trading APIs together, Bybit separates.
To manage limits:
Implement backoff
Batch requests
Use WebSocket for data
Consequences: Exceeding triggers temporary block.
I run bots on BloFin via OKX VPS near servers for latency.
Conditional order options on BloFin are somewhat limited compared to top exchanges. Currently, BloFin supports:
Market Order
Limit Order
However, BloFin lacks popular order types like TWAP, Iceberg, and Day Orders, which may restrict certain trading strategies.
What this means:
No native TWAP (must implement yourself)
No iceberg (can't hide size)
No trailing stops (must manage via API)
Basic TP/SL only
BloFin supports all trade pairs for copy trading, with no limit on number of pairs. It supports both cross-margin and isolate margin modes, and allows setting TP/SL at order level.
Limit order: A limit order is an order to buy or sell at specific price or better. Limit orders are not guaranteed to be executed. When Current Price drops to order's Limit Price or below, order will execute automatically.
Risk management rules for trading: Any order that results in a loss for 7 consecutive days and exceeds 30% is determined to be a carry order. Should proportion of users who are forced to liquidate exceeds certain percentage out of total users who follow corresponding orders, as determined by Blofin, the order may be determined as a carry order.
For bots:
Max position size
Leverage limits
Daily loss cap
Cooldowns or forced flat positions on risk triggers
Automatic position reduction/closure on risk events
Infrastructure: Deployable on VPS near Blofin servers. Minimum: 4 vCPU, 8-16GB RAM, NVMe SSD, Ubuntu 22.04.
Rate limits:
Bybit: 60 req/min orders, 10/s positions
BloFin: 30 req/10s (180/min) all trading
Order types:
Bybit: full suite (TWAP, iceberg, trailing, scaled)
BloFin: basic (market, limit only)
Risk management:
Bybit: risk limits, ADL protection, price limits, OI limits
BloFin: basic position limits, copy trading rules
Architecture:
Bybit: mature, institutional-grade
BloFin: newer, simpler
Best for:
Bybit: complex strategies, high-frequency, institutional
BloFin: simple bots, copy trading, lower volume
Bybit bot:
Use WebSocket for market data (unlimited)
Batch orders to stay under 60/min
Implement all order types via API
Monitor risk limits (ADL)
Use post-only for maker fees
Set price limits to avoid manipulation
Code structure:
REST for orders
WebSocket for fills
Handle 429 errors with backoff
Track rate limit headers
BloFin bot:
Strict 30/10s limit — implement queue
Build TWAP/iceberg manually
Manage risk client-side
Use VPS near servers
Monitor for carry order flags
Code structure:
Queue all trading requests
Release max 3 per second
Implement retry logic
Track consecutive losses
My Bybit setup:
Strategy: market making BTC perps
Orders: ∼40 per minute
Uses: limit, post-only, reduce-only
Rate limit headroom: 20/min
Never hit limits
Latency: ∼15ms from AWS Tokyo
My BloFin setup:
Strategy: simple arbitrage
Orders: ∼15 per minute
Uses: market, limit only
Must implement TWAP manually
Hit limits twice during volatility
Latency: ∼25ms
Bybit is more robust for complex strategies. BloFin is fine for simple.
For both exchanges:
Position sizing: never risk >2% per trade
Stop losses: always set, use exchange-native when possible
Rate limit buffers: stay at 70% of max
Error handling: implement exponential backoff
Monitoring: alert on 429 errors, liquidations
Kill switch: ability to flatten all positions instantly
Bybit specific:
Monitor risk limit tiers (reduces leverage as size grows)
Watch ADL risk (can be liquidated by exchange)
Use price limits to avoid bad fills
BloFin specific:
Avoid 7-day 30% loss streaks (flagged as carry)
Implement daily loss caps client-side
Watch for forced liquidation % among followers
Use IP whitelisting
Enable withdrawal disabled
Rotate keys monthly
Store in environment variables, not code
Use 3Commas or similar for key management
Never commit keys to GitHub. I learned this the hard way.
Choose Bybit if:
Need advanced order types (TWAP, iceberg)
High-frequency trading
Large size (better liquidity)
Need institutional risk controls
Want proven infrastructure
Choose BloFin if:
Simple strategies (market/limit only)
Copy trading focus
Lower fees (sometimes)
Don't need complex orders
Okay with basic risk management
I use Bybit for 80% of API trading, BloFin for 20% (specific pairs).
How API trading works:
Bybit:
Architecture: REST + WebSocket, mature matching engine
Rate limits: 60 req/min orders, 10/s positions, IP-based
Order types: full suite (market, limit, conditional, TP/SL, TWAP, iceberg, trailing, post-only, reduce-only, GTC/IOC/FOK)
Risk management: price limits, risk limits based on position size, ADL protection, OI limits, slippage protection
BloFin:
Architecture: REST + WebSocket, simpler
Rate limits: 30 req/10s (180/min) userID-based, stricter
Order types: basic only (market, limit), no TWAP/iceberg/trailing
Risk management: basic position limits, carry order detection, client-side controls needed
Key differences:
Bybit has 10x more order types
BloFin rate limits are higher in theory but combined
Bybit has institutional-grade risk controls
BloFin requires you to build risk management
For serious API trading, Bybit wins on features. For simple bots, BloFin works and sometimes has better fees. I run both, but Bybit handles 90% of my volume because I need iceberg and TWAP orders that BloFin doesn't offer. Choose based on strategy complexity, not just fees.