Short-Form Markets and Chainlink TWAP

The managed short-form stream discovers the active Polymarket crypto market, subscribes to its settlements, follows the matching Chainlink price source, and rotates to the next market window. Starting August 7, 2026 at 00:00 UTC, affected Polymarket short-form markets resolve against Chainlink-computed time-weighted average prices. Current SDKs select the required lookback automatically:

Market duration	Chainlink price selection
5 minutes	30-second TWAP
15 minutes	60-second TWAP
1 hour	spot / default stream
4 hours	60-second TWAP

30 and 60 are lookback windows, not publication intervals. Read Polymarket’s August 7 announcement, the PolyNode transition guide, and Polymarket’s Chainlink TWAP guide for the schedule and underlying price semantics.

Use TypeScript 0.12.0+, Python 0.12.0+, or Rust 0.15.0+. Earlier versions do not implement the complete interval-to-TWAP mapping and rotation behavior documented here.

Managed stream

Choose an interval and, optionally, a subset of supported assets. The default is all seven: BTC, ETH, SOL, XRP, DOGE, HYPE, and BNB.

TypeScript
Python
Rust

import { PolyNode } from 'polynode-sdk';

const apiKey = process.env.POLYNODE_API_KEY;
if (!apiKey) throw new Error('Set POLYNODE_API_KEY');
const pn = new PolyNode({ apiKey });

const stream = pn.ws.shortForm('5m', { coins: ['btc', 'eth'] });

stream.on('rotation', (rotation) => {
  console.log('window', rotation.windowStart, rotation.windowEnd);
  for (const market of rotation.markets) {
    console.log({
      coin: market.coin,
      slug: market.slug,
      priceToBeat: market.priceToBeat,
      twapWindowSeconds: market.twapWindowSeconds,
      upOdds: market.upOdds,
      timeRemaining: rotation.timeRemaining,
    });
  }
});

stream.on('price_feed', (price) => {
  console.log(price.feed, price.price, price.twap_window_seconds);
});
stream.on('settlement', (event) => console.log(event.status, event.tx_hash));
stream.on('error', (error) => console.error(error.message));

process.once('SIGINT', () => stream.stop());

import asyncio
import os
from polynode import AsyncPolyNode

async def main() -> None:
    async with AsyncPolyNode(api_key=os.environ["POLYNODE_API_KEY"]) as pn:
        stream = pn.ws.short_form("5m", coins=["btc", "eth"])

        def on_rotation(rotation) -> None:
            for market in rotation.markets:
                print(
                    market.coin,
                    market.slug,
                    market.price_to_beat,
                    market.twap_window_seconds,
                    rotation.time_remaining,
                )

        stream.on("rotation", on_rotation)
        stream.on(
            "price_feed",
            lambda price: print(
                price.feed, price.price, price.twap_window_seconds
            ),
        )
        stream.on("settlement", lambda event: print(event.status, event.tx_hash))
        stream.on("error", lambda error: print(error))

        try:
            await asyncio.Event().wait()
        finally:
            stream.stop()

asyncio.run(main())

use polynode::{
    Coin, PolyNodeClient, PolyNodeEvent, ShortFormInterval, ShortFormMessage,
};

#[tokio::main]
async fn main() -> polynode::Result<()> {
    let client = PolyNodeClient::new(
        std::env::var("POLYNODE_API_KEY").expect("Set POLYNODE_API_KEY")
    )?;
    let mut stream = client
        .short_form(ShortFormInterval::FiveMin)
        .coins(&[Coin::Btc, Coin::Eth])
        .start()
        .await?;

    while let Some(message) = stream.next().await {
        match message {
            ShortFormMessage::Rotation(rotation) => {
                for market in rotation.markets {
                    println!(
                        "{} {} {:?} {:?}",
                        market.coin.id(),
                        market.slug,
                        market.price_to_beat,
                        market.twap_window_seconds,
                    );
                }
            }
            ShortFormMessage::PriceFeed(price) => {
                println!("{} {} {:?}", price.feed, price.price, price.twap_window_seconds);
            }
            ShortFormMessage::Event(PolyNodeEvent::Settlement(event)) => {
                println!("{:?} {}", event.status, event.tx_hash);
            }
            ShortFormMessage::Error(error) => eprintln!("{error}"),
            _ => {}
        }
    }
    Ok(())
}

What rotation means

Market slugs and outcome-token IDs change at every boundary. Chainlink selection is also scoped to the WebSocket connection. The managed helper therefore owns a dedicated socket and performs this sequence at each boundary:

close the old dedicated socket
discover the new market slugs and token IDs
connect a replacement socket
subscribe to settlements for the exact new slugs
subscribe to the interval’s exact Chainlink TWAP window, when applicable
emit rotation with the new market metadata

This reconnect is expected and necessary. Do not place unrelated subscriptions on the managed stream’s dedicated connection; the helper isolates it for you. If discovery or subscription fails, the helper emits an error. Keep the error handler visible in production and restart the stream if it stops.

Rotation payload

Each discovered market includes the fields needed to connect other user-facing components:

Field	Meaning
`slug` / `conditionId`	current Polymarket market identifiers
`clobTokenIds`	outcome token IDs for orderbook or trading calls
`chainlinkFeed`	canonical feed, such as `BTC/USD`
`twapWindowSeconds`	`30`, `60`, or `null` for the 1-hour spot/default stream
`priceToBeat`	opening Chainlink reference when available
`upOdds` / `downOdds`	current outcome probabilities
`liquidity` / `volume24h`	current market metadata
`feesEnabled` / `takerBaseFee`	fee metadata returned for the market

Python and Rust expose the same fields in snake_case. Rust’s RotationInfo also exposes twap_window_seconds for the selected interval.

Choose another interval

TypeScript
Python
Rust

const fiveMinute = pn.ws.shortForm('5m');
const fifteenMinute = pn.ws.shortForm('15m');
const hourly = pn.ws.shortForm('1h');
const fourHour = pn.ws.shortForm('4h');

five_minute = pn.ws.short_form("5m")
fifteen_minute = pn.ws.short_form("15m")
hourly = pn.ws.short_form("1h")
four_hour = pn.ws.short_form("4h")

let five_minute = client.short_form(ShortFormInterval::FiveMin);
let fifteen_minute = client.short_form(ShortFormInterval::FifteenMin);
let hourly = client.short_form(ShortFormInterval::Hourly);
let four_hour = client.short_form(ShortFormInterval::FourHour);

Each managed stream owns its own connection. If you need several intervals, monitor connection usage and stop streams you no longer need. Use a manual Chainlink subscription when you want price events without managed market discovery. Combine every feed and lookback needed on that socket into one subscription.

TypeScript
Python
Rust

const prices = await pn.ws.subscribe('chainlink')
  .feeds(['BTC/USD', 'ETH/USD'])
  .twapWindows([30, 60])
  .send();

console.log(prices.priceSource, prices.twapWindows, prices.warnings);
prices.on('price_feed', (event) => {
  const key = `${event.feed}:${event.twap_window_seconds}:${event.timestamp}`;
  console.log(key, event.price);
});

prices = await (
    pn.ws.subscribe("chainlink")
    .feeds(["BTC/USD", "ETH/USD"])
    .twap_windows([30, 60])
    .send()
)
print(prices.price_source, prices.twap_windows, prices.warnings)
prices.on(
    "price_feed",
    lambda event: print(
        event.feed, event.twap_window_seconds, event.timestamp, event.price
    ),
)

use polynode::ws::{Subscription, SubscriptionType};

let ack = stream.subscribe_with_ack(
    Subscription::new(SubscriptionType::Chainlink)
        .feeds(vec!["BTC/USD".into(), "ETH/USD".into()])
        .twap_windows(vec![30, 60]),
).await?;
println!("{:?} {:?} {:?}", ack.price_source, ack.twap_windows, ack.warnings);

On every price event, inspect is_twap and twap_window_seconds; do not infer the price type from arrival frequency. If both windows are selected, key state by feed, window, and timestamp.

Connect the current market to the orderbook

Use the rotation payload’s outcome token IDs. Replace the previous token set whenever rotation fires:

import { OrderbookEngine } from 'polynode-sdk';

const engine = new OrderbookEngine({ apiKey, integrity: true });

stream.on('rotation', async ({ markets }) => {
  const tokenIds = markets.flatMap((market) => market.clobTokenIds);
  await engine.subscribe(tokenIds);
});

See Orderbook streaming and PN1 for readiness, integrity errors, and cleanup.

Shutdown

Stop every managed stream you create. This cancels its rotation timer, removes subscriptions, and closes its dedicated connection.

TypeScript
Python
Rust

stream.stop();

stream.stop()

stream.stop().await;

Getting Started

Core Guides

Optional Helpers

TypeScript

Python

Rust

Charts (Browser)

Short-Form Markets and Chainlink TWAP

Managed stream

What rotation means

Rotation payload

Choose another interval

Connect the current market to the orderbook

Shutdown

​Managed stream

​What rotation means

​Rotation payload

​Choose another interval

​Subscribe to TWAP prices manually

​Connect the current market to the orderbook

​Shutdown

Managed stream

What rotation means

Rotation payload

Choose another interval

Subscribe to TWAP prices manually

Connect the current market to the orderbook

Shutdown