Real-Time NFT Floor Price Tracking System

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.

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

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.