Hobbs · Property Data Report

Cook County Property & Tax Data — Extraction Guide

How to pull Cook County, Illinois parcel, assessment, tax-rate, and equalization data directly from the public Socrata API — without scraping, without reCAPTCHA, without auth.

1. TL;DR

Cook County publishes its property, assessment, and tax-rate data on a Socrata-powered Open Data portal at datacatalog.cookcountyil.gov. Everything you need lives there as JSON/CSV with a documented query language. No authentication is required to read. A free app token raises the throttle ceiling but is not strictly required.

• For property characteristics, assessments, sales, appeals, exemptions → query the Cook County Assessor datasets.
• For tax-code rates, agency rates, the per-property tax composition → query the Cook County Clerk datasets.
• The State Equalization Factor (a.k.a. the "multiplier") is a single annual number set by the Illinois Department of Revenue. It is not its own dataset, but it appears as a column in some derived tables and is the easiest piece to maintain as a small static lookup.
• The Treasurer's own site (cookcountytreasurer.com, cookcountypropertyinfo.com) is a per-PIN lookup portal. Do not bulk-scrape it. Use it only for live billing/payment status that's not in open data.

2. Why not scrape the public sites

The instinct is to point Playwright at cookcountyassessoril.gov/address-search and call it a day. Don't. Here's what you'd actually be fighting:

• Drupal 11 + Google reCAPTCHA on the Assessor's form. Any automated submission requires solving (or paying to solve) a reCAPTCHA challenge.
• CloudFront / Akamai in front of both the Assessor and the Treasurer. Datacenter IPs get rate-limited or 403'd; you'd need residential proxies.
• No bulk export from the UI. One PIN per request, slow.
• Brittle DOM. Drupal theme changes break selectors. The same data has been stable on the API for 5+ years.

3. The actual sources of truth

4. Socrata API 101

Every Cook County dataset has a stable 4x4 resource ID (e.g. uzyt-m557) and is queryable at:

https://datacatalog.cookcountyil.gov/resource/{resource-id}.json
https://datacatalog.cookcountyil.gov/resource/{resource-id}.csv

You filter using SoQL (Socrata Query Language) via query-string parameters prefixed with $:

Optional: get a free App Token

Register at datacatalog.cookcountyil.gov/profile/edit/developer_settings and pass X-App-Token as a header. Without a token you share an anonymous throttling pool; with one you get your own much-higher ceiling. Either way, reads are free.

5. Assessor datasets (property & assessment)

Example — address to PIN

GET https://datacatalog.cookcountyil.gov/resource/3723-97qp.json
    ?$where=upper(prop_address_full) like upper('%123 N MAIN%')
    &$limit=10

Example — assessment history for a PIN

GET https://datacatalog.cookcountyil.gov/resource/uzyt-m557.json
    ?pin=32213210090000
    &$order=year DESC

6. Treasurer / Clerk datasets (rates & equalizer)

The Treasurer collects the bill; the County Clerk publishes the tax rates and agency composition. All of it is on the same Open Data portal.

Example — full tax composition for a tax code in a given year

GET https://datacatalog.cookcountyil.gov/resource/9sqg-vznj.json
    ?tax_year=2023
    &tax_code=10001

Returns one row per taxing body (county, schools, parks, library, etc.) plus the composite tax_code_rate. Sum the agency_rate values across the rows and you'll match the composite — that's the breakdown that shows up on a Cook County bill.

7. The equalization factor, explained

It is exactly one number per tax year, applied county-wide. Recent values hover around 3.0.

The formula every Cook County bill follows:

EAV = AssessedValue × StateEqualizationFactor
NetEAV = EAV − Exemptions
Bill = NetEAV × (TaxCodeRate / 100)

Where to get the factor:

• Authoritative: the IDOR annual order (PDF, one per year).
• Quick news source: the Cook County Clerk announces it each year with a press release.
• Derived columns: the archived a536-gjbq dataset includes equalization_factor per tax code per year (2013-ish through ~2021).

For programmatic use, the cleanest approach is a tiny static lookup table you maintain once a year:

# equalization_factors.json — update once per year
{
  "2019": 2.9160,
  "2020": 3.2234,
  "2021": 3.0027,
  "2022": 2.9237,
  "2023": 3.0163,
  "2024": 3.0103
  // Values shown are illustrative. Confirm against the IDOR order for production use.
}

8. Joining it together — address to estimated bill

Putting the joins in order, end to end:

# 1. Resolve address to PIN
3723-97qp  : address (free text)         → pin

# 2. Pull the parcel's tax code & class
nj4t-kc8j  : pin + year                  → tax_code, class, township

# 3. Pull the assessed value (latest stage available)
uzyt-m557  : pin + year                  → certified_tot (or board_tot)

# 4. Pull the tax code rate & agency breakdown
9sqg-vznj  : tax_code + year             → tax_code_rate, [agency, agency_rate]

# 5. Apply the state equalization factor (static lookup)
equalization_factors[year]               → state_eq_factor

# 6. (Optional) Subtract any exemptions
vgzx-68gb / exemption tables             → exemption_total

# 7. Compute
EAV     = certified_tot * state_eq_factor
NetEAV  = EAV - exemption_total
Bill    = NetEAV * (tax_code_rate / 100)

That's the entire bill. The Treasurer's website does the same math; you're just doing it from raw inputs.

9. Working Python example

Drop this in a file and run. No dependencies beyond requests.

import requests, urllib.parse

BASE = "https://datacatalog.cookcountyil.gov/resource"
HEADERS = {"X-App-Token": ""}  # optional, leave blank or add your token

def soda(resource, **params):
    url = f"{BASE}/{resource}.json"
    return requests.get(url, params=params, headers=HEADERS, timeout=15).json()

def find_pin_by_address(query):
    where = f"upper(prop_address_full) like upper('%{query}%')"
    return soda("3723-97qp", **{"$where": where, "$limit": 10})

def parcel_universe(pin, year=None):
    params = {"pin": pin}
    if year: params["year"] = year
    return soda("nj4t-kc8j", **params)

def assessed_values(pin):
    return soda("uzyt-m557", pin=pin, **{"$order": "year DESC"})

def tax_rate_composition(tax_code, year):
    return soda("9sqg-vznj", tax_code=tax_code, tax_year=str(year))

def estimate_bill(pin, year):
    parcel = parcel_universe(pin, year)[0]
    av     = float(assessed_values(pin)[0]["certified_tot"])
    rate   = float(tax_rate_composition(parcel["tax_code"], year)[0]["tax_code_rate"])
    eq     = EQUALIZATION_FACTORS[str(year)]  # static lookup
    eav    = av * eq
    bill   = eav * (rate / 100)
    return {"pin": pin, "year": year, "av": av, "eq": eq,
            "eav": eav, "rate_pct": rate, "est_bill": round(bill, 2)}

EQUALIZATION_FACTORS = {"2023": 3.0163, "2024": 3.0103}  # maintain yearly

if __name__ == "__main__":
    print(estimate_bill("32213210090000", 2023))

10. Working JavaScript example

Browser or Node — works either way. Useful for a thin client-side property-lookup form.

const BASE = "https://datacatalog.cookcountyil.gov/resource";

async function soda(resource, params = {}) {
  const qs = new URLSearchParams(params).toString();
  const r = await fetch(`${BASE}/${resource}.json?${qs}`);
  return r.json();
}

async function findPinByAddress(q) {
  return soda("3723-97qp", {
    "$where": `upper(prop_address_full) like upper('%${q}%')`,
    "$limit": 10
  });
}

async function taxComposition(taxCode, year) {
  return soda("9sqg-vznj", { tax_code: taxCode, tax_year: String(year) });
}

findPinByAddress("123 N MAIN").then(console.log);

11. Rate limits, freshness, & gotchas

• Throttling. Anonymous reads share a global pool; expect HTTP 429 if you burst hard. Register an App Token (free) for your own bucket. There is no documented hard cap for normal use.
• Page size cap. $limit max is 50,000 rows per request. Use $offset to walk a large set.
• Freshness lag. The portal lags the underlying systems by ~3-6 months for finalized tax-year data. Don't use it for live payment status (use the Treasurer's per-PIN portal for that).
• Tax year ≠ calendar year. Cook County tax year 2023 is paid in calendar 2024. Be precise about which "year" you mean.
• Assessment stages. Each property has three values per year: mailed, certified (after assessor finalizes), and board (after Board of Review). For tax-bill math use certified_tot or board_tot, not mailed_tot.
• Class codes. The class field is a 3-digit code (202 = single-family, 299 = condo, etc.). Look up the full classification table when you need to filter by property type.
• 14-digit PINs. Cook County PINs are 14 digits, no dashes. The same property is sometimes referenced by 10-digit or 8-digit PIN — those are different aggregations.

12. When you must scrape (fallback)

One legitimate scraping scenario remains: live billing/payment status. This is not published on open data because it changes daily. If you need to know whether a specific PIN is paid or delinquent right now:

https://www.cookcountypropertyinfo.com/pin/<14-digit-pin>

The detail page renders server-side and the relevant fields (Total Amount Billed, Amount Paid, Last Payment Date, Status) are stable selectors. There is no reCAPTCHA on the GET path — only on POST forms. Polite scraping rules apply:

• 1–2 requests per second, max
• Identifying User-Agent (e.g. Kaizen-CCAO-Bot/1.0 (contact@kaizenailab.com))
• Cache aggressively — payment status doesn't change minute to minute
• Respect any 429s with exponential backoff

If you ever need to programmatically submit the Assessor's address-search form (you probably don't — the API does this better), you'd need to handle reCAPTCHA via 2Captcha or similar. Cost is ~$2 per 1,000 solves. Not worth it; use the API.

13. Quick-reference endpoint table