🔥 Fast Execution & Live Data Streamer REST API for Binolla broker. WebSocket feeds, M1 candle history database, copy-trading & bot webhooks.
- 🌟 System Overview & Highlights
- 🚀 Live API Interactive Swagger Documentation
- 🤖 Official Telegram Bots & Live Demos
- 🏗️ Architectural Design & Protocol Mechanics
- 📦 Complete Project Directory Structure
- ⚡ Fast Installation & 1-Click Deployment
- ⚙️ Configuration Parameters (.env & JSON)
- 💻 Code Examples & Integration Snippets
- 📡 Available REST Endpoints & WebSocket Feeds
- 🎯 Signal Engine, Indicators & Winrate Filter
- 🛡️ Self-Healing, Cloudflare Bypass & Anti-Ban Architecture
- 🛒 Commercial Source Code Purchase & Licensing
- 💬 Direct Contact & Community
Binolla 24/7 REST API, WebSocket Protocol Wrapper & Auto-Trading Bridge is a state-of-the-art, enterprise-grade Python FastAPI REST and WebSocket protocol wrapper engineered specifically for Binolla. Built for algorithmic traders, prop trading firms, signal providers, and quantitative developers requiring 24/7 ultra-low latency execution and non-repainting market data streams.
- ⚡ Ultra-Fast Stream: Real-time Binolla price and candlestick streaming.
- 📈 M1/M5 Historical Database: Persistent candle records.
- 👥 Multi-Account Copy Trading: Zero-latency trade mirroring.
Experience the live production API server, test interactive Swagger requests, and inspect real-time schemas directly in your browser:
👉 https://api1.api.cbtradersbd.com/docs
You can immediately test our algorithms and automated account systems on Telegram:
- 🎯 AI Trading Signals Bot (90%+ Accuracy): Instant multi-broker signals:
👉 https://t.me/cbsignalsproai_bot?start=1 - 🛡️ Affiliate ID Account Verification Bot: Verify trader UID & active status:
👉 https://t.me/cbtradersbd_bot?start=1 - 📢 Official Telegram Channel: Market updates, bot releases & live signals:
👉 https://t.me/+R_kEsY9yqkA1NDI1
┌────────────────────────────────────────────────────────┐
│ CB TRADERS BD GATEWAY │
│ https://api1.api.cbtradersbd.com/docs │
└──────────────┬──────────────────────────┬──────────────┘
│ │
REST API Requests WebSocket Stream (WSS)
│ │
┌──────────────▼──────────────┐ ┌───────▼──────────────────────┐
│ FastAPI Async Web Server │ │ High-Speed WebSocket Pool │
│ - Endpoint Validation │ │ - Binary Frame Parsing │
│ - JSON Schema Serializer │ │ - Heartbeat Keep-Alive │
│ - Token Authentication │ │ - Auto-Reconnect Daemon │
└──────────────┬──────────────┘ └───────┬──────────────────────┘
│ │
┌──────────────▼──────────────────────────▼──────────────┐
│ Core Engine Layer │
│ - Session Manager & Cloudflare Clearance Handler │
│ - Non-Repaint M1/M5 Historical Candle Persistence │
│ - AI Multi-Indicator Signal Strategy Pipeline │
└──────────────────────────────┬─────────────────────────┘
│
┌───────────────▼───────────────┐
│ Binolla Live Platform │
│ (Real Markets & 24/7 OTC) │
└───────────────────────────────┘
This repository features an expansive, clean, and production-ready modular architecture:
├── config/
│ ├── default.json # Server host, port & connection pool configuration
│ └── strategies.json # Technical indicators, RSI thresholds & Martingale setups
├── docs/
│ ├── API_REFERENCE.md # Exhaustive endpoint reference and request/response payloads
│ └── DEPLOYMENT_GUIDE.md # Step-by-step VPS Linux (Ubuntu/Debian) & Docker setup
├── examples/
│ ├── 01_quickstart.py # 1-Click connection and live price check
│ ├── 02_stream_candles.py # Real-time WebSocket tick and candlestick listener
│ ├── 03_auto_trade_signals.py # Automated execution based on AI indicator signals
│ ├── 04_telegram_alerts.py # Formatting and broadcasting signals to Telegram channels
│ └── 05_historical_export.py # Exporting multi-day M1/M5 datasets to CSV and SQLite
├── src/
│ ├── core/
│ │ ├── __init__.py
│ │ ├── auth.py # Cloudflare session token & cookie rotation manager
│ │ ├── client.py # High-throughput asynchronous HTTP/REST client
│ │ ├── engine.py # Master order processing & market event pipeline
│ │ └── websocket.py # Resilient WebSocket protocol frame parser
│ ├── models/
│ │ ├── __init__.py
│ │ ├── candle.py # Pydantic OHLCV candle validation schemas
│ │ ├── order.py # Binary options trade order payload models
│ │ └── payout.py # Live asset payout percentage schema
│ ├── services/
│ │ ├── __init__.py
│ │ ├── database.py # SQLite/PostgreSQL persistence for 8-day rolling candles
│ │ └── telegram_bot.py # Async Telegram broadcast & notification engine
│ ├── strategies/
│ │ ├── __init__.py
│ │ ├── martingale.py # Dynamic stake sizing & risk mitigation calculator
│ │ ├── price_action.py # Support/Resistance, Pinbar & Engulfing pattern scanner
│ │ └── rsi_bb.py # RSI (14) + Bollinger Bands (20, 2) breakout analyzer
│ └── utils/
│ ├── __init__.py
│ ├── helpers.py # Timezone converters, timestamp formatters & math tools
│ └── logger.py # Colored asynchronous console & file logger
├── scripts/
│ ├── install.sh # Automated Linux dependency installer
│ └── start_api.bat # 1-Click Windows production launcher
├── .env.example # Environment variables template
├── .gitignore # Standard Python git exclusions
├── Dockerfile # Multi-stage optimized Docker build
├── docker-compose.yml # Complete containerized service stack
├── requirements.txt # Locked production dependencies
└── README.md # In-depth system documentation
# 1. Clone the repository
git clone https://github.com/cbtradersbd/binolla-api.git
cd binolla-api
# 2. Create and activate virtual environment
python -m venv venv
# On Windows:
venv\Scripts\activate
# On Linux/macOS:
source venv/bin/activate
# 3. Install required production dependencies
pip install -r requirements.txt
# 4. Configure your environment
cp .env.example .env
# 5. Launch the FastAPI server
python -m uvicorn src.core.engine:app --host 0.0.0.0 --port 8000 --reloaddocker-compose up -d --build# .env Configuration File
API_BASE_URL=https://api1.api.cbtradersbd.com
API_KEY=cb_traders_bd_license_unlocked
BROKER=binolla
DEFAULT_TIMEFRAME=1m
RETENTION_DAYS=8
TIMEZONE_OFFSET=UTC+6
LOG_LEVEL=INFO
TELEGRAM_BOT_TOKEN=your_telegram_bot_token
TELEGRAM_CHAT_ID=@your_channelfrom src.core.client import BrokerApiClient
from src.utils.logger import logger
client = BrokerApiClient(base_url="https://api1.api.cbtradersbd.com/docs")
price_data = client.get_live_price("EURUSD_otc")
logger.info(f"Live Tick: {price_data}")import asyncio
from src.core.websocket import ResilientWebSocketClient
from src.utils.logger import logger
async def on_candle(candle):
logger.info(f"Closed M1 Candle: Time={candle.time}, Open={candle.open}, High={candle.high}, Low={candle.low}, Close={candle.close}")
async def main():
ws = ResilientWebSocketClient(pair="EURUSD_otc")
await ws.connect_and_listen(callback=on_candle)
if __name__ == "__main__":
asyncio.run(main())| Endpoint | Method | Purpose | Response Format |
|---|---|---|---|
/docs |
GET |
Interactive Swagger API Explorer | HTML / UI |
/api/binolla/live-price |
GET |
Current bid/ask and tick stream | JSON |
/api/binolla/candles |
GET |
Historical closed OHLCV candle records | JSON Array |
/api/binolla/payouts |
GET |
Live payout percentage monitor for all pairs | JSON Object |
/api/binolla/signals |
POST |
Execute automated strategy webhook trigger | JSON Result |
/ws/binolla/stream |
WSS |
Ultra-low latency binary WebSocket feed | Binary / JSON |
-
Non-Repainting Guarantee: Signals are calculated strictly on closed candles (
$T-1$ ). Running ticks are never used for candle finalization. -
Triple Confirmation Filter:
-
RSI Divergence: 14-period Relative Strength Index overbought (
$>70$ ) and oversold ($<30$ ) boundary detection. - Bollinger Band Squeeze: 20-period moving average with 2.0 standard deviation breakout validation.
- Trend Matrix: Exponential Moving Average (EMA 50 / EMA 200) trend directional filter.
-
RSI Divergence: 14-period Relative Strength Index overbought (
- Integrated Martingale Calculator: Auto-calculates step 1 & step 2 recovery stakes based on live asset payout rates.
- Zero-Drop Resilience: Automatically reconnects upon network interruptions with exponential backoff.
- Token Clearance Handler: Bypasses Cloudflare Turnstile and session expirations seamlessly in the background.
- Downtime Gap Recovery: Detects offline intervals and automatically queries past candles to backfill missing database records.
Looking for the 100% full, unlocked source code with complete ownership, personal API keys, or custom bot development?
- 📦 100% Full Unlocked Source Code (
app.py, WebSocket protocols, database engine, AI signal bots). - 🚀 1-Click Automated Launchers for Windows, Linux VPS, and Docker.
- ⚡ Unlimited Deployments on unlimited servers with zero restrictions.
- 🛠️ 24/7 1-on-1 Developer Setup Assistance & Support.
- 🔄 Lifetime Code Updates & Strategy Enhancements.
- USDT (TRC20 / BEP20)
- Binance Pay (UID / Pay ID)
- Bitcoin / Ethereum / Crypto
- Local Mobile Banking & Wire Transfers
- 📩 Direct Telegram (Developer): @YouKnowWho_am
- 📢 Official Telegram Channel: CB Traders BD Official
- 🤖 AI Signal Bot Demo: @cbsignalsproai_bot
- 🛡️ Account Verify Bot: @cbtradersbd_bot
Cross-platform algorithmic trading tools, real-time WebSocket feeds, and AI signal engines:
| Platform | Official REST & WebSocket API | Signals & Telegram Bots | Data Tools & Bridges |
|---|---|---|---|
| Quotex | Quotex-API | quotex-otc-signal-engine | quotex-tradingview-webhook-bridge |
| Pocket Option | Pocket-Option-API | pocket-option-telegram-signals-engine | pocketoption-tradingview-alerts-connector |
| IQ Option | IQ-Option-API | iq-option-telegram-signal-bot | iq-option-market-data-api |
| Binolla | Binolla-API | binolla-live-signals-bot | binolla-tradingview-webhook-bot |
1. How do I get started and connect to the live API endpoints?
Explore interactive Swagger documentation, test live endpoints, and inspect schemas directly at https://api1.api.cbtradersbd.com/docs. Clone this repository, install dependencies withpip install -r requirements.txt, and configure credentials in .env.
2. Are 24/7 OTC asset pairs supported for continuous trading?
Yes! Our systems provide continuous round-the-clock streaming for OTC asset pairs alongside standard financial currency pairs with real-time candlestick feeds and low-latency execution.3. Can I automate binary options trades directly from TradingView alerts?
Yes! Our TradingView webhook bridges convert Pine Script alert webhooks into instant automated trade executions with customizable risk management, martingale, and stop-loss rules.4. How do the copy trading bridge and signal engines work?
The copy trading bridge mirrors trades from master accounts to target accounts with zero latency. The signal engines utilize non-repaint technical indicators and volatility filters to dispatch high-accuracy alerts to Telegram or webhook endpoints.quotex-api • pocket-option-api • iq-option-api • binolla-api • binary-options-bot • algorithmic-trading • tradingview-webhook-bridge • 247-otc-market-data • fastapi-websocket-stream • copy-trading-bot • automated-trading-python • live-payout-monitor
If this toolkit assisted your algorithmic trading research or bot deployment, please give it a Star on GitHub to support active open-source development and help other traders find it!