DEV Community: Omar Eldeeb

How to Check if ChatGPT Mentions Your Brand (Free)

Omar Eldeeb — Wed, 14 Oct 2026 17:40:54 +0000

To check if ChatGPT mentions your brand for free, write 10–20 questions a buyer would ask without naming you. Ask each one in a new, unpersonalised chat, at least three times, and note every brand named, its position and the cited sites. The share of runs that name you is your mention rate. One answer proves nothing; the rate does.

This guide is the manual version of what visibility tools automate. It works in ChatGPT, Perplexity, Gemini, Claude or any other assistant, and it produces a log you can score with a short script, or in a spreadsheet.

Why one check isn't enough

An AI answer is generated each time you ask, so the same question can name different brands, in a different order, from one chat to the next. Several things change what you see:

What varies	Why it matters
Sampling	The model can pick different words, and different brands, for the same prompt.
Web search	ChatGPT can search the web on its own when a question needs current information, or you can turn search on yourself (OpenAI help: searching the web with ChatGPT). A searched answer is built from the pages it found and shows sources; an unsearched one comes from the model's training.
Location	Answers to local questions can depend on where you are. "Best accountant near me" will differ by city, so note where each check was run.
Personalisation	Memory, past chats and custom instructions can shape answers, so run checks signed out or with personalisation turned off.
Model updates	The model behind ChatGPT changes over time, so last quarter's check isn't this quarter's.

So the question to answer isn't "does ChatGPT mention us?" but "in what share of relevant answers does it name us, and where?".

Step 1: write buyer prompts, not brand prompts

If you type your brand into the prompt, the answer will mention you. That tells you nothing about recommendations. Write the questions someone asks before they know you exist:

Intent	Example pattern
Best for a use case	"What's the best [category] for [type of company / situation]?"
Alternatives	"What are good alternatives to [market leader]?"
Comparison	"[Competitor A] vs [Competitor B]: which is better for [use case]?"
Problem	"How do I [job your product does] without [common pain]?"
Local	"Best [service] in [city]" (only if you serve a location)
Price	"Cheapest [category] that still has [key feature]"

Write 10–20 unbranded prompts across these intents, and keep a separate group of 2–3 branded prompts ("Is [your brand] good for [use case]?", "What does [your brand] cost?") to check what the assistant says about you. Report the two groups separately; the branded ones always mention you.

Give each prompt an ID (P1, P2...) and never edit the wording once you start, or later checks won't be comparable.

Step 2: use a clean session

Remove personalisation. Use a private browser window while signed out, or a chat with memory and custom instructions turned off. Your own chat history about your company can steer the answer toward you.
Start a new chat for every prompt. Earlier messages in a conversation shape later answers.
Pick your location on purpose. If you sell in one country, run the checks from there, or note where you ran them.
Write down the model. Note which model or mode the app shows, if any.

Step 3: run each prompt several times

Ask each prompt at least three times, each in its own new chat. Three runs won't give you a precise number, but they show whether you appear always, never, or sometimes. "Sometimes" prompts need more runs; see AI share of voice for how many.

Do the same for web search on and off if you want both views. In ChatGPT, an answer that used search shows sources you can open; record whether it did.

Step 4: log every answer the same way

One row per answer, in a spreadsheet or CSV:

date,assistant,web_search,prompt_id,run,brands_in_order,cited_domains
2026-10-14,chatgpt,on,P1,1,Contoso;Northwind;Fabrikam,contoso.com;g2.com;northwind.io
2026-10-14,chatgpt,on,P1,2,Contoso;Fabrikam,contoso.com;reddit.com

brands_in_order: every brand the answer names, in the order it first names them, separated by ;. Include brands you don't track; they're the competitors you didn't know about.
cited_domains: the domains of the sources the answer links or lists.
If you want more, add a column for a short quote of what the answer says about you, so you can catch wrong facts.

Count a brand only when the answer recommends or describes it. "I'm not familiar with Northwind" is not a mention.

Step 5: score it

Three numbers, per assistant and per prompt:

Mention rate: answers that name you ÷ all answers.
Top-3 rate: answers that name you among the first three brands ÷ all answers.
Owned-site citation rate: answers that cite your own domain ÷ all answers.

A spreadsheet's COUNTIF does it. Or run this script on the CSV. It groups the runs by assistant and prompt and flags the prompts where you appear only some of the time:

import csv
import sys
from collections import defaultdict

BRAND = "Northwind"          # your brand, spelled as you log it
OWNED_DOMAIN = "northwind.io"

rows = list(csv.DictReader(open(sys.argv[1], encoding="utf-8")))
groups = defaultdict(list)
for r in rows:
    groups[(r["assistant"], r["prompt_id"])].append(r)

print(f"{'assistant':<11}{'prompt':<7}{'runs':>5}{'named':>7}{'top 3':>7}{'cited':>7}  verdict")
for (assistant, pid), runs in sorted(groups.items()):
    order = [[b.strip() for b in r["brands_in_order"].split(";") if b.strip()] for r in runs]
    named = sum(BRAND in o for o in order)
    top3 = sum(BRAND in o[:3] for o in order)
    cited = sum(OWNED_DOMAIN in r["cited_domains"].split(";") for r in runs)
    verdict = ("always" if named == len(runs) else "never" if named == 0 else "unstable: run more")
    print(f"{assistant:<11}{pid:<7}{len(runs):>5}{named:>7}{top3:>7}{cited:>7}  {verdict}")

Run on a 12-row example log (python prompt_summary.py ai_log.csv). The brands are made up: Northwind, Contoso, Fabrikam and Tailspin are placeholder names, not real results.

assistant  prompt  runs  named  top 3  cited  verdict
chatgpt    P1         3      2      2      2  unstable: run more
chatgpt    P2         3      1      1      0  unstable: run more
perplexity P1         3      1      1      1  unstable: run more
perplexity P2         3      1      1      1  unstable: run more

How to read the result

"Never" on unbranded prompts means the assistant doesn't put you in its answer for that need. Look at who it names instead and which sites it cites; those sources are where your category's reputation is being formed.
"Unstable" is the common case. You're on the edge of the list. More runs will tell you whether that's 1 in 3 or 2 in 3.
Mentioned but not cited means the assistant knows you, but your own pages aren't what it reads. Cited but not mentioned means it reads your pages for facts but recommends others.
Branded prompts are for accuracy. Check prices, plans and claims it states about you against reality.

For why assistants pick the brands and sources they do, see How AI assistants choose which brands and sources to mention.

Related guides

AI share of voice: measure it in ChatGPT and Perplexity, with the formula and sample sizes.
How AI assistants choose which brands and sources to mention.
Track AI brand mentions over time.
Measure AI share of voice in Python, the scripted version through the model APIs.

Do it without code

The free LLM visibility query builder takes your brand, market category and competitors, and produces a ready-to-run audit input, with a fixed example of the output shape. It doesn't query any AI model from your browser, and the example isn't live data for your brand.

At scale

LLM Visibility Monitor on Apify automates this protocol. It writes a buyer-question set for your category (the generator is never told your brand name; a few branded questions are reported separately), saves it so every run asks the same questions, and sends them to the API models behind ChatGPT, Claude, Gemini, Perplexity and Grok. Each row records whether your brand was mentioned, its position, the cited sources, and whether that model searched the web. These are API models, not the consumer apps, so answers can differ from what a logged-in user sees. It has a free demo mode that calls no models, and is free to start, then pay-as-you-go.

Disclosure: I build the datatooly query builder and the Apify actor. The manual protocol above needs neither.

Sources: OpenAI Help Center: Searching the web with ChatGPT, Perplexity: How does Perplexity work?.

FPL Live Gameweek Points from the API: Picks Math

Omar Eldeeb — Wed, 14 Oct 2026 17:40:22 +0000

A Fantasy Premier League team's gameweek score is each picked player's total_points from https://fantasy.premierleague.com/api/event/{gw}/live/, multiplied by the pick's multiplier from entry/{manager_id}/event/{gw}/picks/, summed, minus event_transfers_cost. Multipliers are 0 for the bench, 1 for starters, 2 for the captain and 3 for a triple captain. Auto-subs and vice-captaincy change them.

The Python below rebuilds the score from those two endpoints, including automatic substitutions and the captain falling back to the vice-captain. I checked it against FPL's own numbers for 300 team-gameweeks on 2026-10-14 (gameweeks 4 to 6 of 2026/27, 100 managers from four depths of the Overall league): all 300 matched, including 91 automatic substitutions.

The two endpoints

event/{gw}/live/ returns elements, one row per player:

Field	Meaning
`id`	Player ID (matches `bootstrap-static/` → `elements[].id`)
`stats.total_points`	Points this gameweek so far
`stats.minutes`, `goals_scored`, `assists`, `clean_sheets`, `bonus`, `bps`, `saves`, `defensive_contribution`, `expected_goals`...	The counters behind the points
`explain`	Points broken down per fixture, e.g. `{"identifier": "goals_scored", "points": 10, "value": 2}`

entry/{manager_id}/event/{gw}/picks/ returns:

Field	Meaning
`picks`	15 rows: `element`, `position` (1–11 starters, 12–15 bench in priority order), `multiplier`, `is_captain`, `is_vice_captain`, `element_type`
`active_chip`	`null`, `bboost`, `3xc`, `freehit` or `wildcard`
`automatic_subs`	`[{element_in, element_out, event}]` once FPL has processed them
`entry_history`	`points` (before the hit), `event_transfers_cost`, `total_points`, `points_on_bench`, `rank`, `overall_rank`, `bank`, `value`

For a gameweek that hasn't started, event/{gw}/live/ returns {"elements":[]} and the picks endpoint returns 404 {"detail":"Not found."}.

The simple version: after a gameweek

Once a gameweek is over, FPL has already applied auto-subs and captaincy to the picks, so the sum is direct:

score = sum(live[p.element].total_points * p.multiplier for p in picks) - event_transfers_cost

For manager 895045 in gameweek 6 that gives 77, and entry_history.points is 77. points_on_bench (6) is the sum for the four multiplier: 0 players.

The full version: projecting the rules yourself

During a gameweek you want the score as it stands, with the substitutions that will happen. This script works from the lineup set at the deadline. For a finished gameweek it first swaps FPL's processed auto-subs back out, which is what makes it testable against FPL's numbers.

import sys
import time

import requests

API = "https://fantasy.premierleague.com/api/"
s = requests.Session()
s.headers["User-Agent"] = "fpl-live-points/1.0 (personal script)"


def get(path, attempts=4):
    for i in range(attempts):
        r = s.get(API + path, timeout=30)
        if r.status_code == 200:
            return r.json()
        if r.status_code == 404:
            raise LookupError(f"{path}: {r.json().get('detail')}")
        time.sleep(2 ** i)  # 429 / 5xx: back off 1, 2, 4 s
    r.raise_for_status()


boot = get("bootstrap-static/")
PLAYER = {p["id"]: p for p in boot["elements"]}
MIN_PLAY = {t["id"]: t["squad_min_play"] for t in boot["element_types"]}  # 1 GKP, 3 DEF, 2 MID, 1 FWD
MAX_PLAY = {t["id"]: t["squad_max_play"] for t in boot["element_types"]}


def deadline_lineup(picks, auto_subs):
    """After a gameweek, FPL's picks already have the auto-subs swapped in.
    Swap them back to get the 15 players in the order the manager set."""
    by_el = {p["element"]: dict(p) for p in picks}
    for sub in auto_subs:
        a, b = by_el[sub["element_in"]], by_el[sub["element_out"]]
        a["position"], b["position"] = b["position"], a["position"]
    return sorted(by_el.values(), key=lambda p: p["position"])


def gameweek_points(manager_id, gw):
    live = {e["id"]: e["stats"] for e in get(f"event/{gw}/live/")["elements"]}
    fixtures = get(f"fixtures/?event={gw}")
    picks = get(f"entry/{manager_id}/event/{gw}/picks/")
    chip = picks["active_chip"]

    # A player "didn't play" only once all of their team's matches this gameweek are over.
    done = {}
    for f in fixtures:
        for team in (f["team_h"], f["team_a"]):
            done[team] = done.get(team, True) and f["finished_provisional"]
    mins = lambda el: live.get(el, {}).get("minutes", 0)
    gw_over = all(f["finished_provisional"] for f in fixtures)  # also covers teams with no match (blank)
    out_for_good = lambda el: mins(el) == 0 and done.get(PLAYER[el]["team"], gw_over)
    pos = lambda el: PLAYER[el]["element_type"]

    order = deadline_lineup(picks["picks"], picks["automatic_subs"])
    xi = [p["element"] for p in order[:11]]
    bench = [p["element"] for p in order[11:]]

    subs = []
    if chip != "bboost":
        for out in list(xi):
            if not out_for_good(out):
                continue
            for cand in bench:  # bench order = substitution priority
                if mins(cand) == 0 or (pos(out) == 1) != (pos(cand) == 1):
                    continue
                trial = [cand if e == out else e for e in xi]
                counts = {t: sum(pos(e) == t for e in trial) for t in MIN_PLAY}
                if all(MIN_PLAY[t] <= counts[t] <= MAX_PLAY[t] for t in MIN_PLAY):
                    xi = trial
                    bench.remove(cand)
                    subs.append((cand, out))
                    break

    mult = {el: 1 for el in xi + (bench if chip == "bboost" else [])}
    cap = next(p["element"] for p in order if p["is_captain"])
    vice = next(p["element"] for p in order if p["is_vice_captain"])
    armband = cap if not out_for_good(cap) else vice if not out_for_good(vice) else None
    if armband in mult:
        mult[armband] = 3 if chip == "3xc" else 2

    gross = sum(live.get(el, {}).get("total_points", 0) * m for el, m in mult.items())
    hit = picks["entry_history"]["event_transfers_cost"]
    return {"chip": chip, "subs": subs, "mult": mult, "live": live, "gross": gross,
            "hit": hit, "net": gross - hit, "fpl_points": picks["entry_history"]["points"]}


if __name__ == "__main__":
    manager_id, gw = int(sys.argv[1]), int(sys.argv[2])
    r = gameweek_points(manager_id, gw)
    for el, m in r["mult"].items():
        tag = {2: " (C)", 3: " (TC)"}.get(m, "")
        print(f"  {PLAYER[el]['web_name']:<14} {r['live'][el]['total_points']:>3} x{m}{tag}")
    for cand, out in r["subs"]:
        print(f"  auto-sub: {PLAYER[cand]['web_name']} in for {PLAYER[out]['web_name']}")
    print(f"chip={r['chip']}  gross={r['gross']}  hit=-{r['hit']}  net={r['net']}  "
          f"(FPL's own gameweek points: {r['fpl_points']})")

python fpl_live_points.py 895045 6 (the Overall league leader on 2026-10-14):

  Raya             3 x1
  Gabriel          2 x1
  De Cuyper       15 x1
  Hall             0 x1
  O'Shea          11 x1
  Rogers           9 x1
  Palmer           8 x2 (C)
  Schade           1 x1
  João Pedro      12 x1
  Haaland          6 x1
  Wissa            2 x1
  auto-sub: O'Shea in for Szoboszlai
chip=None  gross=77  hit=-0  net=77  (FPL's own gameweek points: 77)

Szoboszlai started but played 0 minutes, so the first eligible bench player, O'Shea (11 points), came in. Two more cases from the same run:

$ python fpl_live_points.py 895045 3 | tail -1
chip=3xc  gross=90  hit=-0  net=90  (FPL's own gameweek points: 90)
$ python fpl_live_points.py 2098553 6 | tail -1
chip=None  gross=100  hit=-4  net=96  (FPL's own gameweek points: 100)

The second shows that entry_history.points is the score before the hit: that manager's total_points went from 409 to 505, which is 100 − 4 added.

The rules the script applies

Rule	In the code
A starter who plays 0 minutes, once their team's matches are over, is replaced by the first bench player who played	`out_for_good`, bench loop in position order
Goalkeepers only swap with goalkeepers	`(pos(out) == 1) != (pos(cand) == 1)`
The XI must stay a legal formation: at least 1 GK, 3 DEF, 2 MID, 1 FWD	`squad_min_play` / `squad_max_play` from `bootstrap-static/` → `element_types`
If the captain doesn't play, the vice-captain's points are doubled; if neither plays, nobody's are	`armband`
Triple Captain triples instead of doubles	`3 if chip == "3xc"`
Bench Boost counts all 15 players and makes no substitutions	`chip != "bboost"`
Transfer hits are taken off the total	`event_transfers_cost`

The Premier League describes the vice-captain rule in its postponements explainer. The formation limits come from the API's own element_types.

One known difference. When two starters are both replaced, the script can pair them with the bench players differently than FPL records in automatic_subs. The same players end up in the XI, so the score is the same. That happened once in the 300 checks. In one Bench Boost gameweek FPL also recorded an entry in automatic_subs (the script records none); with all 15 players counting, the score was the same either way. The other 298 matched FPL's substitutions exactly.

Using it during a live gameweek

All 300 checks were on finished gameweeks. On 2026-10-14 no gameweek was in progress (gameweek 7's deadline is 2026-10-17 10:00 UTC), so the live behaviour below is how the code is designed to work, not something I tested:

A starter whose match hasn't kicked off isn't substituted yet, because out_for_good waits for finished_provisional on all of that team's fixtures.
A bench player whose match hasn't started can't come on yet (mins(cand) == 0), so the projection can change as matches finish.
total_points changes during matches. Bonus points are added later: check event-status/ for "bonus_added": true on each day before treating a score as final.
event/{gw}/live/ has no published cache rule. Polling it every minute or two is plenty; matches don't change faster than that.

Pitfalls

Points before the hit. Compare like with like: entry_history.points against gross, net against FPL's displayed net score.
Free Hit and Wildcard don't change the maths. They change the squad, and the picks endpoint already returns the squad used that gameweek.
Double gameweeks. A player with two fixtures has one total_points covering both. explain lists them per fixture.
No CORS. The API can't be called from browser JavaScript; run this as a script or on a server.

Related guides for this API

Do it without code

The free FPL query builder builds a ready-to-run input for gameweek picks, mini-league intel, manager dashboards and more, and shows a fixed example of the output shape. It doesn't fetch live points in your browser; the API blocks that.

At scale

The FPL Intelligence actor on Apify has a live_tracker mode that takes a gameweek plus manager or league IDs and returns live points per manager and live standings per league, as a single snapshot or refreshed on an interval. Other modes cover captain and transfer picks, a wildcard optimizer, mini-league intel and manager dashboards. It exports JSON, CSV or Excel. It's free to start, then pay-as-you-go.

Disclosure: I build the datatooly query builder and the Apify actor. The script above needs neither.

Sources: live responses from fantasy.premierleague.com/api/ on 2026-10-14 (FPL publishes no API documentation), and the Premier League's article How postponements affect FPL managers.

FPL API Endpoints: Complete Reference for 2026/27

Omar Eldeeb — Wed, 14 Oct 2026 17:39:50 +0000

The Fantasy Premier League API is a free, keyless JSON API at https://fantasy.premierleague.com/api/. Its main endpoints are bootstrap-static/ (all players, teams and gameweeks), fixtures/, element-summary/{player_id}/, event/{gw}/live/, entry/{manager_id}/ with /history/, /event/{gw}/picks/ and /transfers/, and leagues-classic/{league_id}/standings/. It has no official documentation and no CORS header.

The Premier League doesn't document this API, so this reference comes from live responses. I called every endpoint below on 2026-10-14, during the 2026/27 season, between gameweek 6 (finished) and gameweek 7 (deadline 2026-10-17 10:00 UTC). Each returned HTTP 200 unless marked otherwise.

The endpoints at a glance

Endpoint	Returns	Status on 2026-10-14
`bootstrap-static/`	Every player, team and gameweek, plus game rules	200, 1.7 MB
`fixtures/`	All 380 fixtures of the season	200
`fixtures/?event={gw}`	One gameweek's fixtures	200 (10 for GW6)
`fixtures/?future=1`	Only fixtures not yet played	200 (320)
`element-summary/{player_id}/`	One player's remaining fixtures, this season's matches, past seasons	200; unknown ID: 404
`event/{gw}/live/`	Every player's stats and points for a gameweek	200; a future gameweek returns `{"elements":[]}`
`event-status/`	Whether bonus points are added and leagues updated	200
`dream-team/{gw}/`	The best XI of a gameweek	200
`entry/{manager_id}/`	A manager's profile, rank and leagues	200; unknown ID: 404
`entry/{manager_id}/history/`	Points and rank per gameweek, past seasons, chips used	200
`entry/{manager_id}/event/{gw}/picks/`	The 15 players picked in a gameweek, captain, chip, auto-subs	200; a future gameweek: 404
`entry/{manager_id}/transfers/`	Every transfer this season	200
`leagues-classic/{league_id}/standings/`	A classic league table, 50 per page	200
`team/set-piece-notes/`	Set-piece notes per team	200
`regions/`	Countries and regions for manager profiles	200 (255)
`stats/most-valuable-teams/`	The 10 highest team values	200
`my-team/{manager_id}/`	Your own team before the deadline	403 without login
`entry/{manager_id}/transfers-latest/`	Your latest transfers	403 without login

The paths end with a slash. Two paths that older tutorials mention, set-piece-notes/ and bootstrap-dynamic/, returned 404 HTML pages. The base URL itself (/api/) also returns 404.

Check them yourself

import time

import requests

API = "https://fantasy.premierleague.com/api/"
s = requests.Session()
s.headers["User-Agent"] = "fpl-endpoint-check/1.0 (personal script)"


def get(path):
    r = s.get(API + path, timeout=30)
    return r.status_code, (r.json() if r.headers.get("content-type", "").startswith("application/json") else None)


_, boot = get("bootstrap-static/")
gw = next(e["id"] for e in boot["events"] if e["is_current"])          # latest started gameweek
player = max(boot["elements"], key=lambda p: p["total_points"])["id"]  # any player id works
_, overall = get("leagues-classic/314/standings/")                    # 314 = the Overall league
manager = overall["standings"]["results"][0]["entry"]                  # any manager id works

paths = [
    "bootstrap-static/",
    "fixtures/",
    f"fixtures/?event={gw}",
    f"element-summary/{player}/",
    f"event/{gw}/live/",
    "event-status/",
    f"dream-team/{gw}/",
    f"entry/{manager}/",
    f"entry/{manager}/history/",
    f"entry/{manager}/event/{gw}/picks/",
    f"entry/{manager}/transfers/",
    "leagues-classic/314/standings/?page_standings=2",
    "team/set-piece-notes/",
    "regions/",
    "stats/most-valuable-teams/",
    "my-team/1/",
]
for p in paths:
    status, body = get(p)
    shape = list(body)[:4] if isinstance(body, dict) else f"list of {len(body)}" if isinstance(body, list) else "-"
    print(f"{status}  {p:<45} {shape}")
    time.sleep(0.5)

Output on 2026-10-14:

200  bootstrap-static/                             ['chips', 'events', 'game_settings', 'game_config']
200  fixtures/                                     list of 380
200  fixtures/?event=6                             list of 10
200  element-summary/115/                          ['fixtures', 'history', 'history_past']
200  event/6/live/                                 ['elements']
200  event-status/                                 ['status', 'leagues']
200  dream-team/6/                                 ['top_player', 'team']
200  entry/895045/                                 ['id', 'joined_time', 'started_event', 'favourite_team']
200  entry/895045/history/                         ['current', 'past', 'chips']
200  entry/895045/event/6/picks/                   ['active_chip', 'automatic_subs', 'entry_history', 'picks']
200  entry/895045/transfers/                       list of 36
200  leagues-classic/314/standings/?page_standings=2 ['league', 'standings', 'last_updated_data', 'new_entries']
200  team/set-piece-notes/                         ['last_updated', 'teams']
200  regions/                                      list of 255
200  stats/most-valuable-teams/                    list of 10
403  my-team/1/                                    ['detail']

Key fields, endpoint by endpoint

`bootstrap-static/`

Top-level keys: events, game_settings, game_config, phases, teams, total_players, element_stats, element_types, elements, chips. On 2026-10-14 it held 667 players, 20 teams, 38 gameweeks and total_players: 11085989.

Array	Key fields
`elements` (players, 109 fields each)	`id`, `web_name`, `team`, `element_type` (1 GKP, 2 DEF, 3 MID, 4 FWD), `now_cost` (tenths of £m), `total_points`, `event_points`, `form`, `selected_by_percent`, `status`, `chance_of_playing_next_round`, `news`, `minutes`, `goals_scored`, `assists`, `expected_goals`, `expected_assists`, `defensive_contribution`, `ep_next`, `transfers_in_event`, `price_change_percent`
`teams`	`id`, `name`, `short_name`, `strength_overall_home`, `strength_overall_away`, `played`, `win`, `draw`, `loss`, `points`, `position`
`events` (gameweeks)	`id`, `name`, `deadline_time`, `is_previous`, `is_current`, `is_next`, `finished`, `data_checked`, `average_entry_score`, `highest_score`, `most_captained`, `top_element`
`element_types`	`squad_select` (2/5/5/3), `squad_min_play`, `squad_max_play`
`game_settings`	`squad_squadsize` (15), `squad_team_limit` (3 per club), `squad_total_spend` (1000 = £100.0m), `transfers_cap`, `max_extra_free_transfers`

Several numbers arrive as strings: form, selected_by_percent, expected_goals, price_change_percent. Cast them before comparing. The response carried cache-control: max-age=300, so it changes at most every five minutes.

`fixtures/`

Each fixture: id, event (gameweek), kickoff_time, team_h, team_a, team_h_score, team_a_score, team_h_difficulty, team_a_difficulty, started, finished, minutes, stats. For a finished match, stats lists goals_scored, assists, own_goals, penalties_saved, penalties_missed, yellow_cards, red_cards, saves, bonus, bps and defensive_contribution, each split into h and a with {value, element} pairs. Difficulty is covered in FPL fixture difficulty from the API.

`element-summary/{player_id}/`

fixtures (remaining matches, with difficulty and is_home from that player's side), history (one row per match this season: round, opponent_team, minutes, total_points, bps, expected_goals, value, selected, transfers_balance, and more) and history_past (one row per earlier season: season_name, start_cost, end_cost, total_points, minutes).

`event/{gw}/live/`

elements is a list of every player with id, stats (the same counters as above plus total_points, in_dreamteam and played) and explain, which breaks the points down per fixture: {"identifier": "goals_scored", "points": 10, "value": 2}. Pair it with a manager's picks to compute their score; see FPL live gameweek points from the API.

`entry/{manager_id}/` and its sub-paths

Endpoint	Key fields
`entry/{id}/`	`id`, `name` (team name), `started_event`, `summary_overall_points`, `summary_overall_rank`, `summary_event_points`, `current_event`, `last_deadline_value`, `last_deadline_bank`, `leagues` (`classic`, `h2h`, `cup`)
`entry/{id}/history/`	`current` (per gameweek: `points`, `total_points`, `overall_rank`, `bank`, `value`, `event_transfers`, `event_transfers_cost`, `points_on_bench`), `past` (`season_name`, `total_points`, `rank`), `chips` (`name`, `event`, `time`)
`entry/{id}/event/{gw}/picks/`	`picks` (15 rows: `element`, `position`, `multiplier`, `is_captain`, `is_vice_captain`), `active_chip`, `automatic_subs`, `entry_history`
`entry/{id}/transfers/`	`element_in`, `element_in_cost`, `element_out`, `element_out_cost`, `event`, `time`

How to find a manager ID, and a full history script: Find your FPL manager ID and pull your team history.

`leagues-classic/{league_id}/standings/`

league (id, name, ...), standings (page, has_next, results: entry, entry_name, player_name, rank, last_rank, total, event_total), new_entries and last_updated_data. Fifty rows per page; add ?page_standings=2 and keep going while has_next is true. League 314 is the Overall league.

Small endpoints

event-status/ returned {"status": [{"bonus_added": true, "date": "2026-10-10", "event": 6, "points": "r"}, ...], "leagues": "Updated"}. Check bonus_added and leagues before you treat a gameweek's numbers as final.
dream-team/{gw}/ returns top_player (id, points) and team (11 rows of element, points, position).

Errors

Situation	Status	Body
Unknown manager	404	`{"detail":"No Entry matches the given query."}`
Unknown player	404	`{"detail":"No Element matches the given query."}`
Picks for a gameweek that hasn't started	404	`{"detail":"Not found."}`
Your own team without login	403	`{"detail":"Authentication credentials were not provided."}`
`me/` without login	200	`{"player":null,"watched":[]}`

Rules of the road

No browser calls. The responses I checked (bootstrap-static/, fixtures/, entry/{id}/) carried no Access-Control-Allow-Origin header, so a web page can't fetch() them. Use a server, a script or a scheduled job.
No published rate limit. FPL documents none. Cache bootstrap-static/ (it's 1.7 MB and only changes every five minutes), pause between requests, and back off on errors. My scripts send a descriptive User-Agent; the API also answered without one.
The API only shows now. It doesn't keep yesterday's prices, ownership or price-change progress. Save snapshots if you need history; for past seasons, the community vaastav/Fantasy-Premier-League archive on GitHub is the usual source.
Prices are in tenths. now_cost: 61 is £6.1m, and squad_total_spend: 1000 is £100.0m.

Related guides for this API

Find your FPL manager ID and pull your team history.
FPL live gameweek points from the API.
FPL fixture difficulty from the API.
FPL API price change data in Python, for the official price-change fields.

Do it without code

The free FPL query builder lets you pick a mode (gameweek picks, mini-league intel, manager dashboard, price-change predictor and others), a gameweek and manager IDs, and gives you a ready-to-run input with a fixed example of the output. It's a query builder, not a live tool: because of the missing CORS header, it can't call the FPL API from your browser.

At scale

The FPL Intelligence actor on Apify calls these endpoints server-side and turns them into ready answers: captain, transfer and differential picks, a wildcard optimizer, mini-league intel, a manager dashboard, live gameweek tracking, a price-change predictor, and past seasons from the vaastav archive. It exports JSON, CSV or Excel and runs on a schedule. It's free to start, then pay-as-you-go.

Disclosure: I build the datatooly query builder and the Apify actor. Every endpoint above works without either.

Sources: live responses from fantasy.premierleague.com/api/ on 2026-10-14. FPL publishes no API documentation.

ClinicalTrials.gov API v2 Query Parameters: Full Reference

Omar Eldeeb — Wed, 14 Oct 2026 17:39:18 +0000

The ClinicalTrials.gov API v2 has one search endpoint, https://clinicaltrials.gov/api/v2/studies. You search with query.* parameters (query.cond, query.term, query.intr, query.spons), narrow with filter.* and aggFilters, choose output with fields and format, and page with pageSize and pageToken. There is no API key. There is also no filter.phase; use filter.advanced=AREA[Phase]PHASE3.

This is a complete reference for the /studies endpoint, built from the official OpenAPI spec (API version 2.0.5) and checked against the live API on 2026-10-14. Every count below comes from that day's data, so your numbers will drift as the registry grows.

Query parameters: what to search

query.* parameters search text and affect relevance ranking. Each one targets a "search area", a group of fields defined by the API (the full list is at /api/v2/studies/search-areas).

Parameter	Search area	Searches in (examples)	Example	Matches on 2026-10-14
`query.cond`	ConditionSearch	Condition, titles, condition MeSH terms, keywords, NCT ID (7 fields)	`query.cond=lung cancer`	14,620
`query.term`	BasicSearch	57 fields, incl. NCT ID, acronym, titles, conditions, interventions, summary ("Other terms" on the website)	`query.term=GLP-1`	4,273
`query.intr`	InterventionSearch	Intervention name, type, other names, arm groups, MeSH terms (12 fields)	`query.intr=pembrolizumab`	2,977
`query.titles`	TitleSearch	Acronym, brief title, official title	`query.titles=TRAILBLAZER`	12
`query.outc`	OutcomeSearch	Primary, secondary and other outcome measures and descriptions (9 fields)	`query.outc=HbA1c`	12,125
`query.spons`	SponsorSearch	Lead sponsor, collaborators, organization name	`query.spons=Pfizer`	6,091
`query.lead`	`LeadSponsorName` field only	Lead sponsor only	`query.lead=Pfizer`	3,884
`query.locn`	LocationSearch	Location city, state, country, facility, ZIP	`query.locn=Boston`	21,515
`query.id`	IdSearch	NCT ID, NCT ID aliases, acronym, org study ID, secondary IDs	`query.id=NCT04437511`	1
`query.patient`	PatientSearch	47 fields, a patient-oriented mix of conditions, titles, summary and interventions

query.spons vs query.lead: Pfizer appears as lead sponsor or collaborator on 6,091 studies, and as lead sponsor on 3,884.

Every query.* value uses Essie expression syntax, so "exact phrase", AND, OR, NOT and parentheses all work. For example query.term="continuous glucose monitor" matched 234 type 2 diabetes studies.

Filter parameters: what to keep

Filters narrow the result set without changing ranking.

Parameter	Format	Example
`filter.overallStatus`	Comma- or pipe-separated statuses	`RECRUITING\
{% raw %}`filter.ids`	Comma- or pipe-separated NCT IDs	`NCT04437511,NCT04368728`
`filter.geo`	`distance(lat,lon,radius)` with `mi` or `km`	`distance(42.3601,-71.0589,50mi)`
`filter.advanced`	An Essie expression, usually `AREA[Field]value`	`AREA[Phase]PHASE3`
`filter.synonyms`	`area:synonym_id` pairs	`ConditionSearch:1651367`
`aggFilters`	`filter_id:option` pairs, the website's sidebar filters	`results:with,status:com`
`postFilter.*`	Same as the `filter.*` versions	`postFilter.overallStatus=RECRUITING`

The spec says filter.* and postFilter.* "have same effect", and both exist "just to simplify applying parameters from search request".

Valid filter.overallStatus values (from the spec): ACTIVE_NOT_RECRUITING, COMPLETED, ENROLLING_BY_INVITATION, NOT_YET_RECRUITING, RECRUITING, SUSPENDED, TERMINATED, WITHDRAWN, AVAILABLE, NO_LONGER_AVAILABLE, TEMPORARILY_NOT_AVAILABLE, APPROVED_FOR_MARKETING, WITHHELD, UNKNOWN. Anything else, such as OPEN, returns HTTP 400: Invalid value in parameter `overallStatus`: `OPEN`.

filter.advanced and the AREA[] syntax

Most fields have no dedicated filter. You reach them with filter.advanced, which takes an Essie expression. AREA[FieldName] points the expression at one field. All of these returned HTTP 200 on 2026-10-14, combined with query.cond=type 2 diabetes (11,987 studies):

Goal	`filter.advanced` value	Studies
Phase 3	`AREA[Phase]PHASE3`	1,642
Phase 2 or 3	`AREA[Phase](PHASE2 OR PHASE3)`	2,811
Started on or after 2024-01-01	`AREA[StartDate]RANGE[2024-01-01,MAX]`	1,903
Enrollment of 1,000 or more	`AREA[EnrollmentCount]RANGE[1000,MAX]`	1,059
Industry lead sponsor	`AREA[LeadSponsorClass]INDUSTRY`	4,350
Phase field empty	`AREA[Phase]MISSING`	2,113
Exclude "not applicable" phase	`NOT AREA[Phase]NA`	7,497
Completed, no results posted	`AREA[OverallStatus]COMPLETED AND AREA[HasResults]false`	5,955
A recruiting site in Boston	`SEARCH[Location](AREA[LocationCity]Boston AND AREA[LocationStatus]RECRUITING)`	26

SEARCH[Location](...) makes both conditions apply to the same location. Without it, a study with a recruiting site in Chicago and a closed site in Boston would match. Phase values are NA, EARLY_PHASE1, PHASE1, PHASE2, PHASE3 and PHASE4.

aggFilters

aggFilters uses the short keys behind the website's filter sidebar. The spec gives results:with,status:com and status:not rec,sex:f,healthy:y as examples. phase:3 matched exactly the same 1,642 studies as AREA[Phase]PHASE3. Separate several options for one filter with spaces (status:not rec) and separate filters with commas.

Output and paging parameters

Parameter	What it does	Notes from testing
`fields`	Which fields to return	JSON uses field names (`NCTId`, `BriefTitle`), piece names or module names. CSV uses column names (`NCT Number`). An unknown name returns HTTP 400. `@query` returns the fields your query matched.
`format`	`json` (default) or `csv`	In CSV mode the next-page token comes in the `x-next-page-token` response header.
`markupFormat`	`markdown` (default) or `legacy`	JSON only.
`sort`	Up to 2 sort keys, `Field:asc` or `Field:desc`	Only date and numeric fields, plus `@relevance`. `sort=BriefTitle` returned HTTP 400: `Unsupported sort field type: text`. Results are unsorted by default.
`countTotal`	`true` adds `totalCount` to the first page	CSV puts it in the `x-total-count` header.
`pageSize`	Studies per page	Default 10. Values above 1,000 are quietly reduced to 1,000. `0` means the default.
`pageToken`	The `nextPageToken` from the previous page	Every other parameter must stay the same, apart from `countTotal`, `pageSize` and `pageToken`.
`geoDecay`	How distance from `filter.geo` affects ranking	Ignored without `filter.geo`.

curl: one request with several parameters

curl -s "https://clinicaltrials.gov/api/v2/studies?query.cond=type+2+diabetes&filter.advanced=AREA%5BPhase%5DPHASE3&filter.overallStatus=RECRUITING&countTotal=true&pageSize=2&fields=NCTId,BriefTitle"

Result (trimmed titles):

{"totalCount":74,"studies":[
{"protocolSection":{"identificationModule":{"nctId":"NCT07797335","briefTitle":"AMBITION 7: A Research Study Investigating How Well Zenagamtide Lowers Blood Sugar ..."}}},
{"protocolSection":{"identificationModule":{"nctId":"NCT07613307","briefTitle":"A Study of Orforglipron (LY3502970) in Participants With Type 2 Diabetes Who Observe Ramadan Fasting"}}}
],"nextPageToken":"ZVNj7o2Elu8o3lpzC8-7qrbumpOQJJxuZPKj2PAW"}

URL-encode the brackets in AREA[...] (%5B, %5D) when you build URLs by hand. requests and curl --data-urlencode do it for you.

Python: counting and paging

import time
import requests

BASE = "https://clinicaltrials.gov/api/v2/studies"
session = requests.Session()

def count(**params):
    """Total matching studies for a query (countTotal=true, one tiny page)."""
    p = {**params, "countTotal": "true", "pageSize": 1, "fields": "NCTId"}
    r = session.get(BASE, params=p, timeout=60)
    r.raise_for_status()  # a 400 means a bad parameter name or value
    return r.json()["totalCount"]

def search(params, fields, page_size=1000, max_pages=50):
    """Yield every matching study, following nextPageToken."""
    p = {**params, "fields": ",".join(fields), "pageSize": page_size}
    for _ in range(max_pages):
        r = session.get(BASE, params=p, timeout=60)
        r.raise_for_status()
        data = r.json()
        yield from data.get("studies", [])  # a page may be empty
        token = data.get("nextPageToken")
        if not token:
            return
        p["pageToken"] = token  # every other parameter must stay the same
        time.sleep(0.5)

q = {"query.cond": "type 2 diabetes"}
print("all T2D studies:          ", count(**q))
print("+ Phase 3:                ", count(**q, **{"filter.advanced": "AREA[Phase]PHASE3"}))
print("+ recruiting:             ", count(**q, **{"filter.overallStatus": "RECRUITING"}))
print("+ within 50 mi of Boston: ", count(**q, **{"filter.geo": "distance(42.3601,-71.0589,50mi)"}))
print("+ semaglutide:            ", count(**q, **{"query.intr": "semaglutide"}))

rows = list(search(
    {**q, "query.intr": "semaglutide", "filter.overallStatus": "RECRUITING", "sort": "LastUpdatePostDate:desc"},
    ["NCTId", "BriefTitle", "Phase", "LeadSponsorName", "LastUpdatePostDate"],
))
print(len(rows), "recruiting semaglutide T2D trials; newest update:")
for st in rows[:3]:
    p = st["protocolSection"]
    print(p["identificationModule"]["nctId"], p["statusModule"]["lastUpdatePostDateStruct"]["date"],
          p.get("designModule", {}).get("phases"), p["sponsorCollaboratorsModule"]["leadSponsor"]["name"])

Output on 2026-10-14:

all T2D studies:           11987
+ Phase 3:                 1642
+ recruiting:              869
+ within 50 mi of Boston:  586
+ semaglutide:             331
50 recruiting semaglutide T2D trials; newest update:
NCT07743983 2026-10-13 ['PHASE3'] BrightGene Bio-Medical Technology Co., Ltd.
NCT06897475 2026-10-09 ['PHASE2'] Eli Lilly and Company
NCT07668388 2026-10-07 ['PHASE2'] Novo Nordisk A/S

Mistakes the API rejects (and ones it doesn't)

Request	What happens
`filter.phase=PHASE3`	HTTP 400, `filter.phase` is unknown parameter
`filter.overallStatus=OPEN`	HTTP 400, invalid value
`fields=NCTId,Bogus`	HTTP 400, `Parameter 'fields' contains invalid field name: 'Bogus'`
`sort=BriefTitle`	HTTP 400, text fields can't be sorted
`pageSize=5000`	HTTP 200 with 1,000 studies, no warning
`query.term=NCT04437511 NCT04368728` plus filters	HTTP 200, and the filters are ignored (documented: a query of only NCT IDs switches filters off)

A 400 is a bug in your query, so don't retry it. Retry only on 429 and 5xx, with backoff. NLM doesn't publish a fixed request quota for this API.

Related guides for this API

Look up a study by NCT number with /studies/{nctId}.
Get completed trial results with aggFilters=results:with,status:com.
Classic API to v2 migration: how expr, min_rnk and fmt map to v2.
Export search results to CSV in Python, including the header-based CSV paging.

Do it without code

The free ClinicalTrials.gov search tool builds these queries for you and runs them live in your browser. Pick a condition, a drug, a phase and a status, and you get real studies back.

At scale

For scheduled pulls across many conditions or sponsors, with FDA approvals, device clearances, adverse events, recalls and shortages joined on, use the Clinical Trials & FDA Pipeline actor on Apify. Its trials mode takes conditions, interventions, phases, statuses, countries and a date range, and pages through nextPageToken for you. It's free to start, then pay-as-you-go.

Disclosure: I build the datatooly tool and the Apify actor. The API works the same without them.

Sources: ClinicalTrials.gov API, interactive OpenAPI docs, Search Areas, Study Data Structure, and live API responses on 2026-10-14.

ClinicalTrials.gov API: Look Up a Study by NCT Number

Omar Eldeeb — Wed, 14 Oct 2026 17:38:45 +0000

To look up a clinical trial by NCT number, call https://clinicaltrials.gov/api/v2/studies/{nctId}, for example /api/v2/studies/NCT04437511. It returns the full record as JSON, with no API key and no signup. Add fields= to return only what you need. An unknown NCT number returns HTTP 404, and a malformed one returns HTTP 400.

This page covers the single-study endpoint of the ClinicalTrials.gov v2 API: the NCT number format, the response, the errors, aliases, and how to fetch many trials at once. Everything below was run against the live API on 2026-10-14 (API version 2.0.5).

The NCT number format

An NCT number is the ClinicalTrials.gov Identifier. The API's own field definition (from /api/v2/studies/metadata) says: "The format is "NCT" followed by an 8-digit number." For example, NCT04437511 is Eli Lilly's TRAILBLAZER-ALZ 2 donanemab trial.

What the endpoint accepts, as tested:

Input	Result
`NCT04437511`	HTTP 200, the study
`nct04437511` (lowercase)	HTTP 200, the same study
`NCT4437511` (leading zero dropped)	HTTP 200, `nctId` comes back as `NCT04437511`
`NCT99999999` (well-formed, doesn't exist)	HTTP 404, text body `NCT number NCT99999999 not found`
`04437511` (no `NCT` prefix)	HTTP 400, text body Parameter `nctId` has incorrect format
`NCT00009113` (an old alias)	HTTP 301 redirect to `NCT00010647`

Error bodies are text/plain, not JSON, so check the status code before you call .json().

The endpoint

GET https://clinicaltrials.gov/api/v2/studies/{nctId}

Parameter	Values	Notes
`format`	`json` (default), `csv`, `json.zip`, `fhir.json`, `ris`	`fhir.json` ignores `fields`. `ris` is a citation record.
`fields`	Field, piece or module names, comma- or pipe-separated	JSON uses names like `NCTId`, `BriefTitle`, `ConditionsModule`. CSV uses column names like `NCT Number`.
`markupFormat`	`markdown` (default), `legacy`	Applies to JSON only.

These are the parameters listed for /studies/{nctId} in the official OpenAPI spec.

What the JSON contains

The full record for NCT04437511 has five top-level keys: protocolSection, resultsSection, documentSection, derivedSection and hasResults. The spec also defines an annotationSection, which appears only on some studies.

Section	What's in it
`protocolSection`	Registration data in modules: `identificationModule`, `statusModule`, `sponsorCollaboratorsModule`, `descriptionModule`, `conditionsModule`, `designModule`, `armsInterventionsModule`, `outcomesModule`, `eligibilityModule`, `contactsLocationsModule`, and more.
`resultsSection`	Posted results: participant flow, baseline, outcome measures, adverse events. Present only when `hasResults` is `true`.
`documentSection`	Uploaded protocol, statistical analysis plan and consent PDFs.
`derivedSection`	Fields ClinicalTrials.gov adds, such as MeSH terms for conditions and interventions.
`hasResults`	`true` when results are posted.

A full record can be large (the API's /api/v2/stats/size reported an average of 17,304 bytes per study and a 99th percentile of 149,567 bytes), so use fields when you only need a few values.

curl: one study, a few fields

curl -s "https://clinicaltrials.gov/api/v2/studies/NCT04437511?fields=NCTId,BriefTitle,OverallStatus,Phase,LeadSponsorName,HasResults"

Result:

{"protocolSection":{"identificationModule":{"nctId":"NCT04437511","briefTitle":"A Study of Donanemab (LY3002813) in Participants With Early Alzheimer's Disease (TRAILBLAZER-ALZ 2)"},"statusModule":{"overallStatus":"ACTIVE_NOT_RECRUITING"},"sponsorCollaboratorsModule":{"leadSponsor":{"name":"Eli Lilly and Company"}},"designModule":{"phases":["PHASE3"]}},"hasResults":true}

Even with fields, the response keeps the nested path of each field. Phase comes back as designModule.phases, a list.

The same lookup as a one-row CSV:

curl -s "https://clinicaltrials.gov/api/v2/studies/NCT04437511?format=csv&fields=NCT%20Number,Study%20Title,Study%20Status,Phases,Sponsor"

NCT Number,Study Title,Study Status,Sponsor,Phases
NCT04437511,A Study of Donanemab (LY3002813) in Participants With Early Alzheimer's Disease (TRAILBLAZER-ALZ 2),ACTIVE_NOT_RECRUITING,Eli Lilly and Company,PHASE3

The columns come back in the API's order, not the order you asked for.

Python: a lookup that handles every case

import re
import requests

BASE = "https://clinicaltrials.gov/api/v2/studies"

def normalize_nct(raw):
    """'nct4437511', ' NCT04437511 ' -> 'NCT04437511' (NCT + 8 digits)."""
    s = raw.strip().upper().replace(" ", "")
    m = re.fullmatch(r"NCT(\d{1,8})", s)
    if not m:
        raise ValueError(f"not an NCT number: {raw!r}")
    return "NCT" + m.group(1).zfill(8)

def get_study(nct_id, fields=None):
    nct_id = normalize_nct(nct_id)
    params = {"fields": ",".join(fields)} if fields else {}
    r = requests.get(f"{BASE}/{nct_id}", params=params, timeout=30)
    if r.status_code == 404:
        return None  # body is plain text: "NCT number ... not found"
    r.raise_for_status()
    # An old alias NCT ID answers 301 to the current record. The redirect drops
    # the query string, so re-request the canonical ID to keep `fields`.
    if r.history and fields:
        canonical = r.url.rstrip("/").rsplit("/", 1)[-1]
        r = requests.get(f"{BASE}/{canonical}", params=params, timeout=30)
        r.raise_for_status()
    return r.json()

def get_many(nct_ids, fields):
    """Up to 1,000 trials in one call with filter.ids."""
    ids = [normalize_nct(x) for x in nct_ids]
    r = requests.get(BASE, params={
        "filter.ids": ",".join(ids),
        "fields": ",".join(fields),
        "pageSize": 1000,
    }, timeout=60)
    r.raise_for_status()
    return r.json()["studies"]

if __name__ == "__main__":
    FIELDS = ["NCTId", "BriefTitle", "OverallStatus", "Phase", "LeadSponsorName", "HasResults"]
    s = get_study("nct4437511", FIELDS)
    p = s["protocolSection"]
    print(p["identificationModule"]["nctId"], "|", p["identificationModule"]["briefTitle"])
    print(p["statusModule"]["overallStatus"], p["designModule"]["phases"],
          p["sponsorCollaboratorsModule"]["leadSponsor"]["name"], "hasResults:", s["hasResults"])

    print(get_study("NCT99999999"))  # -> None

    alias = get_study("NCT00009113", ["NCTId", "NCTIdAlias", "BriefTitle"])
    print(alias["protocolSection"]["identificationModule"])

    for st in get_many(["NCT04437511", "NCT04368728", "NCT00010647"], ["NCTId", "OverallStatus"]):
        p = st["protocolSection"]
        print(p["identificationModule"]["nctId"], p["statusModule"]["overallStatus"])

Output on 2026-10-14:

NCT04437511 | A Study of Donanemab (LY3002813) in Participants With Early Alzheimer's Disease (TRAILBLAZER-ALZ 2)
ACTIVE_NOT_RECRUITING ['PHASE3'] Eli Lilly and Company hasResults: True
None
{'nctId': 'NCT00010647', 'nctIdAliases': ['NCT00009113'], 'briefTitle': 'Cost-Effectiveness of and Long-Term Outcomes Following Acupuncture Treatment for Osteoarthritis of the Knee'}
NCT00010647 COMPLETED
NCT04437511 ACTIVE_NOT_RECRUITING
NCT04368728 COMPLETED

Details that trip people up

Aliases redirect and drop your query string. Some studies were registered twice and merged. The old ID is kept in nctIdAliases, and requesting it returns a 301 to the current ID. In the test above, the redirect target had no ?fields= on it, so following it blindly returns the full record. On 2026-10-14 there were 3,164 studies with at least one alias.
Batch lookups don't keep your order. filter.ids returned the three studies in the API's order, not the order I sent. Index the results by nctId.
NCT IDs in a search query switch filters off. The /studies docs say: "If any query parameter contains only NCT IDs (comma- and/or space-separated), filters are ignored." I sent query.term=NCT04437511 NCT04368728 with filter.overallStatus=RECRUITING and got both studies back, although neither is recruiting. Use filter.ids when you want the filters applied.
Document PDFs live on a CDN. documentSection.largeDocumentModule.largeDocs lists file names such as Prot_000.pdf. For NCT04437511 the file was at https://cdn.clinicaltrials.gov/large-docs/11/NCT04437511/Prot_000.pdf, where 11 is the last two digits of the NCT number. That path pattern is what I observed; it isn't documented in the API spec.
There is no history endpoint. The v2 API returns only the current version. Past versions are on the website's History of Changes tab (https://clinicaltrials.gov/study/NCT04437511?tab=history). The internal endpoint the site appears to use, /api/int/studies/{nctId}/history, returned HTTP 403 to a script.

Related guides for this API

ClinicalTrials.gov API v2 query parameters: the full reference, for searching rather than fetching one ID.
Get completed trial results with the ClinicalTrials.gov API, which reads the resultsSection this page skipped.
Migrating from the classic ClinicalTrials.gov API to v2, if your code still calls /api/query/full_studies.
Export ClinicalTrials.gov search results to CSV in Python.

Do it without code

The free ClinicalTrials.gov search tool calls this same API live from your browser. Search by condition or drug and filter by phase and status. It shows each study's NCT ID, title, status, phase and lead sponsor. No login, no key.

At scale

To look up hundreds of NCT numbers and join the trials with FDA approvals, device clearances, adverse events and recalls, use the Clinical Trials & FDA Pipeline actor on Apify. Its trial_details mode takes a list of NCT IDs (nctIds) and returns one flat row per trial: status, phase, enrollment, primary and secondary endpoints, eligibility criteria, sponsors and locations. It exports JSON, CSV or Excel. It's free to start, then pay-as-you-go.

Disclosure: I build the datatooly tool and the Apify actor. Everything above works with the public API alone.

Sources: ClinicalTrials.gov API (interactive OpenAPI docs), Study data structure, and live responses from clinicaltrials.gov/api/v2 on 2026-10-14.

SEC EDGAR Rate Limit and User-Agent: Fair Access Rules

Omar Eldeeb — Wed, 14 Oct 2026 17:38:13 +0000

SEC EDGAR's fair-access rules are short. Send a User-Agent with your name or company and a contact email, such as Acme Research admin@acme.com, and stay at or under 10 requests per second in total across all your machines. No User-Agent, or a library default, gets HTTP 403. Go over the rate and your IP can be limited until it stays under it for 10 minutes.

The SEC EDGAR API in Python guide gives the short version. This page goes further: the exact wording of each rule, what the server actually does (tested on 2026-10-14), and a client that follows the rules.

The rules, in the SEC's words

User-Agent. From Accessing EDGAR Data:

Please declare your user agent in request headers:
Sample Declared Bot Request Headers:
User-Agent: Sample Company Name AdminContact@<sample company domain>.com

The webmaster FAQ repeats that sample and adds Accept-Encoding: gzip, deflate and Host: www.sec.gov.

Rate. Accessing EDGAR Data says "Current max request rate: 10 requests/second" and "SEC reserves the right to limit request rates to preserve fair access for all users." The SEC.gov privacy and security policy gives the details:

Current guidelines limit users to a total of no more than 10 requests per second, regardless of the number of machines used to submit requests.

If a user or application submits more than 10 requests per second, further requests from the IP address(es) may be limited for a brief period. Once the rate of requests has dropped below the threshold for 10 minutes, the user may resume accessing content on SEC.gov.

Three details matter in practice:

The limit is per user, not per IP. Ten workers each doing 2 requests per second is 20 per second, which is over the limit.
The block is not a fixed 10 minutes. It lasts until your rate has stayed below the threshold for 10 minutes. If you keep retrying at full speed while blocked, the 10 minutes never start.
It covers all of SEC.gov. That includes data.sec.gov (submissions, XBRL), efts.sec.gov (full-text search) and www.sec.gov (Archives, company_tickers.json).

The SEC also says it doesn't "offer technical support for developing or debugging scripted downloading processes", and that the policy "may change".

What the server did on 2026-10-14

Each User-Agent below was sent to https://data.sec.gov/submissions/CIK0000789019.json, with a one-second pause between requests:

User-Agent sent	Status
(header removed)	403
`curl/8.15.0` (curl's default)	403
`python-requests/2.32.3` (requests' default format)	403
`MyApp/1.0`	200
`Mozilla/5.0`	200
`contact@example.com`	200
`Jane Doe jane@example.com`	200
`Data Tooly research contact@example.com`	200

curl's default also got 403 from efts.sec.gov and from www.sec.gov (/files/company_tickers.json and an Archives document).

What this shows: the automatic 403 catches missing and default library User-Agents. It didn't check whether an email was present. A 200 doesn't make a request compliant, though. The policy asks for company-specific information and a contact, and the SEC can manage traffic it can't identify. Send Name or Company contact@yourdomain and you meet the rule as written.

The 403 page

The 403 body is an HTML page, not JSON. Its key lines:

Your Request Originates from an Undeclared Automated Tool

To allow for equitable access to all users, SEC reserves the right to limit requests originating from undeclared automated tools. Your request has been identified as part of a network of automated tools outside of the acceptable policy and will be managed until action is taken to declare your traffic.

Please declare your traffic by updating your user agent to include company specific information.

The page also includes a Reference ID. If you think you've been blocked by mistake, the SEC points you to opendata@sec.gov.

A client that follows the rules

import threading
import time
import requests

class SecClient:
    """requests.Session that declares a User-Agent, stays under a request rate,
    and tells an undeclared-tool block apart from a temporary limit."""

    def __init__(self, user_agent, max_per_second=8):
        self.s = requests.Session()
        self.s.headers.update({"User-Agent": user_agent, "Accept-Encoding": "gzip, deflate"})
        self.min_interval = 1.0 / max_per_second
        self.lock = threading.Lock()  # one shared pace across threads
        self.last = 0.0

    def _wait_turn(self):
        with self.lock:
            delay = self.last + self.min_interval - time.monotonic()
            if delay > 0:
                time.sleep(delay)
            self.last = time.monotonic()

    def get(self, url, retries=4, **kw):
        for attempt in range(retries + 1):
            self._wait_turn()
            r = self.s.get(url, timeout=60, **kw)
            if r.status_code == 403 and "Undeclared Automated Tool" in r.text:
                # Retrying won't help: fix the User-Agent.
                raise RuntimeError("SEC blocked the request as an undeclared automated tool")
            if r.status_code in (403, 429, 503) and attempt < retries:
                wait = float(r.headers.get("Retry-After", 0)) or min(60 * 2 ** attempt, 600)
                time.sleep(wait)  # back off; the SEC lifts limits after 10 quiet minutes
                continue
            r.raise_for_status()
            return r
        raise RuntimeError(f"gave up on {url}")

sec = SecClient("Data Tooly research contact@example.com")

# 20 requests: the client spaces them at 8 per second.
t0 = time.monotonic()
for cik in [320193, 789019, 1652044, 1018724, 1045810] * 4:
    sec.get(f"https://data.sec.gov/submissions/CIK{cik:010d}.json")
elapsed = time.monotonic() - t0
print(f"20 requests in {elapsed:.1f}s = {20 / elapsed:.1f} req/s")

# What a missing or default User-Agent gets.
bad = SecClient("python-requests/2.32.3")
try:
    bad.get("https://data.sec.gov/submissions/CIK0000320193.json")
except RuntimeError as e:
    print("blocked:", e)

Output on 2026-10-14:

20 requests in 3.3s = 6.0 req/s
blocked: SEC blocked the request as an undeclared automated tool

Design notes:

Pace below 10, not at 10. At 8 per second you have room for clock jitter and a second script you forgot was running. The measured 6 per second is lower because each request also waits for the network; the limiter only sets a ceiling.
One limiter for the whole job. The lock makes threads share one pace. For several processes or machines, divide the budget between them, because the SEC counts your total.
Don't retry the undeclared-tool 403. Every retry is another undeclared request. Fix the header instead.
Back off for minutes, not seconds, on other errors. The SEC doesn't document which status code a rate-limited client gets, and I didn't trigger the limit to find out. The client therefore backs off on 403, 429 and 503, from 1 minute up to 10, which fits the "below the threshold for 10 minutes" rule.

Need more than 10 per second? Use the bulk files

The SEC's EDGAR APIs page calls the nightly ZIP archives "the most efficient means to fetch large amounts of API data":

File	Contains
`https://www.sec.gov/Archives/edgar/daily-index/xbrl/companyfacts.zip`	All data from the XBRL frames and company facts APIs
`https://www.sec.gov/Archives/edgar/daily-index/bulkdata/submissions.zip`	The filing history of every filer, from the submissions API

One download instead of tens of thousands of requests keeps you within the rules without trying.

Can a browser call the SEC APIs?

Not in a way that meets the rule. A web page can't choose the User-Agent its browser sends, so it can't declare itself the way the SEC asks. Run SEC requests server-side, which is why the free tool below is a query builder rather than a live search.

Related guides for this API

SEC EDGAR API in Python: the overview, with a full example.
Submissions API and ticker to CIK.
Company facts, company concept and frames.
EDGAR full-text search API.

Do it without code

The free SEC EDGAR query builder assembles a ready-to-run query for filings, financials, full-text search or insider trades from plain tickers, and shows the output shape. You run it server-side, where the User-Agent can be set.

At scale

The SEC EDGAR Scraper actor on Apify sends a declared User-Agent, paces its requests and handles paging for you across nine modes: filings, financials, XBRL facts, full-text search, Form 4, 13F, 13D/G, a latest-filings feed and 8-K items. It exports JSON, CSV or Excel. It's free to start, then pay-as-you-go.

Disclosure: I build the datatooly query builder and the Apify actor. The rules and the client above apply with or without them.

Sources: SEC: Accessing EDGAR Data, SEC webmaster FAQ, Developers section, SEC.gov privacy and security policy, SEC: EDGAR APIs, and live responses on 2026-10-14.

SEC Company Facts API: companyfacts, concept & frames

Omar Eldeeb — Wed, 14 Oct 2026 17:37:41 +0000

The SEC's XBRL APIs on data.sec.gov return reported financials as JSON, free and with no API key. companyfacts/CIK##########.json gives every fact for one company. companyconcept/CIK##########/us-gaap/{Tag}.json gives one tag for one company. frames/us-gaap/{Tag}/{Unit}/CY{Year}.json gives one tag across all companies for one period. Pad the CIK to 10 digits and send a User-Agent.

This page covers the three endpoints, the JSON they return, and the traps that silently give you wrong numbers. All code was run on 2026-10-14.

The three endpoints

From the SEC's EDGAR APIs page:

Endpoint	URL pattern	Returns
Company facts	`https://data.sec.gov/api/xbrl/companyfacts/CIK##########.json`	"all the company concepts data for a company"
Company concept	`https://data.sec.gov/api/xbrl/companyconcept/CIK##########/us-gaap/AccountsPayableCurrent.json`	"all the XBRL disclosures from a single company (CIK) and concept (a taxonomy and tag)", with "a separate array of facts for each units on measure"
Frames	`https://data.sec.gov/api/xbrl/frames/us-gaap/AccountsPayableCurrent/USD/CY2019Q1I.json`	"one fact for each reporting entity that is last filed that most closely fits the calendrical period requested"

The SEC says the facts come from financial statements in "forms 10-Q, 10-K, 8-K, 20-F, 40-F, 6-K, and their variants". They are limited to standard taxonomies (us-gaap, ifrs-full, dei, srt) and to facts that apply to the whole company. The XBRL APIs update in real time "with a typical processing delay of under a minute".

Frame periods and units

Period	Format	Meaning (from the SEC page)
Annual	`CY2024`	Duration of 365 days, plus or minus 30
Quarterly	`CY2024Q1`	Duration of 91 days, plus or minus 30
Instant	`CY2024Q1I`	A point in time, for balance-sheet items

Units are USD, shares, pure (the default XBRL unit), or a ratio joined with -per-, such as USD-per-shares for EPS. frames/us-gaap/EarningsPerShareBasic/USD-per-shares/CY2024.json returned 5,591 companies.

The JSON

companyfacts has the shape {cik, entityName, facts: {taxonomy: {Tag: {label, description, units: {unit: [fact, ...]}}}}}. Apple's file on 2026-10-14 was 3.8 MB, with the dei and us-gaap taxonomies and 503 us-gaap concepts. One fact:

{"start": "2026-03-29", "end": "2026-06-27", "val": 29789000000,
 "accn": "0000320193-26-000020", "fy": 2026, "fp": "Q3", "form": "10-Q",
 "filed": "2026-07-31", "frame": "CY2026Q2"}

Field	Meaning
`start`, `end`	The period the value covers. Instant facts have only `end`.
`val`	The value, in the unit you are under
`accn`	Accession number of the filing that reported it
`fy`, `fp`	Fiscal year and period of the filing, not of the fact (see trap 1)
`form`, `filed`	Form type and filing date
`frame`	Present on the one fact the SEC chose for that calendar period (see trap 2)

frames has the shape {taxonomy, tag, ccp, uom, label, description, pts, data: [{accn, cik, entityName, loc, start, end, val}]}, where pts is the number of companies.

Python: all three, plus a CSV for Excel

import csv
import time
from datetime import date
import requests

HEADERS = {"User-Agent": "Data Tooly research contact@example.com"}  # use your own name + email
XBRL = "https://data.sec.gov/api/xbrl"

def get(url):
    r = requests.get(url, headers=HEADERS, timeout=60)
    r.raise_for_status()  # 404 = wrong CIK padding, tag, unit or period
    time.sleep(0.15)      # stay under 10 requests/second
    return r.json()

def cik10(cik):
    return f"CIK{int(cik):010d}"

def annual_from_10k(facts):
    """One value per fiscal year: full-year facts from 10-K filings, latest filing wins."""
    best = {}
    for f in facts:
        if f.get("form") not in ("10-K", "10-K/A") or "start" not in f:
            continue
        days = (date.fromisoformat(f["end"]) - date.fromisoformat(f["start"])).days
        if 350 <= days <= 380 and (f["end"] not in best or f["filed"] > best[f["end"]]["filed"]):
            best[f["end"]] = f
    return [best[k] for k in sorted(best)]

# 1. companyfacts: every XBRL fact a company has reported, in one call.
facts = get(f"{XBRL}/companyfacts/{cik10(320193)}.json")
print(facts["entityName"], "| taxonomies:", list(facts["facts"]),
      "| us-gaap concepts:", len(facts["facts"]["us-gaap"]))
for f in annual_from_10k(facts["facts"]["us-gaap"]["NetIncomeLoss"]["units"]["USD"])[-3:]:
    print(f"  FY ending {f['end']}: ${f['val']:,}  (fy {f['fy']}, filed {f['filed']}, frame {f.get('frame')})")

# 2. companyconcept: one tag for one company.
rev = get(f"{XBRL}/companyconcept/{cik10(320193)}/us-gaap/RevenueFromContractWithCustomerExcludingAssessedTax.json")
last = annual_from_10k(rev["units"]["USD"])[-1]
print(rev["label"], "| FY ending", last["end"], f"${last['val']:,}")

# 3. frames: one tag for every company, one period.
frame = get(f"{XBRL}/frames/us-gaap/NetIncomeLoss/USD/CY2024.json")
print("CY2024 NetIncomeLoss:", frame["pts"], "companies; largest values:")
for d in sorted(frame["data"], key=lambda d: d["val"], reverse=True)[:5]:
    print(f"  {d['entityName'][:28]:28s} ${d['val']:,}  accn {d['accn']}")

# 4. Check a suspicious frame value against every fact behind it.
trr = get(f"{XBRL}/companyfacts/{cik10(1573221)}.json")["facts"]["us-gaap"]["NetIncomeLoss"]["units"]["USD"]
for f in trr:
    if f.get("start") == "2024-01-01" and f["end"] == "2024-12-31":
        print(f"  TheRealReal FY2024: {f['val']:,}  form {f['form']:8s} filed {f['filed']}  frame {f.get('frame')}")

# 5. Save the frame to CSV (opens in Excel).
with open("net_income_cy2024.csv", "w", newline="", encoding="utf-8") as fh:
    w = csv.DictWriter(fh, fieldnames=["cik", "entityName", "loc", "start", "end", "val", "accn"])
    w.writeheader()
    w.writerows(frame["data"])
print("wrote", len(frame["data"]), "rows to net_income_cy2024.csv")

Output on 2026-10-14:

Apple Inc. | taxonomies: ['dei', 'us-gaap'] | us-gaap concepts: 503
  FY ending 2023-09-30: $96,995,000,000  (fy 2025, filed 2025-10-31, frame CY2023)
  FY ending 2024-09-28: $93,736,000,000  (fy 2025, filed 2025-10-31, frame CY2024)
  FY ending 2025-09-27: $112,010,000,000  (fy 2025, filed 2025-10-31, frame CY2025)
Revenue from Contract with Customer, Excluding Assessed Tax | FY ending 2025-09-27 $416,161,000,000
CY2024 NetIncomeLoss: 6068 companies; largest values:
  TheRealReal, Inc.            $134,202,000,000  accn 0001573221-26-000036
  Alphabet Inc.                $100,118,000,000  accn 0001308179-26-000342
  HighPeak Energy, Inc.        $95,069,000,000  accn 0001437749-26-014193
  Apple Inc.                   $93,736,000,000  accn 0000320193-25-000079
  BERKSHIRE HATHAWAY INC       $88,995,000,000  accn 0001193125-26-083899
  TheRealReal FY2024: -134,202,000  form 10-K     filed 2025-02-21  frame None
  TheRealReal FY2024: -134,202,000  form 10-K     filed 2026-02-26  frame None
  TheRealReal FY2024: 134,202,000,000  form PRE 14A  filed 2026-04-15  frame None
  TheRealReal FY2024: 134,202,000,000  form DEF 14A  filed 2026-04-27  frame CY2024
wrote 6068 rows to net_income_cy2024.csv

The first rows of the CSV:

cik,entityName,loc,start,end,val,accn
1750,AAR CORP.,-,2024-06-01,2025-05-31,12500000,0001140361-26-031078
1800,Abbott Laboratories,US-IL,2024-01-01,2024-12-31,13402000000,0001628280-26-010185

The traps

1. `fy` is the filing's fiscal year, not the fact's

All three Apple values above carry fy 2025, including the year that ended in September 2023. They were all reported in the 10-K filed on 2025-10-31, which shows three years of income statement. To label a value by its own period, use end (or start and end). Don't group by fy.

2. A `frame` value can come from the wrong filing

The frames API returns the fact that was last filed for the period. The output above shows what that can do. TheRealReal's 10-Ks report a 2024 net loss of $134,202,000. A proxy statement (DEF 14A) filed in April 2026 tagged the same line as +$134,202,000,000: the opposite sign and 1,000 times larger. Because it was filed last, it became the CY2024 frame value, and TheRealReal ranked first in the frame, ahead of Alphabet. HighPeak Energy has the same pattern: $95,069,000 in its 10-Ks, $95,069,000,000 in a DEF 14A.

What to do:

For one company's history, filter on form (10-K, 10-K/A, 10-Q) and take the latest filing per period, as annual_from_10k does, instead of trusting frame.
For cross-company frames, sanity-check outliers. For any value that looks off, open that company's companyfacts and compare the facts behind it.

3. Duplicates are normal

The same period appears once for every filing that reported it. Apple's fiscal 2024 net income is in both the 2024 and the 2025 10-K. Only one copy has frame. Summing facts without de-duplicating double-counts.

4. The tag you guess may not exist

companyconcept/CIK0000320193/us-gaap/Revenue.json returned HTTP 404 with an XML NoSuchKey body. Apple reports revenue as RevenueFromContractWithCustomerExcludingAssessedTax. Across all filers, the CY2024 frame for that tag had 2,972 companies and the frame for Revenues had 2,507. The older SalesRevenueNet had 1,649 companies in CY2017. Some companies change tags over the years. List the keys of facts["us-gaap"] from companyfacts to see which tags a company really uses.

5. 404s are XML, and the CIK must be padded

Every miss (an unpadded CIK such as CIK320193.json, a tag that doesn't exist, or a period without the CY prefix) returned HTTP 404 with an XML error body, not JSON. Check the status before parsing.

Bulk alternative

For every company at once, the SEC publishes https://www.sec.gov/Archives/edgar/daily-index/xbrl/companyfacts.zip. It "contains all the data from the XBRL Frame API and the XBRL Company Facts API", is recompiled nightly, and is the SEC's recommended way to fetch large amounts of data.

Related guides for this API

Submissions API and ticker to CIK: find the CIK these URLs need.
EDGAR full-text search API: find filings by what they say.
SEC rate limits and User-Agent rules: the 403 and the 10-per-second limit.
SEC EDGAR API in Python, the overview guide.

Do it without code

The free SEC EDGAR query builder builds a financials query from tickers and shows the output shape. It's a query builder: browsers can't send the User-Agent the SEC requires, so the data is fetched server-side when you run the query.

At scale

The SEC EDGAR Scraper actor on Apify has a financials mode that returns normalized income statement, balance sheet and cash flow rows per ticker, and an xbrl_facts mode for raw facts by concept (xbrlConcepts). It resolves tickers to CIKs, paces requests, and exports JSON, CSV or Excel. It's free to start, then pay-as-you-go.

Disclosure: I build the datatooly query builder and the Apify actor. The endpoints above work without either.

Sources: SEC: EDGAR Application Programming Interfaces, SEC: Accessing EDGAR Data, and live data.sec.gov responses on 2026-10-14.

EDGAR Full-Text Search API: efts.sec.gov Parameters

Omar Eldeeb — Wed, 14 Oct 2026 17:37:09 +0000

EDGAR full-text search has a JSON endpoint: https://efts.sec.gov/LATEST/search-index?q=.... Pass a phrase in q, filter with forms, ciks (10-digit) and startdt/enddt, and page with from in steps of 100. No API key is needed, but you must send a User-Agent naming you. The SEC doesn't document this endpoint as an API; it's the backend of its Full-Text Search page.

This page documents what each parameter actually does. Every response from the endpoint includes a query object, the Elasticsearch query it ran, so the table below comes from those echoes plus live tests on 2026-10-14. It is not from an official spec, because there isn't one.

What full-text search covers

From the SEC's Full-Text Search FAQ: it searches "the full text of all EDGAR filings submitted electronically since 2001", and "the full text of a filing includes all data in the filing itself as well as all attachments (such as exhibits)". Natural-language queries aren't supported.

Each result is one document, not one filing. A 10-K and its exhibits are separate hits that share an accession number. In one page of 100 hits I found 99 distinct filings.

Parameters

Parameter	What it does (from the echoed query)	Example
`q`	Searches document text. A quoted phrase is a phrase match. Words without quotes are each required.	`q="supply chain disruption"`
`forms`	Filters on `root_forms`, comma-separated. Upper case only: `8-k` matched 0 documents where `8-K` matched 831. `10-K` also returns `10-K/A`.	`forms=10-K,8-K`
`ciks`	Filters on `ciks`. Must be zero-padded to 10 digits: `320193` matched 0, `0000320193` matched 12.	`ciks=0000320193`
`startdt`, `enddt`	Range on `file_date`, format `yyyy-mm-dd`. Works with or without `dateRange=custom`.	`startdt=2025-01-01&enddt=2025-12-31`
`dateRange`	Ignored by the endpoint. `30d`, `1y`, `5y` and `all` produced no date filter; the website turns them into `startdt`/`enddt` itself.
`from`	Offset of the first hit. `from=9900` worked; `from=10000` returned no hits.	`from=100`
`sort`	`desc` or `asc` sorts by `file_date`. Without it, results are ranked by relevance.	`sort=desc`
`locationCodes`	Filters on business-address state (`biz_states`).	`locationCodes=CA`
`locationType=incorporated`	Makes `locationCodes` filter on state of incorporation (`inc_states`) instead.	`locationType=incorporated&locationCodes=DE`
`entityName`	Adds a loose word match on company names. `Apple Inc.` became separate matches for `Apple` and `Inc.`, giving 43 results against 12 for Apple's CIK. Prefer `ciks`.
`hits`, `size`, `page`	Ignored. The page size is always 100.

Query syntax in `q`

These all ran on 2026-10-14. The syntax matches the FAQ.

You type	It becomes
`"supply chain disruption"`	Exact phrase
`software hardware`	Both words required (implied AND)
`tariff OR tariffs -china`	Either word, and not "china" (`-` or `NOT` excludes)
`tariff NEAR(5) china`	Both words within 5 words of each other, in any order (default 10)
`gas*`	Prefix wildcard (only at the end of a word)

An empty q with no other filter returns nothing. But forms plus dates with no q works: forms=8-K&startdt=2026-10-13&enddt=2026-10-13 returned the day's 252 8-K documents.

The response

{
  "took": 293,
  "hits": {
    "total": {"value": 331, "relation": "eq"},
    "hits": [{
      "_id": "0001640334-25-001300:acro_10k.htm",
      "_source": {
        "ciks": ["0001622996"],
        "display_names": ["ACRO BIOMEDICAL CO., LTD.  (CIK 0001622996)"],
        "form": "10-K", "root_forms": ["10-K"], "file_type": "10-K",
        "file_date": "2025-07-24", "period_ending": "2024-12-31",
        "adsh": "0001640334-25-001300", "sequence": 1,
        "sics": ["7900"], "biz_states": ["IN"], "inc_states": ["NV"],
        "biz_locations": ["Fishers, IN"], "file_num": ["000-55643"], "items": []
      }
    }]
  },
  "aggregations": {"entity_filter": {}, "sic_filter": {}, "biz_states_filter": {}, "form_filter": {}},
  "query": {}
}

That's a trimmed real hit from the query below. The fields you'll use most:

hits.total.value with relation. When relation is "gte", the value is capped at 10,000 and the true count is higher.
_id is accession:filename. Together with the first CIK, it gives the document URL (see doc_url below).
adsh is the accession number, the same for every document in a filing.
items lists 8-K item numbers when the document belongs to an 8-K.
aggregations gives the top 30 companies, SIC codes, states and forms for the whole result set. That's useful for counts without paging.

Python: search, page and link to documents

import time
import requests

EFTS = "https://efts.sec.gov/LATEST/search-index"
HEADERS = {"User-Agent": "Data Tooly research contact@example.com"}  # use your own name + email

def search(q, forms=None, ciks=None, start=None, end=None, max_hits=300):
    """Yield full-text search hits, 100 per page, following `from`."""
    params = {"q": q}
    if forms:
        params["forms"] = ",".join(forms)           # upper case: "8-K", not "8-k"
    if ciks:
        params["ciks"] = ",".join(f"{int(c):010d}" for c in ciks)  # must be 10 digits
    if start or end:
        params.update(dateRange="custom", startdt=start, enddt=end)  # yyyy-mm-dd
    offset = 0
    while offset < max_hits:
        r = requests.get(EFTS, params={**params, "from": offset}, headers=HEADERS, timeout=60)
        r.raise_for_status()
        hits = r.json()["hits"]["hits"]
        if not hits:
            return
        yield from hits
        offset += len(hits)                         # the page size is fixed at 100
        time.sleep(0.2)                             # stay well under 10 requests/second

def doc_url(hit):
    """Build the sec.gov URL of the matching document."""
    adsh, filename = hit["_id"].split(":", 1)
    cik = int(hit["_source"]["ciks"][0])
    return f"https://www.sec.gov/Archives/edgar/data/{cik}/{adsh.replace('-', '')}/{filename}"

first = requests.get(EFTS, headers=HEADERS, timeout=60, params={
    "q": '"supply chain disruption"', "forms": "10-K",
    "dateRange": "custom", "startdt": "2025-01-01", "enddt": "2025-12-31"}).json()
print("total:", first["hits"]["total"])
print("forms:", [(b["key"], b["doc_count"]) for b in first["aggregations"]["form_filter"]["buckets"]])
print("top states:", [(b["key"], b["doc_count"]) for b in first["aggregations"]["biz_states_filter"]["buckets"][:3]])

hits = list(search('"supply chain disruption"', forms=["10-K"], start="2025-01-01", end="2025-12-31"))
print(len(hits), "hits,", len({h["_source"]["adsh"] for h in hits}), "distinct filings")
h = hits[0]["_source"]
print(h["display_names"][0], "|", h["form"], h["file_date"], "| period", h["period_ending"])
print(doc_url(hits[0]))

apple = list(search("tariff", ciks=[320193]))
print("Apple filings mentioning tariff:", len(apple), sorted({x["_source"]["form"] for x in apple}))

Output on 2026-10-14:

total: {'value': 331, 'relation': 'eq'}
forms: [('10-K', 331)]
top states: [('CA', 68), ('NY', 28), ('TX', 26)]
300 hits, 299 distinct filings
ACRO BIOMEDICAL CO., LTD.  (CIK 0001622996) | 10-K 2025-07-24 | period 2024-12-31
https://www.sec.gov/Archives/edgar/data/1622996/000164033425001300/acro_10k.htm
Apple filings mentioning tariff: 12 ['10-K', '10-K405', '10-Q', '8-K', 'DEF 14A', 'PX14A6G', 'SC TO-I']

The document URL returned HTTP 200. The filing's index is at the same folder plus {accession}-index.htm, or index.json for a machine-readable listing.

The same first query with curl:

curl -s -A "Data Tooly research contact@example.com" \
  "https://efts.sec.gov/LATEST/search-index?q=%22supply+chain+disruption%22&forms=10-K&dateRange=custom&startdt=2025-01-01&enddt=2025-12-31"

Traps that return wrong data without an error

None of these return an error. You just get wrong or empty results:

Unpadded CIK → 0 results. ciks=320193 returns an empty result with HTTP 200. Always pad: f"{cik:010d}".
Lowercase form → 0 results. forms=8-k matched nothing.
dateRange=30d does nothing. Send startdt and enddt yourself.
A badly formatted date is ignored. startdt=2026/01/01 returned unfiltered results. Use yyyy-mm-dd.
The 10,000-hit ceiling. from can't go past 9,900. To collect more, split the date range into smaller windows, for example month by month, so each window stays under 10,000.
Hits are documents. Count filings with distinct adsh, not with len(hits).

Rate limit and User-Agent

The endpoint follows SEC.gov's fair-access rules: at most 10 requests per second, and a declared User-Agent. With no User-Agent, or with curl's or python-requests' default, efts.sec.gov answered HTTP 403. The SEC rate limit and User-Agent guide covers the exact format and the block behavior.

Related guides for this API

SEC EDGAR API in Python: User-Agent, rate limits, XBRL, the overview.
Submissions API and ticker to CIK: get the 10-digit CIK that ciks= needs.
Company facts, company concept and frames: the numbers inside the filings you found.
SEC rate limits and User-Agent rules.

Do it without code

The free SEC EDGAR query builder assembles a full-text search configuration, with tickers, forms and dates, and shows the output shape. It's a query builder, not a live search: browsers can't send the User-Agent the SEC requires, so the query runs server-side.

At scale

The SEC EDGAR Scraper actor on Apify has a full_text_search mode (searchQuery, searchCiks, forms, dateFrom, dateTo) that handles the User-Agent, pacing and paging, and returns clean rows as JSON, CSV or Excel. It also has a latest_feed mode for new filings. It's free to start, then pay-as-you-go.

Disclosure: I build the datatooly query builder and the Apify actor. The endpoint works the same without them.

Sources: SEC Full-Text Search FAQ, SEC: Accessing EDGAR Data, and live responses from efts.sec.gov on 2026-10-14, including each response's echoed query object.

Hacker News Firebase API vs Algolia: Which One to Use

Omar Eldeeb — Wed, 14 Oct 2026 17:36:37 +0000

Use the official Firebase API (https://hacker-news.firebaseio.com/v0/) for the front-page ranking (topstories), live lists and exact item lookups. Use the Algolia API (https://hn.algolia.com/api/v1/) for anything you need to search or filter by keyword, author, points or date. Firebase has no search and returns IDs you fetch one by one. Algolia returns full records in one call.

Both are free, need no key, and send Access-Control-Allow-Origin: *. I ran the same tasks through both on 2026-10-14. Here is how they differ.

Side by side

	Firebase (official)	Algolia (HN Search)
Base URL	`https://hacker-news.firebaseio.com/v0/`	`https://hn.algolia.com/api/v1/`
Docs	HackerNews/API on GitHub	HN Search API page
Run by	Hacker News, on Firebase	Algolia
Search, filters	None	Full-text query, `tags`, `numericFilters`
Front-page ranking	`topstories`, in rank order	`tags=front_page`: the same set, not in rank order
Response shape	Lists of IDs, then one item per request	Full hits, up to 1,000 per request
Comment trees	`kids` IDs only; walk them yourself	`/items/{id}` returns the nested tree
Deleted and dead items	Returned, flagged `deleted` / `dead`	Not returned
Rate limit	"There is currently no rate limit."	"10,000 per hour" per IP
Field names	`by`, `score`, `time`, `descendants`, `kids`	`author`, `points`, `created_at_i`, `num_comments`, `children`

Firebase endpoints

Every path ends in .json. Without it, the server answered HTTP 301.

Endpoint	Returns	Count on 2026-10-14
`/v0/topstories.json`	Front-page ranking, including jobs	500 IDs (docs: up to 500)
`/v0/newstories.json`	Newest stories	500 IDs (docs: up to 500)
`/v0/beststories.json`	Best stories	200 IDs
`/v0/askstories.json`	Latest Ask HN	22 IDs (docs: up to 200)
`/v0/showstories.json`	Latest Show HN	177 IDs (docs: up to 200)
`/v0/jobstories.json`	Latest jobs	31 IDs (docs: up to 200)
`/v0/item/{id}.json`	One story, comment, job, poll or poll option
`/v0/user/{id}.json`	`id`, `created`, `karma`, `about`, `submitted`	Usernames are case-sensitive: `PG` returned `null`
`/v0/maxitem.json`	The highest item ID	50090563 at the time
`/v0/updates.json`	`items` and `profiles` that changed recently	97 items, 26 profiles

The item fields, per the official docs: id, deleted, type, by, time, text, dead, parent, poll, kids, url, score, title, parts and descendants. The docs say kids are "in ranked display order" and descendants is "the total comment count" of a story or poll. Only id is guaranteed; a field that doesn't apply is absent, not null.

Firebase also accepts its REST query parameters. topstories.json?orderBy="$key"&limitToFirst=3 returned only the first three IDs, and ?print=pretty indents the output.

Same task, both APIs

Fetching the current front page:

import time
from concurrent.futures import ThreadPoolExecutor

import requests

FB = "https://hacker-news.firebaseio.com/v0"
ALGOLIA = "https://hn.algolia.com/api/v1"
s = requests.Session()


def fb(path):
    r = s.get(f"{FB}/{path}.json", timeout=30)
    r.raise_for_status()
    return r.json()  # a missing item is HTTP 200 with the body `null`


# Official API: the ranked list, then one request per story.
t0 = time.time()
ids = fb("topstories")[:30]
with ThreadPoolExecutor(10) as ex:
    stories = [x for x in ex.map(lambda i: fb(f"item/{i}"), ids) if x]
print(f"Firebase: {len(stories)} stories in {time.time() - t0:.1f}s ({len(ids) + 1} requests)")
for rank, st in enumerate(stories[:3], 1):
    print(f"  #{rank} {st['score']} pts, {st.get('descendants', 0)} comments: {st['title']}")

# Algolia: one request for the stories on the front page now (not in rank order).
t0 = time.time()
hits = s.get(f"{ALGOLIA}/search", params={"tags": "front_page", "hitsPerPage": 50}, timeout=30).json()["hits"]
print(f"Algolia front_page: {len(hits)} stories in {time.time() - t0:.1f}s (1 request)")
print(f"  same IDs as Firebase top 30: {len({int(h['objectID']) for h in hits} & set(ids))}")

# Firebase list endpoints and how many IDs each returned today.
for name in ["topstories", "newstories", "beststories", "askstories", "showstories", "jobstories"]:
    print(f"{name:<12} {len(fb(name))} ids")

Output on 2026-10-14:

Firebase: 30 stories in 14.2s (31 requests)
  #1 524 pts, 211 comments: Iosevka is an open-source, sans-serif and slab-serif monospace font
  #2 25 pts, 3 comments: Submarine cable resilience
  #3 134 pts, 39 comments: Pg_vectorsearch: An index that is faster than pgvector's IVFFlat and HNSW
Algolia front_page: 30 stories in 3.0s (1 request)
  same IDs as Firebase top 30: 28
topstories   500 ids
newstories   500 ids
beststories  200 ids
askstories   22 ids
showstories  177 ids
jobstories   31 ids

Request times vary a lot from run to run. In an earlier test the same thread pool fetched 200 Firebase items in 4.4 seconds. The shape is what matters: Firebase is one request per item, and Algolia is one request per page of up to 1,000 items.

The two front pages overlapped on 28 of 30 IDs in this run and on 29 of 30 in an earlier one. The front page changes from minute to minute, and the two requests weren't simultaneous. If you need the exact ranking, topstories is the source: it's ordered, and front_page isn't.

Freshness

On 2026-10-14 the newest item in Algolia's /search_by_date had the same ID as Firebase's maxitem, 27 seconds after it was posted. Points and comment counts for the five top stories matched exactly between the two APIs. On that day Algolia was effectively live. Firebase is still the source of truth: Algolia indexes what Firebase publishes, so if the two ever disagree, trust Firebase.

Rate behaviour

Firebase: the README says "There is currently no rate limit." That's not an invitation to hammer it. Use a small thread pool, as above, and cache items that no longer change (old stories and comments).
Algolia: the API page says "We are limiting the number of API requests from a single IP to 10,000 per hour." That's about 2.7 requests per second, sustained. Because one request can return 1,000 hits, you rarely need that many.
Neither publishes an error format for throttling. Back off and retry on 429 and 5xx.

Which one to use

Task	Use
Front page in rank order	Firebase `topstories`
New, Ask, Show or job lists as HN shows them	Firebase list endpoints
Search by keyword, author, domain or points	Algolia `/search`
Everything posted between two dates	Algolia `/search_by_date` with `created_at_i`
A whole comment thread fast	Algolia `/items/{id}`
A complete thread including removed comments	Firebase, walking `kids`
A user's karma and submissions	Firebase `/user/{id}` (`submitted` lists every item ID); Algolia `/users/{name}` returns only karma and about
Watching for changes	Firebase `/updates` or `maxitem`

Most real projects use both. Find IDs with Algolia, then read the authoritative item from Firebase when it matters.

Related guides for this API

HN Algolia API reference.
Get all comments for a Hacker News story, which compares all three ways of reading a thread.
Search Hacker News by date range or points.
The Hacker News Search API: free, no key.

Do it without code

The free Hacker News search tool runs Algolia searches live in your browser: keyword, type (story, comment, Show HN, Ask HN), relevance or date order, and a minimum score.

At scale

The Hacker News Scraper actor on Apify combines both APIs. Its list modes (top, new, best, ask, show and job) read the Firebase rankings, its search mode uses Algolia, and it can attach comment trees, author karma, and filters on score, comments, date and domain. It also parses the monthly "Who is hiring?" thread into job rows. It exports JSON, CSV or Excel, and it's free to start, then pay-as-you-go.

Disclosure: I build the datatooly tool and the Apify actor. Both APIs work fine without them.

Sources: Hacker News API on GitHub (official), HN Search API, and live responses from both APIs on 2026-10-14.

Get All Comments for a Hacker News Story with the API

Omar Eldeeb — Wed, 14 Oct 2026 17:36:05 +0000

To get every comment on a Hacker News story, request https://hn.algolia.com/api/v1/items/{story_id}. It returns the story with the full comment tree nested in children, in one call, with no key. It skips deleted and dead comments and every reply under them. For a complete set, use the search index (tags=comment,story_{id}) or walk the official Firebase API.

I tested all three methods on two threads on 2026-10-14: the 2007 Dropbox launch post (71 comments) and "OpenAI's board has fired Sam Altman" (2,530 comments). The counts don't agree, and the reason matters if you are building a dataset.

Three methods compared

Method	Requests	Big thread: comments returned	Time (big thread)	Gaps
Algolia `/items/{id}`	1	2,450	1.8 s	No deleted or dead comments, and none of their replies
Algolia search, `tags=comment,story_{id}`	1 per 1,000 comments, or more	2,530	21.8 s	Flat list (rebuild the tree from `parent_id`), no deleted or dead items
Firebase `/v0/item/{id}.json`	1 per comment	2,734 items, 204 of them deleted or dead	53.9 s with 16 threads	None; it's the source of truth

The Firebase story reported descendants: 2530, and 2,734 items minus 204 deleted or dead is 2,530. So descendants (and Algolia's num_comments) counts live comments.

Where the item tree loses comments. The tree was 80 short. I checked every one of the 80: each was a live reply whose parent comment was deleted or dead. The tree prunes the whole branch at the removed comment. The search index had all 80. Asking /items/38312257 for one of them directly worked too, so the data is there; it just isn't attached to the tree.

On small threads the difference is usually zero. The Dropbox thread has 71 live comments and the tree returned 71.

What the item tree looks like

GET https://hn.algolia.com/api/v1/items/8863 returns the story at the top, with the same fields on every node:

Field	Story	Comment
`id`, `type`	`8863`, `story`	`8865`, `comment`
`author`, `created_at`, `created_at_i`	yes	yes
`title`, `url`, `points`	yes	`null`
`text`	`null` for link posts	HTML
`parent_id`, `story_id`	`null`, `8863`	parent's ID, `8863`
`children`	top-level comments	replies, nested

Comment text is HTML: paragraphs are separated by <p>, links are <a href>, and quotes and apostrophes are entity-encoded ('). The script below converts it to plain text.

Python: all three methods

import csv
import html
import re
import time
from concurrent.futures import ThreadPoolExecutor

import requests

ALGOLIA = "https://hn.algolia.com/api/v1/items/{}"
FIREBASE = "https://hacker-news.firebaseio.com/v0/item/{}.json"
s = requests.Session()


def get_json(url, attempts=4):
    for i in range(attempts):
        try:
            r = s.get(url, timeout=60)
            if r.status_code == 200:
                return r.json()
            if r.status_code == 404:
                return None
        except requests.RequestException:
            pass
        time.sleep(2 ** i)
    raise RuntimeError(f"failed: {url}")


def to_text(fragment):
    """HN comment HTML -> plain text (<p> becomes a blank line)."""
    t = re.sub(r"<p>", "\n\n", fragment or "")
    t = re.sub(r"<[^>]+>", "", t)
    return html.unescape(t).strip()


def comments_algolia(story_id):
    """One request: the whole tree. Flattened depth-first, in thread order."""
    root = get_json(ALGOLIA.format(story_id))
    rows = []

    def walk(node, depth):
        for c in node.get("children", []):
            rows.append({"id": c["id"], "parent": c["parent_id"], "depth": depth,
                         "author": c["author"], "created_at": c["created_at"],
                         "text": to_text(c["text"])})
            walk(c, depth + 1)

    walk(root, 1)
    return root, rows


def comments_search(story_id, start=0, end=2**31):
    """Flat list from the search index (tags=comment,story_ID). Includes replies
    whose parent was deleted. Splits the time window while a slice has > 1,000 hits."""
    r = s.get("https://hn.algolia.com/api/v1/search_by_date", timeout=60, params={
        "tags": f"comment,story_{story_id}", "hitsPerPage": 1000,
        "numericFilters": f"created_at_i>={start},created_at_i<{end}"}).json()
    if r["nbHits"] <= 1000:
        return [{"id": int(h["objectID"]), "parent": h["parent_id"], "author": h["author"],
                 "created_at": h["created_at"], "text": to_text(h["comment_text"])}
                for h in r["hits"]]
    mid = (start + end) // 2
    return comments_search(story_id, start, mid) + comments_search(story_id, mid, end)


def comments_firebase(story_id, workers=16):
    """Official API: one request per comment, level by level. Keeps deleted
    and dead items so you can see what the Algolia tree leaves out."""
    story = get_json(FIREBASE.format(story_id))
    rows, level, depth = [], [(k, story_id) for k in story.get("kids", [])], 1
    with ThreadPoolExecutor(workers) as ex:
        while level:
            items = list(ex.map(lambda pair: get_json(FIREBASE.format(pair[0])), level))
            nxt = []
            for item in items:
                if not item:
                    continue
                rows.append({"id": item["id"], "parent": item.get("parent"), "depth": depth,
                             "author": item.get("by"), "time": item.get("time"),
                             "deleted": item.get("deleted", False), "dead": item.get("dead", False),
                             "text": to_text(item.get("text"))})
                nxt += [(k, item["id"]) for k in item.get("kids", [])]
            level, depth = nxt, depth + 1
    return story, rows


if __name__ == "__main__":
    story_id = 8863  # "My YC app: Dropbox - Throw away your USB drive"

    t0 = time.time()
    root, rows = comments_algolia(story_id)
    print(f"Algolia: {root['title']!r} -> {len(rows)} comments, "
          f"max depth {max(r['depth'] for r in rows)}, {time.time() - t0:.1f}s")
    print(rows[0]["author"], "|", rows[0]["text"][:70])

    with open(f"hn_{story_id}_comments.csv", "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=rows[0].keys())
        w.writeheader()
        w.writerows(rows)

    t0 = time.time()
    story, fb_rows = comments_firebase(story_id)
    gone = sum(1 for r in fb_rows if r["deleted"] or r["dead"])
    print(f"Firebase: descendants={story['descendants']} -> {len(fb_rows)} items "
          f"({gone} deleted or dead), {time.time() - t0:.1f}s")

    big = 38309611  # "OpenAI's board has fired Sam Altman"
    t0 = time.time()
    root, rows = comments_algolia(big)
    print(f"Algolia, big thread: {len(rows)} comments, max depth "
          f"{max(r['depth'] for r in rows)}, {time.time() - t0:.1f}s")
    t0 = time.time()
    flat = comments_search(big, start=root["created_at_i"], end=int(time.time()) + 60)
    print(f"Search index, big thread: {len(flat)} comments, {time.time() - t0:.1f}s")
    t0 = time.time()
    story, fb_rows = comments_firebase(big)
    gone = sum(1 for r in fb_rows if r["deleted"] or r["dead"])
    print(f"Firebase, big thread: descendants={story['descendants']} -> {len(fb_rows)} items "
          f"({gone} deleted or dead), {time.time() - t0:.1f}s")

Output on 2026-10-14:

Algolia: 'My YC app: Dropbox - Throw away your USB drive' -> 71 comments, max depth 5, 1.1s
dhouston | oh, and a mac port is coming :)
Firebase: descendants=71 -> 72 items (1 deleted or dead), 5.6s
Algolia, big thread: 2450 comments, max depth 14, 1.8s
Search index, big thread: 2530 comments, 21.8s
Firebase, big thread: descendants=2530 -> 2734 items (204 deleted or dead), 53.9s

And the first rows of hn_8863_comments.csv:

id,parent,depth,author,created_at,text
8865,8863,1,dhouston,2007-04-04T19:22:55.000Z,"oh, and a mac port is coming :)"
9007,8865,2,vlad,2007-04-05T01:48:11.000Z,"Drew, this is awesome!  All of the features you mentioned are exactly what people need."

Which method to use

Reading or summarising a thread: /items/{id}. One fast request, already in thread order. The missing branches hang off removed comments, which a reader on the site sees collapsed or flagged anyway.
A dataset that should match num_comments: the search index. It returned exactly 2,530 on the big thread. Rebuild the tree from parent_id if you need it, and expect replies whose parent isn't in your set.
Moderation research, or anything that needs removed items: Firebase. It's the only one that returns deleted and dead items, flagged with deleted: true or dead: true. It's also the slowest: one request per comment.

Pitfalls

The search split needs a sensible window. One query returns at most 1,000 hits, so the function halves the time window until each slice fits. Starting the window at the story's own created_at_i saves requests; a window from 1970 still worked but took longer.
Order isn't guaranteed across methods. The item tree is in display order. The search index is newest first. Firebase kids are in ranked display order, but the script reads them level by level. Sort by created_at or rebuild the tree if order matters.
Firebase answers a missing ID with null and HTTP 200. get_json returns None for it, and the walker skips it.
A thread keeps growing while it's on the front page. Comments posted between your requests won't match a count you read earlier. For a fixed snapshot, record the time you started and filter by created_at_i afterwards.
"Who is hiring?" threads are posted by the account whoishiring. Find this month's with /search_by_date?tags=story,author_whoishiring; on 2026-10-14 the newest was "Ask HN: Who is hiring? (October 2026)" (ID 49922569, 389 comments). Job posts are the top-level comments, so take depth == 1 from the tree.

Related guides for this API

HN Algolia API reference: every parameter, tag and limit.
Hacker News Firebase API vs Algolia.
Search Hacker News by date range or points, which uses the same window-splitting idea.
The Hacker News Search API: free, no key.

Do it without code

The free Hacker News search tool searches stories and comments live in your browser, with points, comment counts, author and date. Set the type to comments to see which threads discuss a topic, then use a story's ID with the code above.

At scale

The Hacker News Scraper actor on Apify attaches comment trees to stories (includeComments, with a maxCommentDepth cap), can flatten them into rows, and can add each author's karma. It walks the official Firebase API level by level, so replies under deleted comments aren't lost. Its hiring_threads mode turns the monthly "Who is hiring?" thread into job rows. It exports JSON, CSV or Excel, and it's free to start, then pay-as-you-go.

Disclosure: I build the datatooly tool and the Apify actor. The script above needs neither.

Sources: HN Search API (official page), Hacker News API (Firebase) on GitHub, and live responses from both APIs on 2026-10-14.

PERM Disclosure Data in Python: Find Green Card Sponsors by City

Omar Eldeeb — Tue, 29 Sep 2026 12:37:12 +0000

To find green card (PERM) sponsors by city, download the Department of Labor's free PERM disclosure file and filter it in pandas. Keep CASE_STATUS values starting with "Certified", match PRIMARY_WORKSITE_CITY and PRIMARY_WORKSITE_STATE, optionally narrow by PWD_SOC_CODE, then count cases per EMP_BUSINESS_NAME. The current file is about 156 MB of XLSX. There's no API key and no signup, and the whole analysis is about 40 lines of Python.

Sponsor sites like h1bgrader and visasponsorhub build their lists from these same public files. This guide shows how to query the files yourself: where the file lives now (the link moved in FY2026), which columns matter in the new PERM form, and the data-quality traps that skew a naive count. Every figure below comes from running the code on 2026-09-29.

The source: OFLC disclosure files

The DOL's Office of Foreign Labor Certification (OFLC) publishes case-level disclosure data for its programs on one page:

https://www.dol.gov/agencies/eta/foreign-labor/performance

A few points you need to know before you start:

It's a bulk file, not an API. Each program publishes an .xlsx per fiscal year. The current year's file is replaced each quarter with a cumulative year-to-date version.
The FY2026 files moved. Older files are linked under /sites/dolgov/files/ETA/oflc/pdfs/.... The FY2026 disclosure files are linked from the same page under https://www.dol.gov/media/, for example https://www.dol.gov/media/PERM_Disclosure_Data_FY2026_Q3.xlsx. A scraper that only matches the old path pattern will quietly miss the newest data.
It's big. PERM_Disclosure_Data_FY2026_Q3.xlsx is 156,267,808 bytes: one sheet, 137 columns, 112,550 cases. Its decision dates run from 2025-10-01 to 2026-06-30, which is fiscal 2026 through Q3.
PERM is the first step, not the green card. A certified PERM case is the DOL's labor certification. The employer still has to file with USCIS afterwards. A certification is solid evidence that an employer sponsors a role. It isn't proof that anyone received a green card.

The columns that matter

The file has 137 columns. For sponsor discovery you need about ten:

Column	Meaning
`CASE_NUMBER`	Unique case ID
`CASE_STATUS`	`Certified`, `Certified - Expired`, `Withdrawn`, `Denied`
`DECISION_DATE`	When the DOL decided the case
`EMP_BUSINESS_NAME`	Sponsoring employer
`PWD_SOC_CODE` / `PWD_SOC_TITLE`	Standard occupation code and title (e.g. `15-1252.00`, Software Developers)
`JOB_TITLE`	Employer's own job title
`JOB_OPP_WAGE_FROM` / `JOB_OPP_WAGE_TO`	Offered wage range
`JOB_OPP_WAGE_PER`	`Year`, `Hour`, `Month`, `Bi-Weekly`, `Week`
`PRIMARY_WORKSITE_CITY` / `PRIMARY_WORKSITE_STATE`	Where the job is

These are the names used by the current PERM form. I confirmed them in the FY2025 Q4 and FY2026 Q3 files. Older files, and the H-1B LCA files, use different column names, so check the Record Layout PDF published next to each file before you reuse code across years.

The file also contains names, phone numbers and emails of employer contacts and attorneys. You don't need any of that to rank employers, so the code below never loads those columns.

Runnable Python

This needs requests, pandas and openpyxl:

from pathlib import Path
import pandas as pd
import requests

URL = "https://www.dol.gov/media/PERM_Disclosure_Data_FY2026_Q3.xlsx"
XLSX = Path("PERM_Disclosure_Data_FY2026_Q3.xlsx")
CACHE = Path("perm_fy2026_q3.pkl")

# Employer, job and worksite columns only. The file also contains names, phone
# numbers and emails of contact people and attorneys; don't load what you don't need.
COLS = [
    "CASE_NUMBER", "CASE_STATUS", "DECISION_DATE",
    "EMP_BUSINESS_NAME", "PWD_SOC_CODE", "PWD_SOC_TITLE", "JOB_TITLE",
    "JOB_OPP_WAGE_FROM", "JOB_OPP_WAGE_PER",
    "PRIMARY_WORKSITE_CITY", "PRIMARY_WORKSITE_STATE",
]
ANNUAL = {"Year": 1, "Month": 12, "Bi-Weekly": 26, "Week": 52, "Hour": 2080}

def load():
    if CACHE.exists():
        return pd.read_pickle(CACHE)
    if not XLSX.exists():
        headers = {"User-Agent": "Mozilla/5.0 (compatible; perm-research/1.0)"}
        with requests.get(URL, headers=headers, stream=True, timeout=120) as r:
            r.raise_for_status()
            with open(XLSX, "wb") as f:
                for chunk in r.iter_content(1 << 20):
                    f.write(chunk)
    # Slow step (minutes): openpyxl parses the whole 100+ MB workbook once.
    df = pd.read_excel(XLSX, usecols=COLS, dtype={"PWD_SOC_CODE": str}, engine="openpyxl")
    df["CITY"] = df["PRIMARY_WORKSITE_CITY"].str.strip().str.upper()   # casing is inconsistent
    df["EMPLOYER"] = df["EMP_BUSINESS_NAME"].str.strip().str.replace(r"\s+", " ", regex=True)  # trailing spaces split one employer into two
    df["ANNUAL_WAGE"] = df["JOB_OPP_WAGE_FROM"] * df["JOB_OPP_WAGE_PER"].map(ANNUAL)
    df.to_pickle(CACHE)                                                # later runs load in seconds
    return df

df = load()
certified = df[df["CASE_STATUS"].isin(["Certified", "Certified - Expired"])]

def green_card_sponsors(city, state, soc_prefix="", top=10):
    sub = certified[(certified["CITY"] == city.upper())
                    & (certified["PRIMARY_WORKSITE_STATE"] == state)
                    & certified["PWD_SOC_CODE"].fillna("").str.startswith(soc_prefix)]
    return (sub.groupby("EMPLOYER")
               .agg(certified=("CASE_NUMBER", "count"),
                    median_annual_wage=("ANNUAL_WAGE", "median"),
                    top_occupation=("PWD_SOC_TITLE", lambda s: s.mode().iat[0] if s.notna().any() else None))
               .sort_values("certified", ascending=False)
               .head(top))

if __name__ == "__main__":
    print(f"{len(df):,} PERM cases; status breakdown:")
    print(df["CASE_STATUS"].value_counts().to_string(), "\n")
    # Computer & mathematical occupations (SOC 15-xxxx) in Austin, TX
    print(green_card_sponsors("Austin", "TX", soc_prefix="15-").to_string())

Output from the FY2026 Q3 file:

112,550 PERM cases; status breakdown:
Certified              87741
Certified - Expired    16287
Withdrawn               4643
Denied                  3879

                                certified  median_annual_wage       top_occupation
EMPLOYER
Oracle America, Inc.                  165           139464.00  Software Developers
Charles Schwab & Company, Inc.         62           155104.50  Software Developers
PayPal, Inc.                           23           148902.83  Software Developers
Deloitte Consulting LLP                21           109000.00  Software Developers
Advanced Micro Devices, Inc.           20           137200.50  Software Developers
...

The first run took a few minutes on my machine, almost all of it read_excel. Once the pickle cache exists, the rerun finishes in about a second. Change the city, state and SOC prefix to ask a new question: "29-" for healthcare practitioners, "13-2011" for accountants, or "" for all occupations.

Traps that skew the counts

Employer names are dirty

Charles Schwab & Company, Inc. shows up twice in the raw data, once with a trailing space, which splits its count into 47 and 15. Stripping and collapsing whitespace brings the number of distinct employer strings in this file down from 31,753 to 30,228. Legal-entity variants such as "Inc." versus "Inc" or subsidiaries remain separate. For serious work, add your own alias map.

City casing and blanks

Worksite cities come in mixed case (New York, EL SEGUNDO). Uppercase them before matching. 4,388 cases in this file have no PRIMARY_WORKSITE_CITY at all, so a city filter will never match them.

Wages come in five units

About 7.8% of cases state an hourly wage. If you take a median of JOB_OPP_WAGE_FROM without annualizing (hour × 2080, week × 52 and so on), those rows drag it down badly.

Excel damages some codes

In the raw workbook, one PWD_SOC_CODE cell is stored as a date (9033-11-01) and 54 are blank. Without dtype={"PWD_SOC_CODE": str}, pandas returns a mixed-type column, and saving it to Parquet fails with ArrowTypeError. Read codes as strings and fillna("") before calling .str.startswith.

Status is not a yes/no

Certified - Expired means the certification was granted but has since expired. It still shows the employer sponsored the role, which is why the script counts it. Withdrawn and Denied don't show that.

Downloads can be refused

The file downloaded fine for me with a plain client. Some environments report 403 from dol.gov for bare HTTP clients, so if you hit one, send a normal browser-style User-Agent. Cache the file locally. Re-downloading 156 MB every time you run the script is slow for you and wasteful for the DOL.

Do it without code

If you want to plan the query before downloading anything, the free visa sponsor finder is a query builder. You pick a mode, role and city, and it builds a ready-to-run input for the actor below. It also shows a fixed example of the output shape. It doesn't fetch live DOL data in your browser, because these files are far too large for that.

At scale

One file and one city is a notebook job. Repeating it across fiscal years and programs (PERM plus H-1B LCA), handling column changes between form versions, and noticing new quarterly files is a small pipeline. The Visa Sponsor Tracker actor on Apify reads the same OFLC disclosure files. It has sponsor-finder, company-check, salary-lookup and bulk-export modes, converts wages to annual figures, and caches the files between runs. Each filing row records the sourceFile it came from. Whichever tool you use, check that field to confirm which fiscal year and quarter a result reflects. The actor is free to start, then pay-as-you-go.

Disclosure: I build the datatooly builder and the Apify actor. The DOL source facts and the code above work without either.

FAQ

Where do I download PERM disclosure data?

From the OFLC Performance Data page at dol.gov/agencies/eta/foreign-labor/performance. The current file is https://www.dol.gov/media/PERM_Disclosure_Data_FY2026_Q3.xlsx. Earlier years are linked from the same page.

Is there a PERM API?

No. The DOL publishes bulk .xlsx files, not a query API. You download the file and filter it locally, or use a tool that does that for you.

How often is PERM data updated?

The OFLC posts disclosure data by fiscal quarter, and the current year's file is cumulative. The FY2026 Q3 file covers decisions from 2025-10-01 through 2026-06-30.

Does a certified PERM case mean the worker got a green card?

No. PERM labor certification is the DOL step. The employer then petitions USCIS, and the green card comes later. Treat certified cases as evidence of sponsorship, not as approvals of green cards.

How is this different from H-1B LCA data?

LCA files cover temporary H-1B, H-1B1 and E-3 filings. PERM covers permanent (green card) labor certifications. Both come from the same OFLC page, but they use different column names. For the H-1B side, see the H-1B salary database guide.

Why do I see the same company twice?

Employer names are free text in the source. Trailing spaces, punctuation and subsidiary names split one company into several strings. Normalize whitespace at the very least, and keep an alias map for the employers you care about.

Threads Keyword Search Without App Review: Monitor in Python

Omar Eldeeb — Tue, 29 Sep 2026 09:37:18 +0000

Without app review, Meta's Threads keyword_search endpoint only searches posts owned by the authenticated user. Public posts become searchable only after Meta approves your app for the threads_keyword_search permission. To monitor public keywords before (or instead of) that approval, read the public search page at threads.com/search?q=… and dedupe posts by their code between runs.

That is the whole trick. The rest of this guide covers what the official endpoint gives you once approved, how the public page ships its data, a monitoring script that only prints new posts, and where the public route stops.

Why your keyword search only returns your own posts

The official endpoint is GET /keyword_search on the Threads Graph API. Per Meta's documentation (checked on 29 September 2026):

It needs two permissions: threads_basic and threads_keyword_search.
Until your app is approved for threads_keyword_search, "the search will be performed only on posts owned by the authenticated user." That is why a fresh app returns your own posts and nothing else.
A user can send at most 2,200 queries in a rolling 24-hour window. Queries that return no results do not count.
Parameters: q (required), search_type (TOP or RECENT), search_mode (KEYWORD or TAG), media_type, since / until, limit (default 25, max 100), and author_username.

If you can get through app review, use the API. It is the sanctioned route, and it gives you date bounds and 100 results per page, which the public page does not. The rest of this guide is for the case where you can't, or not yet: a prototype, a one-off research pull, or a team without a Meta business app.

The public route: server-rendered search pages

Threads has three public URLs that matter for keyword monitoring:

URL	What it shows
`https://www.threads.com/search?q=<term>&serp_type=default`	Relevance-ranked results for a keyword
`https://www.threads.com/search?q=<term>&serp_type=recent`	Newest-first results for the same keyword
`https://www.threads.com/tag/<name>`	A topic tag's feed (Threads' version of a hashtag)

Meta serves these pages with the post data embedded as JSON inside <script type="application/json"> blocks when the request identifies as a link-preview crawler (facebookexternalhit/1.1, the user agent Facebook itself uses when unfurling links). A normal browser user agent gets a thin app shell instead, because the browser is expected to fetch the data with JavaScript afterwards.

The JSON is nested inside Meta's module envelope, and the exact path moves around between releases. So don't hard-code a path. Walk every block recursively and pick out anything that looks like a post: an object with a string code, a caption, a string pk, and either taken_at or like_count.

Two properties of these pages shape everything below:

There is no cursor. The page's page_info reports has_next_page: false. Each view renders a bounded sample, typically a few dozen posts, and you can't page deeper without logging in.
The two views differ. default (relevance) and recent (newest) overlap but aren't identical, so fetching both and merging on code widens what you see per term.

Runnable Python: print only new posts per keyword

This script fetches both views for each term, merges them, and compares the result with a local state file. It keeps each post's code plus a "high-water mark" timestamp, and prints only posts it hasn't returned before. Run it on a cron and you have a keyword monitor.

import json, re, sys, time, pathlib, requests
from urllib.parse import quote

UA = "facebookexternalhit/1.1"   # Meta server-renders embedded JSON for link-preview crawlers
SCRIPT_RE = re.compile(r'<script[^>]*type="application/json"[^>]*>(.*?)</script>', re.S)
STATE = pathlib.Path("threads_seen.json")

def walk(node, posts, depth=0):
    """Collect post nodes: code + caption + pk + (taken_at or like_count)."""
    if depth > 30 or node is None:
        return
    if isinstance(node, list):
        for v in node:
            walk(v, posts, depth + 1)
    elif isinstance(node, dict):
        if (isinstance(node.get("code"), str) and "caption" in node
                and isinstance(node.get("pk"), str)
                and ("taken_at" in node or "like_count" in node)):
            old = posts.get(node["code"])
            if old is None or len(json.dumps(node)) > len(json.dumps(old)):
                posts[node["code"]] = node          # keep the richest copy
        for v in node.values():
            walk(v, posts, depth + 1)

def fetch_view(term, view, attempts=3):
    url = f"https://www.threads.com/search?q={quote(term)}&serp_type={view}"
    for i in range(attempts):
        try:
            r = requests.get(url, timeout=25, headers={"User-Agent": UA, "Accept-Language": "en-US,en;q=0.9"})
            r.raise_for_status()
            posts = {}
            for block in SCRIPT_RE.findall(r.text):
                try:
                    walk(json.loads(block), posts)
                except ValueError:
                    continue
            if posts:
                return list(posts.values())
            # 200 with zero posts: a login gate, a data-less shell, or a real "no results".
        except requests.RequestException:
            pass
        time.sleep(2 * (i + 1))
    return []

def to_row(p, term):
    user, info = p.get("user") or {}, p.get("text_post_app_info") or {}
    return {
        "matchedQuery": term,
        "code": p["code"],
        "url": f"https://www.threads.com/@{user.get('username')}/post/{p['code']}",
        "username": user.get("username"),
        "text": (p.get("caption") or {}).get("text"),
        "takenAt": p.get("taken_at"),                  # unix seconds
        "likes": p.get("like_count"),
        "replies": info.get("direct_reply_count"),
        "reposts": info.get("repost_count"),
        "quotes": info.get("quote_count"),
    }

def monitor(terms):
    state = json.loads(STATE.read_text()) if STATE.exists() else {}
    new_rows = []
    for term in terms:
        prior = state.get(term, {})
        seen, high_water = set(prior.get("codes", [])), prior.get("lastTakenAt", 0)
        union = {}
        for view in ("recent", "default"):              # recency view first, then relevance
            for p in fetch_view(term, view):
                union.setdefault(p["code"], p)
        fresh = [p for p in union.values()
                 if p["code"] not in seen
                 and (p.get("taken_at") is None or p["taken_at"] > high_water)]
        new_rows += [to_row(p, term) for p in fresh]
        stamps = [p.get("taken_at") or 0 for p in union.values()] + [high_water]
        codes = list(dict.fromkeys([*union, *prior.get("codes", [])]))[:2000]   # newest first, capped
        state[term] = {"codes": codes, "lastTakenAt": max(stamps)}
        print(f"{term!r}: {len(union)} gathered, {len(fresh)} new", file=sys.stderr)
    STATE.write_text(json.dumps(state))
    return new_rows

if __name__ == "__main__":
    for row in monitor(sys.argv[1:] or ["web scraping"]):
        print(json.dumps(row, ensure_ascii=False))

pip install requests
python threads_monitor.py "web scraping" "n8n"

The first run for a term prints everything currently visible. That's your baseline. After that, a post has to clear two gates to print: its code has never been seen, and it's newer than the last timestamp recorded for that term. The code check stops repeats. The timestamp check stops a post from coming back after its code ages out of the capped list.

Field reference

These are the raw keys on each post node the walker collects, and what the script maps them to:

Raw key	Script field	Notes
`code`	`code`	Short post ID, used in the URL. The dedupe key.
`pk`	—	Numeric post ID as a string
`user.username`	`username`	Author handle
`caption.text`	`text`	Post body. `caption` can be present with empty text.
`taken_at`	`takenAt`	Unix seconds
`like_count`	`likes`
`text_post_app_info.direct_reply_count`	`replies`
`text_post_app_info.repost_count`	`reposts`
`text_post_app_info.quote_count`	`quotes`
`image_versions2`, `carousel_media`, `video_versions`	—	Media candidates. Pick the largest `width × height`.

The post URL is built as https://www.threads.com/@<username>/post/<code>. Use threads.com: threads.net URLs redirect, and a redirect is one more hop to go wrong.

Pitfalls

A 200 with zero posts is ambiguous. Meta sometimes answers a crawler request with a full-size page that has the data blocks stripped, or with a "Threads · Log in" gate. This varies by IP and by moment. It's why the script retries and logs "0 gathered" instead of treating the term as dead. From the connection I wrote this on, every request came back as the data-less shell, so the script above ran cleanly but returned nothing. That was the IP, not the method: the same approach run on Apify's cloud through its proxies on the same day returned 10 posts for "web scraping". Output from a clean IP is what the field table documents. If you're on a hot IP, try from another egress before concluding a term has no posts.
Coverage is a sample, not an archive. With no cursor, one term yields a few dozen posts at most, even when thousands exist. Widen coverage by monitoring related terms and by running more often, not by trying to page backwards.
Busy terms rotate. For a high-volume keyword, consecutive fetches can surface different slices. Early runs will look "new-heavy" until the seen-set fills.
Tags are separate. Topic tags live at /tag/<name>. Searching q=%23name gives an overlapping but different sample, so fetch both if a tag matters.
Date filters only narrow. Filtering on taken_at trims what the page showed you. It can't reach older posts the page never exposed.
Terms and privacy. Meta's terms restrict automated collection, and post authors are people. Collect public posts only, keep request rates modest, and have a lawful basis before you store or contact anyone.

Do it without code

The free Threads keyword monitor query builder lets you pick a mode (search, hashtag, or monitor), enter your terms, and set sort and limits. It generates a ready-to-run input and shows a fixed example of the output shape. It's a query builder: Threads isn't open to cross-site browser requests, so it doesn't fetch live posts in your browser.

At scale

Threads Search & Monitor on Apify runs the same public-page approach with the parts that are tedious to maintain yourself. It fetches through Apify datacenter proxies and automatically retries gated pages through residential. It merges the relevance and recency views (and the tag view for hashtags). Its monitor mode keeps the seen-codes and high-water state in a named key-value store in your own Apify account, so a scheduled run returns only new posts. Reply trees and author bio contacts are both opt-in. It's free to start, then pay-as-you-go, charged per post returned. In monitor mode, only new posts are charged.

Disclosure: I built the query builder and the actor. The script above works on its own.

FAQ

Does the Threads API support keyword search?

Yes. GET /keyword_search accepts q, search_type (TOP or RECENT), search_mode (KEYWORD or TAG), since/until and limit up to 100. It needs the threads_keyword_search permission, and a user can make at most 2,200 queries per rolling 24 hours.

Why does keyword_search only return my own posts?

Your app hasn't been approved for threads_keyword_search yet. Until it is, Meta scopes the search to posts owned by the authenticated user. Public posts become searchable after approval through App Review.

Can I search Threads without logging in?

For public posts, yes. threads.com/search?q=<term> and threads.com/tag/<name> render public results for anonymous visitors. Private accounts and anything behind the login wall stay out of reach, and there's no cursor for deeper pages.

How many posts can I get per keyword without the API?

A bounded sample per view, typically a few dozen posts. Merging the default and recent views widens it somewhat. For broader coverage, monitor several related terms on a schedule instead of trying to backfill one term's history.

How do I get only new Threads posts for a keyword?

Store each post's code plus the newest taken_at you've seen for that term. On every run, emit only posts whose code is new and whose timestamp is newer than the stored mark, then update both. The script above does exactly this in a local JSON file.

Is it threads.net or threads.com?

threads.com. Old threads.net links still redirect, but build URLs on threads.com directly.

DEV Community: Omar Eldeeb

How to Check if ChatGPT Mentions Your Brand (Free)

Why one check isn't enough

Step 1: write buyer prompts, not brand prompts

Step 2: use a clean session

Step 3: run each prompt several times

Step 4: log every answer the same way

Step 5: score it

How to read the result

Related guides

Do it without code

At scale

FPL Live Gameweek Points from the API: Picks Math

The two endpoints

The simple version: after a gameweek

The full version: projecting the rules yourself

The rules the script applies

Using it during a live gameweek

Pitfalls

Related guides for this API

Do it without code

At scale

FPL API Endpoints: Complete Reference for 2026/27

The endpoints at a glance

Check them yourself

Key fields, endpoint by endpoint

bootstrap-static/

fixtures/

element-summary/{player_id}/

event/{gw}/live/

entry/{manager_id}/ and its sub-paths

leagues-classic/{league_id}/standings/

Small endpoints

Errors

Rules of the road

Related guides for this API

Do it without code

At scale

ClinicalTrials.gov API v2 Query Parameters: Full Reference

Query parameters: what to search

Filter parameters: what to keep

filter.advanced and the AREA[] syntax

aggFilters

Output and paging parameters

curl: one request with several parameters

Python: counting and paging

Mistakes the API rejects (and ones it doesn't)

Related guides for this API

Do it without code

At scale

ClinicalTrials.gov API: Look Up a Study by NCT Number

The NCT number format

The endpoint

What the JSON contains

curl: one study, a few fields

Python: a lookup that handles every case

Details that trip people up

Related guides for this API

Do it without code

At scale

SEC EDGAR Rate Limit and User-Agent: Fair Access Rules

The rules, in the SEC's words

What the server did on 2026-10-14

The 403 page

A client that follows the rules

Need more than 10 per second? Use the bulk files

Can a browser call the SEC APIs?

Related guides for this API

Do it without code

At scale

SEC Company Facts API: companyfacts, concept & frames

The three endpoints

Frame periods and units

The JSON

Python: all three, plus a CSV for Excel

The traps

1. fy is the filing's fiscal year, not the fact's

2. A frame value can come from the wrong filing

3. Duplicates are normal

4. The tag you guess may not exist

`bootstrap-static/`

`fixtures/`

`element-summary/{player_id}/`

`event/{gw}/live/`

`entry/{manager_id}/` and its sub-paths

`leagues-classic/{league_id}/standings/`

1. `fy` is the filing's fiscal year, not the fact's

2. A `frame` value can come from the wrong filing

Query syntax in `q`