We integrate a real-time NFT floor price tracking system that combines multiple sources to protect against manipulation. A wash trader places a listing at 0.001 ETH to artificially drive the floor down and buy the panic. Or the opposite — removes cheap listings before a large sale. A tracking system that simply polls the OpenSea API once a minute won't give you an accurate picture. A monitoring error costs real money: traders lose up to 30% on wrong entries. Our system saves you from these losses, potentially saving $500+ monthly for active traders. We build real-time monitoring from multiple sources simultaneously, including on-chain data, so you see the true floor.
Why floor price is a tricky metric
Market manipulation. Wash trading (trading with yourself) and spoofing (placing/removing listings) are daily practice on popular collections. Public marketplace APIs have delays from 30 seconds to 15 minutes, enough for fast attacks. Only a combination of multiple sources and on-chain verification gives a reliable picture.
Source limitations. Each marketplace shows only its own listings. The real market floor is the minimum across all platforms.
| Marketplace | Endpoint | Delay | Rate limit |
|---|---|---|---|
| OpenSea v2 | GET /api/v2/collections/{slug}/stats |
5-15 min | 4 req/s (free) |
| Blur | Unofficial / reverse-engineered | ~1 min | No public |
| LooksRare | GET /api/v1/collections/stats | ~1 min | 5 req/s |
| Reservoir | GET /collections/v7 | ~30 sec | 10 req/s (free) |
Reservoir is an aggregator that normalizes data from all marketplaces. For most tasks it is the best single source of truth, especially on their free tier (10 req/s is enough for monitoring several dozen collections).
How to distinguish the true floor from manipulation
The most reliable way is to compare oracles: if OpenSea shows 0.1 ETH but on-chain trades record sales at 0.08 ETH in the same block, manipulation is present. We use a statistical filter: a sudden drop without a corresponding volume increase is a red flag. The algorithm automatically ignores suspicious listings until confirmed on the secondary market.
Technical Implementation
How we build real-time monitoring
On-chain events give the true real-time floor. We subscribe via WebSocket to Seaport contracts (events OrderValidated, OrderCancelled, OrderFulfilled) and Blur Pool (events NewPool, DepositERC721). Delay is 100-500ms from block confirmation — orders of magnitude faster than any REST polling.
System architecture:
┌─────────────────────────────────────────────┐ │ Data Ingestion Layer │ │ ┌──────────┐ ┌──────────┐ ┌─────────────┐ │ │ │ OpenSea │ │Reservoir │ │ WebSocket │ │ │ │ Poller │ │ Poller │ │ Listener │ │ │ └────┬─────┘ └────┬─────┘ └──────┬──────┘ │ └───────┼────────────┼──────────────┼──────────┘ │ │ │ └────────────┴──────────────┘ │ Redis Streams │ ┌────────────┴──────────────┐ │ Aggregation Worker │ │ (compute true floor, │ │ detect anomalies) │ └────────────┬──────────────┘ │ ┌────────────┴──────────────┐ │ TimescaleDB / ClickHouse │ │ (time-series storage) │ └────────────┬──────────────┘ │ └────────────┴──────────────┘ │ ┌────────────┴──────────────┐ │ WebSocket Push API │ │ (client alerts) │ └───────────────────────────┘ Redis Streams buffer peak loads and guarantee delivery to aggregation. A single source failure does not break the system — data from other sources continues to flow.
How to compute the true floor
The aggregation worker receives snapshots from Redis Streams, discards data older than 2 minutes, and picks the minimum price among fresh ones.
interface FloorSnapshot { collectionAddress: string; floorPriceWei: bigint; floorPriceEth: number; source: 'opensea' | 'blur' | 'looksrare' | 'reservoir' | 'onchain'; timestamp: number; listingsCount: number; } function computeTrueFloor(snapshots: FloorSnapshot[]): bigint { const fresh = snapshots.filter(s => Date.now() - s.timestamp < 120_000); if (fresh.length === 0) throw new Error('No fresh data'); return fresh.reduce((min, s) => s.floorPriceWei < min ? s.floorPriceWei : min, fresh[0].floorPriceWei); } Time-series storage: TimescaleDB
We create a hypertable with time-based partitioning for efficient queries.
CREATE TABLE floor_snapshots ( time TIMESTAMPTZ NOT NULL, collection TEXT NOT NULL, floor_eth DOUBLE PRECISION, volume_24h DOUBLE PRECISION, source TEXT ); SELECT create_hypertable('floor_snapshots', 'time'); CREATE INDEX ON floor_snapshots (collection, time DESC); -- Continuous aggregate for 1-hour OHLC CREATE MATERIALIZED VIEW floor_1h WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, collection, first(floor_eth, time) AS open, max(floor_eth) AS high, min(floor_eth) AS low, last(floor_eth, time) AS close FROM floor_snapshots GROUP BY bucket, collection; Alerting System
Two signals are truly useful for traders: floor drop (decrease >X% in Y minutes) and sweep alert (accumulation of cheap listings in 1-5 blocks). A sweep often precedes a price increase.
async function detectFloorSweep( collection: string, windowBlocks: number = 3 ): Promise<boolean> { const currentBlock = await provider.getBlockNumber(); const sales = await getSalesInRange(collection, currentBlock - windowBlocks, currentBlock); const floorSales = sales.filter(s => s.priceEth <= currentFloor * 1.02); // ±2% of floor return floorSales.length >= SWEEP_THRESHOLD; // e.g., 5 sales in 3 blocks } Clients subscribe to collections via WebSocket (Node.js + ws or Socket.IO). When floor changes >1%, broadcast to all subscribers.
Deployment and Support
What's included in a turnkey development
| Component | Status |
|---|---|
| Polling Reservoir + OpenSea (base) | Included |
| WebSocket listener on Seaport/Blur | Included |
| TimescaleDB storage + aggregations | Included |
| REST API for history | Included |
| WebSocket push alerts | Included |
| Integration documentation (Swagger) | Included |
| Deployment to your server/cloud | Optional |
| Team training | Optional |
| 1 month support | Included |
Our expertise and guarantees
More than 5 years of experience in blockchain development, 20+ successful projects in smart contracts and NFT infrastructure. We guarantee stable system operation: 99.9% uptime, 24/7 monitoring during the first month. We provide a security audit certificate (using Slither, Mythril, Echidna for smart contract verification).
Estimated timelines
Basic tracker with Reservoir polling API + TimescaleDB + REST endpoint — 1 day. Real-time WebSocket listener on Seaport events + alert system + WebSocket push API — 2-3 days total. Full cycle (acceptance, documentation, deployment) — up to 5 working days.
Order your system
Get a consultation on your project — we will calculate the exact timeline and scope of work. Order the development of an NFT floor price tracking system that works faster than competitors.