📈 RealTime Trade Simulator & Orderbook Analysis

A Streamlit-based real-time trading dashboard for analyzing the OKX spot orderbook, simulating execution strategies, tracking latency, visualizing price spreads, and modeling slippage and market impact, it connects to the OKX WebSocket API to stream live order book data for selected spot assets. It provides real-time visualization of market depth metrics such as best bid/ask, spread, mid-price, volumes, latency monitoring, health status, and simulates basic order execution scenarios. The goal is to enable traders and analysts to monitor market liquidity and simulate order executions interactively in a clean, easy-to-use web interface.

Features 🚀

• 📡 Real-time WebSocket order book data from OKX WebSocket API (books5 channel)
• 📊 Mid-price & spread time series visualization
• ⚡ Latency & system health monitoring
• 🎯 Market/Limit execution simulation with volatility
• 🧠 Model-based slippage prediction & market impact estimation
• 🗎 Interactive parameter inputs- symbol, order type, quantity, volatility estimate, fee tiers, and refresh rate
• 💾 CSV export of historical order book data
• 📎 Modular architecture: models/, utils/, ws_client.py
• 💻 Display of key metrics:
  • Best Bid and Best Ask prices
  • Bid/Ask volumes
  • Spread and Mid Price over time
  • Latency measurement and health monitoring (Healthy / Warning / Unhealthy)

Project Structure 🗂️

RealTime-Trade-Simulator/
│
├── main.py                   # Streamlit app (UI + logic)
├── ws_client.py              # WebSocket client for orderbook
│
├── models/
│   ├── slippage_model.py     # Linear regression for slippage
│   ├── market_impact.py      # Almgren–Chriss model
│   └── maker_taker_model.py  # Logistic regression: maker vs taker
│
├── utils/
│   ├── latency_tracker.py    # Tracks system/network latency
│   ├── fee_model.py          # Tiered fee computation
│   └── data_utils.py         # Preprocess orderbook data
│
├── .env                      # Environment Variables
├── test_ws.py                # TestModule File
├── requirements.txt          # Python dependencies
└── README.md                 # Documentation (this file)

Architecture

• main.py : Main Streamlit application responsible for the user interface, real-time order book visualization, trading simulation, model interaction, and export functionalities.
• ws_client.py : WebSocket client managing the connection to OKX's public WebSocket API. Handles subscription, reconnection logic, and parsing of live order book data.
• models/slippage_model.py : Implements a linear regression model to estimate slippage based on order size and market depth.
• models/market_impact.py : Applies the Almgren–Chriss model to evaluate the market impact of large trades over time.
• models/maker_taker_model.py : Uses logistic regression to predict whether a trade will be a maker or taker based on live order book features.
• utils/latency_tracker.py : Measures and logs system and network latency to monitor real-time performance.
• utils/fee_model.py : Calculates trading fees based on tiered fee structure, accounting for maker and taker differences.
• utils/data_utils.py : Provides utility functions for preprocessing and structuring order book data.
• .env : Environment configuration file storing sensitive data such as WebSocket URLs or API credentials.
• requirements.txt : Lists all Python dependencies required to install and run the application.
• test_ws.py : Standalone test script to validate WebSocket connectivity and data integrity.
• README.md : Documentation file providing an overview, setup instructions, and project structure.

Installation 🛠️

• First Read this License & their terms then proceed.
• Star ⭐ the Repository
• Fork the repository (Optional)
• Project Setup:

1. Clone the Project

git clone https://github.com/UjjwalSaini07/RealTime-Trade-Simulator.git

2. Navigate to the project Root directory:

cd RealTime-Trade-Simulator

2. Install dependencies

pip install -r requirements.txt

3. Create a .env file in the root directory and Setup Contact

Usage 🖥️

• Run the Streamlit app:

python -m streamlit run main.py

• The dashboard will open in your default browser: http://localhost:8501/

Project Setup Using Docker Containerization:

1. Start the Docker Engine Locally or Use Any Service
2. Navigate to the project Root directory:

    cd RealTime-Trade-Simulator

3. Run DockerFile:

    docker-compose up --build

4. Wait for Generating the Image

How Docker Image Builds Looks

Docker Image Starts the Server Locally

Project Docker Container WebSockets Data Fetching

5. Now Simply use the Project using Docker Container

Dashboard Panels

• Metrics: Shows current best bid/ask, spread, mid price, bid/ask volumes, latency, and health status.
• Charts: Real-time line charts for mid price, spread, and latency over time.
• Latency & Health Monitoring: Shows latency trends and health status based on latency thresholds.
• Execution Simulation: Displays simulated execution results based on order type and market conditions.
• Export Data: Button to download historical order book snapshots and metrics as CSV.

Model Documentation 🧠

1. Slippage Model

Path: models/slippage_model.py

• Model: Linear Regression
• Purpose: Estimate price deviation from order size, volatility, and spread.
• Features: order_size_usd, market_volatility, spread_percent
• Target: slippage_bps

2. Market Impact Model

Path: models/market_impact.py

• Framework: Almgren–Chriss
• Assumptions:
  • Linear coefficients for temporary and permanent impact
  • Liquidity proxy via market volume
• Equation:
  impact = η * (Q / V) + λ * (Q / V)^2
  • Q: order size
  • V: market volume
  • η, λ: impact coefficients

3. Maker vs Taker Model

Path: models/maker_taker_model.py

• Model: Logistic Regression
• Purpose: Predict limit order execution likelihood.
• Features: spread, volatility, order_type, relative_price_distance

Utility Modules 🧰

1. utils/latency_tracker.py : Measures roundtrip latency for WebSocket events and internal app cycles.

2. utils/fee_model.py : Supports tiered maker-taker fee structures (OKX Tier 1, 2, 3).

3. utils/data_utils.py : Converts OKX order book ticks into normalized pandas DataFrames.

Performance Optimization ⚙️

• @st.cache_resource to avoid re-instantiating WebSocket clients
• deque with maxlen for lightweight time series
• DataFrames rebuilt only from live updates
• Streamlit container reuse to reduce render load

Future Enhancements 🧭

Feature	Description
🔌 FastAPI Backend	Refactor core logic into a FastAPI backend to support RESTful and WebSocket endpoints for scalable API-based integration.
📱 Mobile Dashboard	Build a responsive frontend using React Native or Flutter to access real-time analytics from mobile devices.
📦 Redis Caching Layer	Introduce Redis for efficient storage and retrieval of real-time market data and reduce load on WebSocket listeners.
📈 Historical Backtesting Engine	Implement a module for backtesting execution strategies using historical tick data.
🔐 User Authentication	Add secure login with role-based access (e.g., admin vs. analyst) using OAuth2 or Firebase.
🧪 CI/CD & Dockerization	Containerize the entire system and set up CI/CD pipelines with GitHub Actions and Docker Compose.

Contact 📞

Feel free to reach out if you have any questions or suggestions!

• Email: Mail
• Github: @Ujjwal Saini

Screenshots 📷

Trading Dashboard

Terminal Data Retrieval

Video Demonstration 📷

Project_Demonstration.mp4