# NY Court Decisions Scraper - Official Reports & Slip Opinions (`parseforge/ny-court-decisions-scraper`) Actor

Reads New York State court decisions from the Law Reporting Bureau: Court of Appeals, all four Appellate Divisions, both Appellate Terms, the Supreme Court Commercial Division and the trial courts, with full opinion text, judge, counsel and index numbers, back to 2003.

- **URL**: https://apify.com/parseforge/ny-court-decisions-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.45 / 1,000 court decisions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### NY Court Decisions Scraper - Official Reports & Slip Opinions

**Scrape New York State court decisions straight from the Law Reporting Bureau, the official publisher, across all nine court families and back to 2003.** Each row carries the case title, court, county, decision date, judge, slip opinion number, docket and index numbers, and on request the full text of the opinion, the parties, counsel of record and the Bureau's own subject classification. No login, no API key. Export to CSV, JSON, Excel or XML.

New York publishes its decisions as static monthly index pages, one per court per month, with the opinions behind them. There is no search API on the public site. This Actor walks those indexes, reads the opinions, and hands back one flat row per decision, with a keyword filter that can run against the full opinion text so you can build a subject feed the site itself does not offer.

| Who uses it | What they scrape New York decisions for |
|---|---|
| Litigation finance and specialty lenders | Merchant cash advance, factoring and confession of judgment rulings as they land |
| Law firms and legal research teams | Every decision by a named judge, or on a named subject, across the Commercial Division |
| Insurers and claims analysts | Trial level rulings by county on coverage, premises and no fault disputes |
| Legal tech and AI teams | A clean, licensed, official corpus of state court opinions with full text |
| Journalists and policy researchers | What the trial courts of a county actually decided, month by month |

### What it does

This Actor reads the New York State Law Reporting Bureau's slip opinion service on www.nycourts.gov and returns each decision as a flat row. Every decision carries:

- ⚖️ **Case identity:** case title, slip opinion number, decision date, the month it was posted and the batch caption it appeared under.
- 🏛️ **Court:** the deciding court and county as printed, plus the court family it belongs to and its key.
- 👤 **Judge and numbers:** the judge or panel, and the docket number where the index table publishes one.
- 🔗 **Links:** the decision page and the monthly index it was listed on.
- 📄 **Optional blocks:** full opinion text, parties split into plaintiff and defendant, counsel of record, the Bureau's digest classification, every index and indictment number printed on the decision, the footnotes, and the publication note that says whether the opinion is final or still subject to revision.
- 🗓️ **A second output:** the directory of every archived month the Bureau publishes for the courts you picked, so you can see what exists before you pay to read it. Pick it with `outputs`.

Results export to CSV, JSON, Excel or XML, or stream from the API.

### The nine court families

| Court | Archive reaches back to |
|---|---|
| Court of Appeals | 2003 |
| Appellate Division, First Department | 2003 |
| Appellate Division, Second Department | 2003 |
| Appellate Division, Third Department | 2003 |
| Appellate Division, Fourth Department | 2003 |
| Appellate Term, First Department | 2003 |
| Appellate Term, Second Department | 2003 |
| Supreme Court, Commercial Division | 2013 |
| Other Courts (trial level) | 2003 |

That is 274 archived monthly indexes for most families and 157 for the Commercial Division, plus the month in progress. `monthsBack` decides how far back a run walks.

### What you can do with New York decision data

**🔎 Build a subject feed the courts do not publish.**

Set `keywords` to `["merchant cash advance"]` and `keywordScope` to `fullText`, point it at the Commercial Division and Other Courts, and you get every trial level ruling that mentions the subject, with the full opinion attached. The Bureau publishes no such feed and its own search sits on a host that forbids crawling.

**👤 Follow a judge.**

Filter by `judges` and get every decision that judge issued, in order, with the text.

**📍 Read one county.**

Filter by `counties` with `"New York County"` or `"Kings"` and get the trial court output of that county alone.

**📚 Build a training or research corpus.**

Set `monthsBack` to 274 with `includeFullText`, and the run walks the whole published archive of a court family, one flat row per opinion.

**🗓️ Scope the job first.**

Run with `"outputs": ["months"]` to get the directory of available months, then decide what to read.

### Why choose this scraper

| | What you get |
|---|---|
| **The official source** | The Law Reporting Bureau is the publisher of record under Judiciary Law § 431. This reads it directly, not a third party mirror with its own gaps and its own terms. |
| **All nine families, one shape** | The nine index families do not share a column layout, and the opinion pages come in two different templates. The parser is header driven and covers both, so a run that reaches back across the 2015 template change does not change shape halfway through. |
| **Full text keyword filtering** | The one thing the public site cannot do. Matching against the opinion body is what turns a court calendar into a subject feed. |
| **Optional blocks, billed only when they return** | Full text, parties, counsel, digest classification, case numbers, footnotes and the publication note are each a checkbox. Untouched blocks are neither fetched nor billed. |
| **No proxy, no browser** | Measured from the Apify container: the site serves this Actor without either. That cost saving is in the price. |
| **The crawlable surface only** | The Bureau's own case search lives on `iapps.courts.state.ny.us`, whose robots file is `Disallow: /` for every agent. This Actor never touches that host. It reads `www.nycourts.gov`, which permits crawling, and nothing else. |

### How it compares

There is no other New York Official Reports scraper on Apify. The closest actors are general case law tools that cover federal or aggregator sources.

| Feature | ParseForge NY Court Decisions | pink\_comic/courtlistener-legal-opinions | johnvc/google-scholar-case-law | moving\_beacon-owner1/findlaw-case-law-scraper |
|---|---|---|---|---|
| New York state trial courts | Yes, Commercial Division and Other Courts | Appellate only | Appellate only | Appellate only |
| Official publisher as the source | Yes | No, aggregator | No, aggregator | No, aggregator |
| Full text keyword filter | Yes | No | Search only | No |
| Judge, county and date filters | Yes | Partial | No | No |
| Digest classification and counsel | Yes | No | No | No |
| Archived month directory | Yes | No | No | No |
| Price per row | $0.005 | $0.002 | Per search | $0.00999 |

### What a New York decision looks like

```json
{
  "rowType": "decision",
  "court": "Supreme Court, New York County",
  "courtFamily": "Supreme Court, Commercial Division",
  "courtKey": "commercial-division",
  "caseTitle": "A & L 444 LLC v Ankura Trust Co., LLC",
  "slipOpinionNumber": "2026 NY Slip Op 51347(U)",
  "decisionDate": "August 20, 2026",
  "judge": "Robert R. Reed, J.",
  "docketNumber": "Not Disclosed",
  "postedLabel": "Cases Posted August 31st",
  "monthLabel": "Current month",
  "decisionUrl": "https://www.nycourts.gov/reporter/current/3dseries/2026/2026_51347.shtml",
  "indexUrl": "https://www.nycourts.gov/reporter/current/index/com_div_idxtable.shtml",
  "wordCount": 1266,
  "parties": "A & L 444 LLC, 444 PARK AVENUE SOUTH ASSOCIATES LLC, DAVID MOIN MOINIAN, Plaintiff, v Ankura Trust Company, LLC, FEOH CAPITAL, LLC, ROYAL ABSTRACT OF NEW YORK LLC, 444 PARK AVE SOUTH OWNER LLC, Defendant.",
  "plaintiff": "A & L 444 LLC, 444 PARK AVENUE SOUTH ASSOCIATES LLC, DAVID MOIN MOINIAN, Plaintiff,",
  "defendant": "Ankura Trust Company, LLC, FEOH CAPITAL, LLC, ROYAL ABSTRACT OF NEW YORK LLC, 444 PARK AVE SOUTH OWNER LLC, Defendant.",
  "digestClassification": "Attorney and Client—Withdrawal from Representation—Failure to Pay Fees-Application for Stay",
  "caseNumbers": ["Index No. 653212/2023"],
  "scrapedAt": "2026-09-02T19:59:40.348Z"
}
```

A field the source does not publish for a given decision comes back as `Not Disclosed`, never as `null` and never missing. `docketNumber` above is empty because the Commercial Division index table has no Docket column; the Court of Appeals and Appellate Division tables do.

### Configure the run

| Input | What it does |
|---|---|
| `courts` | Which of the nine index families to read. Default: Commercial Division. |
| `monthsBack` | How many archived months to walk after the current one, newest first. 0 is the month in progress only; 274 is the whole archive. |
| `maxItems` | Stop after this many rows. |
| `keywords` | Keep only decisions containing these. |
| `keywordScope` | `title` matches the case name and costs nothing extra. `fullText` opens every decision in range to test it. |
| `matchAllKeywords` | Off keeps any match, on requires all of them. |
| `counties` | Substring match on the court line, for example `New York County`, `Kings`, `Westchester`. |
| `judges` | Substring match on the judge line. |
| `decidedAfter`, `decidedBefore` | ISO dates. |
| `startUrls` | Specific decision pages or monthly index pages to read instead of walking the courts. |
| `outputs` | `decisions`, `months`, or both. |
| `includeFullText`, `includeParties`, `includeCounsel`, `includeDigest`, `includeCaseNumbers`, `includeFootnotes`, `includePublicationNote` | The optional blocks. Each one opens the decision page. |
| `proxyMode`, `countryCode` | Off by default. The site geo-filters, so a run from outside the United States needs `datacenter`. |

### Pricing

Pay per event. You are charged for what a run actually delivers and actually reads.

| Event | What it is |
|---|---|
| Decision | One decision row. This is the price you compare. |
| Decision page opened | One opinion page read. Charged on the read, not on the row, because a full text keyword scan opens every decision in range to test it and keeps only the matches. A run that keeps five rows out of four hundred pages is billed for four hundred reads and five rows. |
| Monthly index read | One monthly index page that produced at least one row you kept. |
| Archive directory read | One court's archive page, read once per run when `monthsBack` is above 0. |
| Month entry | One row of the archived month directory output. |
| Full text, Parties, Counsel, Digest classification, Index and docket numbers, Footnotes, Publication note | One per optional block, charged only when that block returned something. |

At $0.005 a decision the base row is inside the band of the general case law actors on the Store, which run from $0.002 to $0.00999, and none of them cover the New York trial courts.

**The one thing to watch:** `keywordScope: "fullText"` is powerful and it is not free. It reads every decision in the range you set to find out whether it matches. Narrow the range with `courts`, `monthsBack`, `counties` and the date filters before you widen the keywords, and use `maxTotalChargeUsd` on the run to put a hard ceiling on it.

### Free users

Apify free plan runs are capped at 10 rows so the plan limit is never the surprise. Paid plans run to `maxItems`.

### Run it

```json
{
  "courts": ["commercial-division", "other-courts"],
  "monthsBack": 6,
  "keywords": ["merchant cash advance"],
  "keywordScope": "fullText",
  "includeFullText": true,
  "includeParties": true,
  "maxItems": 50
}
```

### Use with AI agents (MCP)

The Actor is exposed over Apify's MCP server, so an agent can call it as a tool. Point the agent at `https://mcp.apify.com` with this Actor enabled and it can ask for, say, every Commercial Division decision mentioning a lender in the last six months and get structured rows back.

### Troubleshooting

**Zero rows and a 403 in the log.** The site geo-filters and reads the TLS handshake, not the headers. On the Apify platform it serves this Actor directly. Running the code outside the United States needs `proxyMode: "datacenter"`.

**A month came back empty.** The archive pages list months the Bureau never posted, for example a court's summer recess. The run logs it and moves on.

**The full text scan is slow.** It is one page read per decision in range, paced so the site is not hammered. Narrow `courts` and `monthsBack`, or filter by `counties` and dates first, which happens off the index table and costs no page reads.

**`docketNumber` is empty.** Only the Court of Appeals and the four Appellate Divisions publish a Docket column in their index tables. Tick `includeCaseNumbers` to get every number printed on the decision itself.

### FAQ

**Where does the data come from?** `www.nycourts.gov/reporter`, the New York State Law Reporting Bureau, which publishes these decisions under Judiciary Law § 431.

**Does it touch the case search?** No. NYSCEF and WebCivil live on `iapps.courts.state.ny.us`, whose robots file forbids all crawling. This Actor reads only `www.nycourts.gov`, which permits it.

**How far back does it go?** 2003 for eight of the nine families, 2013 for the Commercial Division.

**Are the opinions final?** Tick `includePublicationNote`. Slip opinions marked uncorrected are subject to revision before they appear in the printed Official Reports.

**Can I get one specific decision?** Yes, put its URL in `startUrls`.

### Related actors

- [Justia Case Law Scraper](https://apify.com/parseforge/justia-case-law-scraper?fpr=vmoqkp)
- [GAO Bid Protest Docket Scraper](https://apify.com/parseforge/gao-bid-protest-docket-scraper?fpr=vmoqkp)
- [FINRA Arbitration Awards Scraper](https://apify.com/parseforge/finra-arbitration-awards-scraper?fpr=vmoqkp)
- [Securities Class Action Filings Scraper](https://apify.com/parseforge/securities-class-action-filings-scraper?fpr=vmoqkp)

# Actor input Schema

## `courts` (type: `array`):

Which of the nine index families published by the New York State Law Reporting Bureau to read. Commercial Division and Other Courts are the trial level, where contract, lending and merchant cash advance disputes are decided; the Appellate Divisions and the Court of Appeals are the appeals above them.

## `monthsBack` (type: `integer`):

How many archived monthly indexes to walk after the current month, newest first. 0 reads only the month in progress. The archive reaches back to 2003 for most courts and to 2013 for the Commercial Division, so 274 is the whole record.

## `maxItems` (type: `integer`):

Stop after this many rows.

## `keywords` (type: `array`):

Keep only decisions whose text contains these. Matching against the case title is free; matching against the full opinion opens every decision page and costs a page read each, which is what makes a subject feed such as "merchant cash advance" possible.

## `keywordScope` (type: `string`):

Case title only, or the full text of the opinion.

## `matchAllKeywords` (type: `boolean`):

Off keeps a decision that matches any keyword; on requires all of them.

## `counties` (type: `array`):

Keep only decisions whose court line contains one of these, for example "New York County", "Kings", "Westchester".

## `judges` (type: `array`):

Keep only decisions by these judges. Matched as a substring of the judge line.

## `decidedAfter` (type: `string`):

ISO date, for example 2026-01-01.

## `decidedBefore` (type: `string`):

ISO date, for example 2026-12-31.

## `startUrls` (type: `array`):

Specific decision pages or monthly index pages on www.nycourts.gov to read instead of walking the courts above.

## `outputs` (type: `array`):

Decisions is the case rows. Months is the directory of every archived monthly index the Bureau publishes for the selected courts, which is how you find out what is available before asking for it.

## `includeFullText` (type: `boolean`):

The complete text of the decision, opens the decision page.

## `includeParties` (type: `boolean`):

The caption split into plaintiff and defendant sides.

## `includeCounsel` (type: `boolean`):

The attorneys and firms of record, as the opinion lists them.

## `includeDigest` (type: `boolean`):

The Bureau's own subject classification for the decision.

## `includeCaseNumbers` (type: `boolean`):

Every index, indictment, docket, motion and appeal number printed on the decision.

## `includeFootnotes` (type: `boolean`):

The numbered footnotes of the opinion.

## `includePublicationNote` (type: `boolean`):

Whether the opinion is uncorrected, subject to revision, or final in the printed Official Reports.

## `includePdfText` (type: `boolean`):

About three quarters of the archived trial court decisions are published as PDF rather than HTML. Tick this to download and read those PDFs for the rows a run keeps. It cannot be used to search: one opinion PDF measured 10.4 MB, so scanning them is not practical and the full text keyword filter skips them.

## `proxyMode` (type: `string`):

The site answers this actor without a proxy from Apify, which is why none is the default. Datacenter exists for running from outside the United States, where the site geo-filters.

## `countryCode` (type: `string`):

Two letter country code used when a proxy is on.

## Actor input object example

```json
{
  "courts": [
    "commercial-division"
  ],
  "monthsBack": 1,
  "maxItems": 20,
  "keywords": [],
  "keywordScope": "title",
  "matchAllKeywords": false,
  "counties": [],
  "judges": [],
  "startUrls": [],
  "outputs": [
    "decisions"
  ],
  "includeFullText": false,
  "includeParties": false,
  "includeCounsel": false,
  "includeDigest": false,
  "includeCaseNumbers": false,
  "includeFootnotes": false,
  "includePublicationNote": false,
  "includePdfText": false,
  "proxyMode": "none",
  "countryCode": "US"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `csv` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "courts": [
        "commercial-division"
    ],
    "monthsBack": 1,
    "maxItems": 20,
    "keywords": [],
    "counties": [],
    "judges": [],
    "decidedAfter": "",
    "decidedBefore": "",
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/ny-court-decisions-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "courts": ["commercial-division"],
    "monthsBack": 1,
    "maxItems": 20,
    "keywords": [],
    "counties": [],
    "judges": [],
    "decidedAfter": "",
    "decidedBefore": "",
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ny-court-decisions-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "courts": [
    "commercial-division"
  ],
  "monthsBack": 1,
  "maxItems": 20,
  "keywords": [],
  "counties": [],
  "judges": [],
  "decidedAfter": "",
  "decidedBefore": "",
  "startUrls": []
}' |
apify call parseforge/ny-court-decisions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/ny-court-decisions-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YsITvtKGH90wj25dv/builds/VKecypL7h72pfO13h/openapi.json