Covered Call Screener: Build One in SQL

A covered call screener ranks every call in an option chain by the premium it pays, annualised, inside a chosen delta band. One SQL query does that job, against global_markets.options_greeks, the per-contract daily table of implied volatility and greeks that starts in August 2021. The query comes first, with the filters that keep its output readable. The second half replays the same screen on past dates to show how the calls it picked finished.

What a covered call screener measures

A covered call is 100 shares you already own plus one call sold against them. The buyer pays premium today for the right to buy those shares at the strike price up to expiration. The position arithmetic, including what the share leg does to the outcome, is worked through in covered call return math, and the position itself in how a covered call works. This post is about the ranking step that comes before any of it.

The ranking number is annualised premium yield: premium divided by the share price, scaled to a year. Sell a $2.00 call on a $200 stock with 30 days left and the premium is 1.0% of the share price. Scaled by 365/30 it prints as 12.2% annualised. Annualising is what puts a 9-day contract and a 45-day contract on one axis. It is a comparison scale, not a forecast: nothing in the number says the shares stay under the strike.

The delta band is the first knob

Delta is the change in the option's price for a $1 move in the shares, and it doubles as a rough odds figure. A 0.30 delta call finishes in the money something like 30% of the time. Option delta covers the mechanics. Premium and delta rise together, which is the trade-off a screener has to put in front of you rather than bury.

The panel below takes every AAPL call with 20 to 45 days to expiration that traded during August 2026, keeps the strikes above the share price, and averages the annualised yield inside each delta band. Call deltas are positive and put deltas are negative, so the delta filter alone isolates the calls.

SELECT
    multiIf(delta < 0.10, 'delta 0.05-0.10',
            delta < 0.20, 'delta 0.10-0.20',
            delta < 0.30, 'delta 0.20-0.30',
            delta < 0.40, 'delta 0.30-0.40',
            delta < 0.50, 'delta 0.40-0.50',
                          'delta 0.50-0.65')                                           AS delta_band,
    count()                                                                            AS contracts,
    round(avg(toFloat64(strike_price) / toFloat64(underlying_close) - 1) * 100, 2)      AS avg_otm_pct,
    round(avg(toFloat64(option_close) / toFloat64(underlying_close)
              * 365.0 / days_to_expiry) * 100, 1)                                      AS avg_annual_yield_pct,
    round(avg(implied_volatility) * 100, 1)                                            AS avg_iv_pct
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date >= '2026-08-01'
  AND date <  '2026-09-01'
  AND iv_converged = 1
  AND volume > 0
  AND days_to_expiry BETWEEN 20 AND 45
  AND delta BETWEEN 0.05 AND 0.65
  AND strike_price > underlying_close
GROUP BY delta_band
ORDER BY min(delta)

Read the curve from left to right. The lowest band, delta 0.05-0.10, sat an average 12.53% above the share price and paid 2.7% annualised across 170 contract-sessions. The top band, delta 0.50-0.65, sat 0.28% above spot and paid 34.2%. The implied volatility column barely moves down the table while the yield column climbs: the yield is coming from strike distance and odds, not from a richer volatility quote.

Where the premium sits across underlyings

Same month, delta window narrowed to 0.25 through 0.35, eight liquid names instead of one.

SELECT
    underlying_symbol                                                              AS symbol,
    count()                                                                        AS contracts,
    round(avg(toFloat64(option_close) / toFloat64(underlying_close)
              * 365.0 / days_to_expiry) * 100, 1)                                  AS avg_annual_yield_pct,
    round(avg(implied_volatility) * 100, 1)                                        AS avg_iv_pct
FROM global_markets.options_greeks
WHERE underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'AMD', 'KO', 'JNJ', 'XOM', 'SPY')
  AND date >= '2026-08-01'
  AND date <  '2026-09-01'
  AND iv_converged = 1
  AND volume > 0
  AND days_to_expiry BETWEEN 20 AND 45
  AND delta BETWEEN 0.25 AND 0.35
  AND strike_price > underlying_close
GROUP BY symbol
HAVING contracts >= 20
ORDER BY avg_annual_yield_pct DESC

Of the 8 names that cleared the 20-contract minimum, AMD paid the most at the same delta: 36.7% annualised, alongside an average implied volatility of 63%. SPY sat at the other end of the board at 7%. Set the yield column next to the volatility column and the pairing is plain: at a fixed delta, premium yield is implied volatility wearing different units.

Five filters that turn a chain dump into a screen

An unfiltered chain is thousands of rows, most of them untradeable. Five filters do the cleanup, and each removes a specific kind of row.

1. An out of the money band, 2% to 12% above the last close. Without it, deep in the money calls top the board on premium that is mostly intrinsic value rather than time value.
2. A delta window, 0.25 to 0.35. Without it, 0.6 delta calls dominate the ranking with yields that come attached to the shares being called away most of the time.
3. A minimum premium, 30 cents. Penny contracts annualise to big numbers, and a single tick of slippage eats a large share of the premium.
4. A volume floor, 100 contracts on the screen date. The greeks rows carry no open interest column, so same-day contract volume stands in for it.
5. A spread guard, expressed as a share of the midpoint. A $1.00 bid against a $1.10 ask is a $1.05 mid with a spread near 9.5% of it. The daily greeks rows carry no bid or ask, so this filter runs against cache_options_quotes on whatever survives the first four.

Here are the first four applied to the last August 2026 session, ranked by annualised yield.

WITH (
    SELECT max(date)
    FROM global_markets.options_greeks
    WHERE date >= '2026-08-01' AND date < '2026-09-01'
) AS screen_session
SELECT
    concat(underlying_symbol, ' ',
           formatDateTime(expiration_date, '%b %e'), ' $',
           toString(round(toFloat64(strike_price), 2)))                        AS contract_label,
    formatDateTime(screen_session, '%b %e')                                    AS screened_on,
    days_to_expiry                                                            AS dte,
    round(delta, 3)                                                            AS delta,
    round((toFloat64(strike_price) / toFloat64(underlying_close) - 1) * 100, 2) AS otm_pct,
    round(toFloat64(option_close), 2)                                          AS premium,
    round(toFloat64(option_close) / toFloat64(underlying_close)
          * 365.0 / days_to_expiry * 100, 1)                                   AS annual_yield_pct,
    volume
FROM global_markets.options_greeks
WHERE underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'AMD', 'KO', 'JNJ', 'XOM', 'SPY')
  AND date = screen_session
  AND iv_converged = 1
  AND volume >= 100
  AND days_to_expiry BETWEEN 20 AND 45
  AND delta BETWEEN 0.25 AND 0.35
  AND toFloat64(strike_price) / toFloat64(underlying_close) - 1 BETWEEN 0.02 AND 0.12
  AND option_close >= 0.30
ORDER BY annual_yield_pct DESC
LIMIT 12

Run on Aug 31, the screen returned 12 rows, which is the point of a screen: a whole board to read. The top row, AMD Oct 2 $515, printed 29.1% annualised from a $11.97 premium at delta 0.297, 9.65% above the share price, with 32 days left and 343 contracts traded that session. The last row on the board still annualised 12%.

Replaying the screen on past dates

This data is end of day, and the front edge runs a session or two behind live, so the board above is a historical board. What end of day data offers instead of a live snapshot is history. The panel below runs the identical screen on the first session of each month from September 2025 through July 2026, with every selected call now expired, and joins each contract's expiration-day close from stocks_daily_aggs to settle whether it finished above the strike.

WITH
    selection_days AS
    (
        SELECT min(date) AS session_date
        FROM global_markets.options_greeks
        WHERE date >= '2025-09-01' AND date < '2026-08-01'
        GROUP BY toStartOfMonth(date)
    ),
    picks AS
    (
        SELECT
            formatDateTime(date, '%Y-%m')      AS month,
            underlying_symbol                  AS symbol,
            expiration_date                    AS expiry,
            toFloat64(strike_price)            AS strike,
            toFloat64(option_close) / toFloat64(underlying_close)
                * 365.0 / days_to_expiry * 100 AS annual_yield_pct
        FROM global_markets.options_greeks
        WHERE date >= '2025-09-01'
          AND date <  '2026-08-01'
          AND date IN (SELECT session_date FROM selection_days)
          AND underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'AMD', 'KO', 'JNJ', 'XOM', 'SPY')
          AND iv_converged = 1
          AND volume >= 100
          AND days_to_expiry BETWEEN 20 AND 45
          AND delta BETWEEN 0.25 AND 0.35
          AND toFloat64(strike_price) / toFloat64(underlying_close) - 1 BETWEEN 0.02 AND 0.12
          AND option_close >= 0.30
          AND expiration_date <= '2026-09-19'
    ),
    rich_line AS
    (
        SELECT
            month,
            avg(annual_yield_pct) * 1.5 AS cutoff
        FROM picks
        GROUP BY month
    )
SELECT
    p.month                                                          AS month,
    count()                                                          AS calls_screened,
    round(avg(p.annual_yield_pct), 1)                                AS avg_annual_yield_pct,
    round(countIf(toFloat64(u.close) > p.strike) / count() * 100, 1) AS itm_rate_all_pct,
    round(countIf(toFloat64(u.close) > p.strike AND p.annual_yield_pct >= r.cutoff)
          / countIf(p.annual_yield_pct >= r.cutoff) * 100, 1)        AS itm_rate_richest_pct
FROM picks AS p
INNER JOIN
(
    SELECT ticker, date, close
    FROM global_markets.stocks_daily_aggs
    WHERE date >= '2025-09-15'
      AND date <= '2026-09-19'
      AND ticker IN ('AAPL', 'MSFT', 'NVDA', 'AMD', 'KO', 'JNJ', 'XOM', 'SPY')
) AS u ON u.ticker = p.symbol AND u.date = p.expiry
INNER JOIN rich_line AS r ON r.month = p.month
GROUP BY p.month
HAVING countIf(p.annual_yield_pct >= r.cutoff) > 0
ORDER BY p.month

Across the 11 replay months, the screen selected 34 calls in 2025-09 at an average 12.5% annualised, and 22 calls in 2026-07 at 20.8%. The two in-the-money columns are the part worth sitting with. In 2025-09, 52.9% of the selected calls finished above their strike, against 42.9% for the richest contracts in that month's selection, defined as the ones paying at least 1.5 times the month's average annualised yield.

The mechanism is worth stating plainly, since a yield-sorted board keeps it out of sight. At a fixed delta band, a richer premium is a higher implied volatility quote, and a higher implied volatility quote is a wider distribution of finishing prices. The top of the board is the row the market prices for the most movement. A screen that sorts by yield and stops there is a screen that sorts by implied volatility and stops there.

That is also the argument for owning the query rather than renting a screen. Tightening the delta window to 0.20 through 0.28 pulls the whole yield column down and pulls the in-the-money rate down with it. Pushing the out of the money band from 2% to 5% leaves more room above the strike and less premium in the row. Shortening the expiry window concentrates the screen in the weeks where names with daily option expirations offer the most strikes to choose among. Each of those is one edit to a WHERE clause, with the whole board recomputed underneath it.

FAQ

How do you annualise a covered call premium?

Divide the premium by the current share price, then multiply by 365 divided by the days to expiration. A $1.50 premium on a $100 stock with 45 days left is 1.5% of the share price, or about 12.2% annualised. The scaling lets contracts with different expirations be ranked on one number.

Why do covered call screens center on 0.30 delta?

Delta approximates the odds a call finishes in the money, so a 0.30 band is a way of holding the odds roughly fixed while comparing premium across strikes, expirations, and underlyings. Move the band up and both the premium and the chance of the shares being called away move up with it.

Can you screen covered calls with SQL for free?

Yes. Per-contract daily implied volatility and greeks, plus daily underlying closes, are enough to rank a full chain by annualised premium yield, and the whole screen is a single SELECT. The endpoint and query limits are covered in the free SQL API guide.

Does end of day options data work for a covered call screen?

For ranking and for backtesting a ranking, yes. End of day rows will not give you a live bid to sell into, and the most recent session or two may still be loading, so the live quote check happens at execution time against the options quote data rather than in the screen itself.

import requests

API_URL = "..."  # the SQL endpoint from the free SQL API guide

def run_sql(sql: str) -> list[dict]:
    reply = requests.post(API_URL, json={"sql": sql}, timeout=180)
    reply.raise_for_status()
    return reply.json()["rows"]

board = run_sql(SCREEN_SQL)
for row in board[:5]:
    print(row["contract_label"], row["annual_yield_pct"])

Every panel on this page ships with the exact SQL beneath it, so the knobs are all visible and all editable. Open one, change the delta band, and run the same question on the Strasmore terminal.