Sentiment scanner

Put/Call Ratio API

A put/call ratio scanner compares put activity with call activity across a defined universe. The useful version is a segmented record by ticker, expiration, volume, open interest, and liquidity so the signal can be inspected instead of blindly ranked.

Core formula

put volume / call volume

Use the same ticker universe and expiration window for both sides.

Positioning variant

put OI / call OI

Open interest is slower moving and describes standing exposure, not same-day flow.

Main risk

Unsegmented ratios

Earnings, 0DTE flow, rolls, and hedges can distort a single headline value.

Measurement

Define the ratio before you rank it

A put/call ratio is only meaningful after the measurement boundary is defined. A ticker-level daily ratio, a single-expiration intraday ratio, and a market-wide open-interest ratio are different statistics. They can all be useful, but they should not be compared as if they were the same variable.

For scanner work, start with contract volume inside a controlled expiration window, then add open interest and spread filters. Volume tells you what traded in the current session. Open interest tells you how much exposure was standing after the previous reporting cycle. Spread and quote checks tell you whether the contracts were liquid enough for a signal to matter.

Live market PCR

Fetch the current Cboe put/call ratio

For the headline market ratio, use the live market endpoint. It returns Cboe intraday calls, puts, total volume, and P/C ratio rows for total, equity, and index options, while the history endpoint remains the better source for multi-year close charts.

curl "https://api.cutemarkets.com/v1/market/put-call-ratio/live/?series=all"

Volume ratio

Best for same-day flow. It reacts quickly, but it can be noisy around earnings, 0DTE windows, and large hedging transactions.

sum(put.volume) / sum(call.volume)

Open-interest ratio

Best for standing exposure. It changes more slowly and is useful for context around positioning and crowding.

sum(put.open_interest) / sum(call.open_interest)

Expiration-segmented ratio

Best for interpretation. Compare 0DTE, weekly, monthly, and LEAPS buckets separately before producing one dashboard rank.

group by expiration_date

API workflow

Build a reproducible put/call scanner

The clean workflow is to fetch expirations, select the expiration window, pull calls and puts with the same filters, aggregate the fields, and store the exact request parameters with the signal. That makes the scanner reproducible and makes false positives easier to debug.

# Calls for one expiration
curl "https://api.cutemarkets.com/v1/options/chain/QQQ/?expiration_date=2026-04-17&contract_type=call&limit=1000" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Puts for the same expiration
curl "https://api.cutemarkets.com/v1/options/chain/QQQ/?expiration_date=2026-04-17&contract_type=put&limit=1000" \
  -H "Authorization: Bearer YOUR_API_KEY"

Scanner design

Controls that make the signal less fragile

01

Segment by expiration

Compute separate ratios for 0DTE or nearest weekly, standard monthly, quarterly, and long-dated buckets before combining them.

02

Filter by liquidity

Exclude contracts with low volume, low open interest, or missing quote context. Otherwise one odd contract can dominate the ratio.

03

Normalize across tickers

Compare a ticker against its own recent distribution before ranking it against structurally different underlyings.

04

Keep direction separate from interpretation

A high put/call ratio can reflect bearish speculation, hedging demand, or protective rolls. The statistic is evidence, not a conclusion.

Pseudo-code

Minimal put/call calculation

def put_call_ratio(chain_results):
    call_volume = 0
    put_volume = 0
    call_oi = 0
    put_oi = 0

    for contract in chain_results:
        details = contract.get("details", {})
        contract_type = details.get("contract_type")
        volume = contract.get("day", {}).get("volume") or 0
        open_interest = contract.get("open_interest") or 0

        if contract_type == "call":
            call_volume += volume
            call_oi += open_interest
        elif contract_type == "put":
            put_volume += volume
            put_oi += open_interest

    return {
        "volume_ratio": put_volume / call_volume if call_volume else None,
        "open_interest_ratio": put_oi / call_oi if call_oi else None,
    }

Last verified

Date-sensitive calendar references on this page were checked on May 30, 2026. Calendar math is useful for planning, but listed contracts and exchange calendars should still be verified before production workflows run.

Put/call ratio API FAQ

What is a put/call ratio?

A put/call ratio compares put activity with call activity, commonly using contract volume or open interest. Values above 1 indicate more put activity than call activity in the measured slice.

Should a put/call ratio use volume or open interest?

Use volume for same-day flow and open interest for standing positioning. They answer different questions and should not be mixed without a clear reason.

Can one ticker have a misleading put/call ratio?

Yes. Earnings, dividends, hedges, rolls, and 0DTE activity can distort a single ticker. A reliable scanner should segment by expiration and liquidity before ranking signals.

Operational usage

How to use Put/Call Ratio API in a real workflow

Treat this page as a decision boundary for the surrounding API workflow. Before a value from Put/Call Ratio APIenters a scanner, dashboard, calendar, backtest, or support answer, store the source route, request parameters, relevant timestamp, freshness label, and the reason the value is suitable for the next step.

The important implementation habit is to keep display labels separate from stable identifiers. Dates should remain tied to the calendar rule or listed-expiration source that produced them. Option rows should keep the OCC symbol, expiration, strike, side, quote state, and pagination context that created the row. Provider or product answers should keep the entitlement, licensing, and support assumptions visible.

When the workflow changes, rerun the page against one concrete example instead of trusting a general claim. Pick the ticker, date window, endpoint family, and expected output artifact. Then verify that the same terminology appears in the API request, UI label, log entry, and review checklist.

Related pages