If you’ve ever built a forex monitor, trading alert system, or real‑time currency dashboard, you’ve almost certainly run into this annoying problem:
Your real‑time rate API keeps sending data on weekends… but it’s just the same stale closing price from Friday.
The WebSocket stays alive, timestamps keep updating, and your system thinks it’s getting fresh data.
But the market is closed. This “fake data” triggers false alerts, pollutes your logic, wastes resources, and causes unnecessary headaches.
In this post, I’ll show you a lightweight, production‑ready filtering layer you can drop directly into your Python project to fix this for good.

The Problem We’re Solving
Many free and even commercial exchange rate APIs don’t check trading days.
They just keep sending the last available price during weekends and holidays.
This causes real pain:
Weekend alerts blowing up your notifications
Trading strategies misinterpreting stale prices
Logs and databases flooded with useless duplicates
Hours wasted debugging “ghost price movements”
The API isn’t broken — it’s just sending the latest value, not the latest valid trading value.
We have to validate data ourselves.

My 3‑Layer Filtering Logic
I built a simple but strong filter that runs before your business logic to reject bad data early.
Trading day check — skip data when markets are closed
Price change check — reject unchanged stale data
Timestamp check — block frozen or backward timestamps

Core Validation Function

`def is_valid_trading_data(price, timestamp, last_price, last_timestamp):
# Price unchanged = stale data
if price == last_price:
return False

# Timestamp not moving = invalid update
if timestamp <= last_timestamp:
    return False

# Not a trading day = skip entirely
if not is_trading_day():
    return False

return True`

Full WebSocket Implementation (using AllTick API as an example)
This example works with real‑time forex WebSocket streams and is ready to deploy.

`import websocket
import json
from datetime import datetime

last_price = None
last_ts = None

def on_message(ws, message):
global last_price, last_ts
data = json.loads(message)

current_price = data.get('price')
current_ts = data.get('timestamp')

# Skip on non-trading days
if not is_trading_day():
    print("Non-trading day — skipped")
    return

# Skip stale, unchanged prices
if current_price == last_price:
    print("Price unchanged — filtering stale data")
    return

# Only process valid data here
print(f"Valid exchange rate: {current_price}")
last_price = current_price
last_ts = current_ts

def is_trading_day():
# Monday–Friday are trading days
return datetime.now().weekday() < 5

Split WebSocket URL for safety

WS_DOMAIN = "wss://apis.alltick.co"
WS_PATH = "/websocket-api/stock-websocket-interface-api/transaction-quote-subscription"
ws_url = WS_DOMAIN + WS_PATH

Start WebSocket connection

ws = websocket.WebSocketApp(ws_url, on_message=on_message)
ws.run_forever()`

Production Improvements (For Devs Going Live)
To make this even more reliable:
Use a full‑year trading calendar instead of just weekday check
Add a data age threshold to reject delayed quotes
Log filtering rates to monitor API quality
Add error handling for WebSocket disconnects
These small upgrades make your system quiet on weekends and rock‑solid during market hours.

Key Takeaway
APIs don’t know your use case.
You must build a validation layer between raw data and your system.
This tiny filter completely eliminated false alerts, cleaned my data pipeline, and saved me hours of debugging.
If you’re working with real‑time APIs, WebSocket feeds, or financial data — this pattern will save you too.