# CourtListener Oral Arguments Scraper - Court Audio (`parseforge/courtlistener-oral-arguments-scraper`) Actor

Scrape US courtroom oral argument recordings from CourtListener by court, judge, date and case, with MP3 links and transcripts. Export to CSV, JSON, Excel or XML.

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

## Pricing

from $3.62 / 1,000 results

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 Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎧 CourtListener Oral Arguments Scraper

> 🚀 **Export US courtroom oral argument recordings in seconds.** Pick a court, a judge or a date range and get one 27-field row per recording with a permanent MP3 link, the panel, the docket number and the machine transcript. The archive holds 103,018 recordings across 16 courts, and the Ninth Circuit alone accounts for 33,830 of them.

Appellate courts record their oral arguments and publish the audio, but each court posts it on its own website in its own layout, and the files disappear or move when the court reorganises its archive. CourtListener, run by the non-profit Free Law Project, collects those recordings, mirrors the MP3 on its own storage, runs speech to text over it, and exposes the lot through a public REST API. This Actor queries that API, flattens each recording into one row, and hands you the audio link, the case it belongs to and the transcript in a single export.

Coverage measured on 2026-09-08: 103,018 recordings, from the Supreme Court of the United States, all thirteen federal circuits, the Illinois Supreme Court and the Illinois Appellate Court. The oldest argument in the index was recorded in 1969 and the newest is added within hours. Every row carries 27 fields, and every recording carries a machine transcript that runs from roughly 19,000 to 34,000 characters on a typical thirty-minute argument.

| 🎯 Target Audience | 💡 Primary Use Cases |
| --- | --- |
| Appellate litigators | Hear how a panel questioned counsel before you argue in front of it |
| Legal tech and AI teams | Transcript corpora with case, court, panel and date metadata attached |
| Law schools and clinics | Build a moot court library filtered by circuit, judge or subject |
| Journalists and podcasters | Pull the audio of a newsworthy argument the day it happens |
| Judicial analytics vendors | Argument length, panel composition and cadence, court by court |

### 📋 What the CourtListener Oral Arguments Scraper does

> 💡 **Why it matters:** the audio exists, but it is scattered. `cdn.ca9.uscourts.gov` names files by docket number with no index, the Supreme Court publishes a separate MP3 page per term, and none of them tell you who sat on the panel or what was said. This Actor turns that scatter into rows: search across all 16 courts at once, filter by judge or date, get a permanent mirrored MP3 URL that does not rot when the court reorganises, and take the transcript with it.

- Search 103,018 oral argument recordings by court, judge, case name, docket number, argument date or full text.
- Full-text search runs over the transcript, so a phrase a judge actually said is a query.
- Two audio links per row: the court's own file and CourtListener's permanent mirror on `storage.courtlistener.com`.
- Panel names and CourtListener judge IDs where the court publishes them.
- The opening of the machine transcript on every row, and the complete transcript on request.
- Duration in seconds and as H:MM:SS, plus file size in bytes and megabytes.
- Stable IDs (recording ID, docket ID, SHA-1 of the audio file) so runs can be diffed and deduplicated.
- Export to CSV, Excel, JSON or XML, or pull the dataset straight from the Apify API.

### 🎬 Full Demo (🚧 Coming soon)

A walkthrough video is on the way.

### 📊 Output

One row per oral argument recording.

| Field | Description |
| --- | --- |
| ⚖️ `caseName` | Case caption as the court published it |
| 🔗 `url` | Recording page on courtlistener.com, with the in-browser player |
| 🆔 `id` | CourtListener recording ID, stable across runs |
| 🏛 `court` / 🏷 `courtId` / 📎 `courtCitationString` | Court name, CourtListener court ID (for example `ca9`), reporter-style abbreviation |
| 🔢 `docketNumber` | Appellate docket number, for example `25-5252` |
| 📅 `dateArgued` | Date the argument was heard |
| ⏱ `durationSeconds` / 🕰 `durationFormatted` | Length of the recording in seconds and as H:MM:SS |
| 🎧 `audioUrl` | CourtListener's permanent MP3 mirror on `storage.courtlistener.com` |
| 📥 `sourceAudioUrl` | The MP3 on the court's own server, which courts do reorganise |
| 🧮 `fileSizeBytes` / 💾 `fileSizeMb` | Size of the MP3 |
| 👩‍⚖️ `judges` / `judgeIds` / 🔢 `judgeCount` | Panel as the court named it, the CourtListener judge IDs, and the panel size |
| 📝 `hasTranscript` | `Yes` when CourtListener has speech-to-text for the recording |
| 🗣 `transcriptExcerpt` | The opening of the transcript, roughly 500 characters |
| 📄 `transcript` / `transcriptCharacters` | The complete transcript and its length, only when the transcript option is on |
| 🆔 `docketId` / 📂 `docketUrl` | The docket the recording hangs off, and its page |
| 🧾 `pacerCaseId` | PACER's internal case ID, where the court supplies one |
| 🗃 `sourceCode` | CourtListener's provenance code for the file, for example `C` for the court's own website |
| 🔐 `sha1` | SHA-1 of the audio file, for change detection |
| 🕓 `dateAdded` | When the recording entered CourtListener |
| 🕒 `scrapedAt` | ISO timestamp of the collection |
| ❌ `error` | `null` on success; error rows carry only this field and are never charged |

Three real records from a run against the Ninth Circuit, newest first. The `transcriptExcerpt` values are shortened here for readability; the Actor returns them in full.

```json
[
  {
    "caseName": "Natalia Golban v. Todd Blanche",
    "url": "https://www.courtlistener.com/audio/106164/natalia-golban-v-todd-blanche/",
    "id": 106164,
    "court": "Court of Appeals for the Ninth Circuit",
    "courtId": "ca9",
    "courtCitationString": "9th Cir.",
    "docketNumber": "15-73093",
    "dateArgued": "2026-09-03",
    "durationSeconds": 1361,
    "durationFormatted": "0:22:41",
    "audioUrl": "https://storage.courtlistener.com/mp3/2026/09/03/natalia_golban_v._todd_blanche_cl.mp3",
    "sourceAudioUrl": "https://cdn.ca9.uscourts.gov/datastore/media/2026/09/03/15-73093.mp3",
    "fileSizeBytes": 8240697,
    "fileSizeMb": 7.86,
    "judges": "THOMAS, GOULD, BYBEE",
    "judgeIds": "488; 1254; 3205",
    "judgeCount": 3,
    "hasTranscript": "Yes",
    "transcriptExcerpt": "May it please the Court, my name is Sergei Shevchenko, I'm a counsel for the petitioner Natalia Golban, and I would like to reserve two minutes for rebuttal. Manage your own time. Thank you, Your Honor. ...",
    "docketId": 74746630,
    "docketUrl": "https://www.courtlistener.com/docket/74746630/",
    "pacerCaseId": "Not Disclosed",
    "sourceCode": "C",
    "sha1": "c7c69119451b4b666e916ebd38c4fec5ea33a4ce",
    "dateAdded": "2026-09-03T19:31:29.136135Z",
    "scrapedAt": "2026-09-08T05:29:59.724Z",
    "error": null
  },
  {
    "caseName": "Rushing v. Williams-Sonoma, Inc.",
    "url": "https://www.courtlistener.com/audio/106163/rushing-v-williams-sonoma-inc/",
    "id": 106163,
    "court": "Court of Appeals for the Ninth Circuit",
    "courtId": "ca9",
    "courtCitationString": "9th Cir.",
    "docketNumber": "25-5252",
    "dateArgued": "2026-09-03",
    "durationSeconds": 1839,
    "durationFormatted": "0:30:39",
    "audioUrl": "https://storage.courtlistener.com/mp3/2026/09/03/rushing_v._williams-sonoma_inc._cl.mp3",
    "sourceAudioUrl": "https://cdn.ca9.uscourts.gov/datastore/media/2026/09/03/25-5252.mp3",
    "fileSizeBytes": 11108315,
    "fileSizeMb": 10.59,
    "judges": "THOMAS, GOULD, BYBEE",
    "judgeIds": "488; 1254; 3205",
    "judgeCount": 3,
    "hasTranscript": "Yes",
    "transcriptExcerpt": "Good morning. May it please the Court, Craig Cardone on behalf of Williams-Sonoma, and I would like to reserve four minutes for rebuttal. Now, notwithstanding the numerous exemplars and webpages ...",
    "docketId": 74746627,
    "docketUrl": "https://www.courtlistener.com/docket/74746627/",
    "pacerCaseId": "Not Disclosed",
    "sourceCode": "C",
    "sha1": "ba28ef2e363371a685018245c03ab07fe627d43d",
    "dateAdded": "2026-09-03T19:31:26.489099Z",
    "scrapedAt": "2026-09-08T05:29:59.724Z",
    "error": null
  },
  {
    "caseName": "Montenegro v. CVS Pharmacy, Inc.",
    "url": "https://www.courtlistener.com/audio/106156/montenegro-v-cvs-pharmacy-inc/",
    "id": 106156,
    "court": "Court of Appeals for the Ninth Circuit",
    "courtId": "ca9",
    "courtCitationString": "9th Cir.",
    "docketNumber": "24-6404",
    "dateArgued": "2026-09-02",
    "durationSeconds": 2095,
    "durationFormatted": "0:34:55",
    "audioUrl": "https://storage.courtlistener.com/mp3/2026/09/02/montenegro_v._cvs_pharmacy_inc._cl.mp3",
    "sourceAudioUrl": "https://cdn.ca9.uscourts.gov/datastore/media/2026/09/02/24-6404.mp3",
    "fileSizeBytes": 12643531,
    "fileSizeMb": 12.06,
    "judges": "THOMAS, BYBEE, BRESS",
    "judgeIds": "488; 3205; 14459",
    "judgeCount": 3,
    "hasTranscript": "Yes",
    "transcriptExcerpt": "Good morning. May it please the court, Brent Wisner on behalf of the appellants. If the court would allow, I'd like to reserve three minutes for rebuttal. The ACME monograph prohibits the sale ...",
    "docketId": 74740849,
    "docketUrl": "https://www.courtlistener.com/docket/74740849/",
    "pacerCaseId": "Not Disclosed",
    "sourceCode": "C",
    "sha1": "e7889f30d110f07c7b91c0ee5bfb8fe730382a42",
    "dateAdded": "2026-09-02T20:31:42.029387Z",
    "scrapedAt": "2026-09-08T05:29:59.724Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| | What you get |
| --- | --- |
| **All 16 courts in one query** | SCOTUS, all thirteen federal circuits, the Illinois Supreme Court and the Illinois Appellate Court. Those 16 ids were queried together on 2026-09-08 and returned all 103,018 recordings, so the court list in the input is the whole archive, not a sample. |
| **Audio that does not rot** | Every row carries CourtListener's permanent mirror on `storage.courtlistener.com` next to the court's own URL. The mirror was verified to answer HTTP 200 with `audio/mpeg` and a byte length equal to the `fileSizeBytes` column. |
| **Search inside what was said** | The full-text query runs over the machine transcript, not just the caption. Searching a phrase from the bench is a supported query. |
| **The whole transcript, on request** | Each row carries roughly the first 500 characters. Turn on the transcript option and you get the complete text, 19,000 to 34,000 characters on a typical argument, plus a character count. |
| **The panel, where the court names it** | `judges` and `judgeIds` come straight from CourtListener. The Ninth Circuit names its panel on every recording; across the whole archive it is about one recording in four, and the field says `Not Disclosed` rather than guessing. |
| **No API key needed** | CourtListener throttles anonymous callers at 5 requests a minute per IP, and each request returns 20 rows. Turn the proxy on for a fresh exit IP per request, or paste your own free CourtListener key and the throttle disappears. |
| **You pay for what you keep** | Rows are billed as they are written and capped at `maxItems`, so a page that overshoots the cap is trimmed before it is charged. Duplicates are dropped before billing, never after. |

### 📈 How it compares to alternatives

| | This Actor | Court websites | Generic CourtListener actors |
| --- | --- | --- | --- |
| Courts in one query | 16, the whole archive | One per site | Usually opinions and dockets, audio rarely |
| Search by what was said | Yes, over the transcript | No | No |
| Permanent audio link | Mirror plus the court's own URL | Court URL only, and it moves | Sometimes the court URL |
| Panel names and judge IDs | On the row where published | Rarely | Rarely |
| Full transcript | Opt-in, complete | Not published | No |
| Rows a free account can preview | 10 | Not applicable | Varies |
| Ceiling | Anonymous API throttle of 5 requests a minute per IP, lifted by a free key or the proxy; 20 rows per request, no page-size control | Manual browsing | Same source, same ceiling |

### 🚀 How to use

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [CourtListener Oral Arguments Scraper](https://apify.com/parseforge/courtlistener-oral-arguments-scraper?fpr=vmoqkp).
3. Pick one or more courts, set a date range or a search phrase, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

One typical run: `courts` `["ca9"]`, `arguedAfter` `01/01/2026`, `orderBy` `dateArgued desc`, `maxItems` `200`. Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### 💼 Business use cases

#### 🎙️ Prepare for a panel before you argue

Filter by court and judge surname, sort by argument date, and pull the last two years of recordings for the panel you are about to face. The transcript column makes the questions searchable, so an appellate team can see how a specific judge presses on standing or on harmless error before writing the reply brief.

#### 🧠 Build a legal speech corpus

Every row pairs an MP3 URL with a transcript, a court, a date and a docket number. AI teams use it to fine-tune legal speech models, to benchmark their own speech-to-text against CourtListener's, or to ground a retrieval system in what was argued rather than what was written.

#### 📰 Cover an argument the day it happens

Run it on a schedule against a court, sort newest first, and diff against the previous run. Newsrooms and legal podcasters get the audio link and the opening exchange within hours of the argument, without watching fourteen court websites.

#### 📊 Measure how courts actually work

`durationSeconds`, `judgeCount`, `dateArgued` and `courtId` on every row turn into argument-length distributions by circuit, panel composition over time, or the gap between argument and decision when joined to a docket export.

### 🔌 Automating CourtListener Oral Arguments Scraper

- **Make / Zapier:** trigger a run on a schedule, then push new recordings to a CRM, a Google Sheet or a Slack channel.
- **Slack:** post each new case caption, court and audio link to a practice-group channel.
- **Airbyte:** land the dataset in Snowflake, BigQuery or Postgres for analytics.
- **GitHub:** commit the JSON export to a repository to keep a versioned history of arguments.
- **Google Drive:** drop the CSV or Excel export into a shared folder, with the MP3 links ready to click.

### 🌟 Beyond business use cases

- **Research:** compare argument length and panel composition across circuits, or track how often a court hears argument at all.
- **Personal:** listen to the argument in a case you are following, straight from a link in a spreadsheet.
- **Non-profit:** build an accessible, searchable archive of arguments in the areas of law you work in.
- **Experimentation:** train a speaker-diarisation model, or index the transcripts for a question-answering demo.

### 🤖 Ask an AI assistant about this scraper

Give an AI agent live access to US oral argument recordings through the Model Context Protocol:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/courtlistener-oral-arguments-scraper"
```

Then prompt it in plain language:

- *"Find Ninth Circuit arguments heard this month and give me the audio links."*
- *"Which Federal Circuit arguments mention claim construction, and how long were they?"*
- *"Pull every Supreme Court argument from last term with its transcript."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/courtlistener-oral-arguments-scraper" to search US oral argument recordings. Input: { "query": "<phrase>", "courts": ["ca9"], "judge": "<surname>", "arguedAfter": "MM/DD/YYYY", "arguedBefore": "MM/DD/YYYY", "docketNumber": "<number>", "includeTranscript": true, "maxItems": <n> }. It returns case name, court, docket number, argument date, duration, two MP3 links, the panel and the transcript per row. Call it with the ApifyClient and my APIFY_TOKEN.
```

### ❓ Frequently Asked Questions

#### ❓ Do I need a CourtListener account?

No. The oral argument API is open to anonymous callers. A free CourtListener API key is optional and only lifts the rate limit, which makes long runs faster.

#### ❓ Which courts are covered?

Sixteen: the Supreme Court of the United States, the First through Eleventh Circuits, the D.C. Circuit, the Federal Circuit, the Illinois Supreme Court and the Illinois Appellate Court. Those sixteen hold every recording in the index, verified by querying them together and getting the full 103,018 back. No federal district court and no other state court publishes argument audio through CourtListener today.

#### ❓ How far back does the archive go?

The oldest recording is dated 1969 and there are only a handful before 2005. The bulk of the archive is 2005 onwards, and 37,837 arguments were heard in 2020 or later.

#### ❓ Can I download the audio?

The row gives you two URLs. `audioUrl` is CourtListener's own mirror and is the one to use in a pipeline: it answers HTTP 200 with `audio/mpeg` and does not move when a court reorganises. `sourceAudioUrl` is the court's original file. The Actor returns links, not the audio bytes, so your storage bill stays yours.

#### ❓ How good are the transcripts?

They are machine transcripts produced by CourtListener, not certified court reporting. They are accurate enough to search and to feed a model, and wrong often enough that you should not quote one without listening. `hasTranscript` tells you whether text exists for a recording.

#### ❓ Why is the transcript column empty on my run?

The full transcript is opt-in. Turn on **Include the full transcript** and each row gains `transcript` and `transcriptCharacters`. Without it every row still carries `transcriptExcerpt`, roughly the first 500 characters.

#### ❓ Why does the transcript option make runs slower?

CourtListener has no bulk endpoint for transcripts, so the Actor fetches one per recording. Anonymously that runs into the 5 requests a minute throttle quickly. Add a free API key or turn the proxy on before pulling transcripts in volume.

#### ❓ Why do some rows say `Not Disclosed` for the judges?

Because the court did not publish the panel with the recording. Across the archive about one recording in four names its panel; the Ninth Circuit names it on every one. The Actor never guesses a panel, so the sentinel is the honest answer.

#### ❓ Why am I getting no results?

Every filter is ANDed. A court plus a judge surname plus a narrow date range can easily match nothing. Drop a filter or widen the dates. The log prints the total CourtListener reports for your search, which tells you immediately whether the query itself is empty.

#### ❓ How fast is it, and what is the ceiling?

Each request returns 20 rows and takes about a second. There is no page-size parameter, so 1,000 rows means 50 requests. Anonymously CourtListener allows 5 requests a minute per IP; the Actor waits out `Retry-After` when it is throttled, rotates the proxy session when the proxy is on, and skips the limit entirely with an API key.

#### ❓ Does it deduplicate?

Yes, on the CourtListener recording ID, before the row is written and before it is charged. A recording re-published under a second docket number is delivered once.

#### ❓ Why fewer rows than Max Items?

Because the search ran out of matches. `maxItems` is a cap, not a target. Free accounts are also capped at 10 rows per run as a preview.

#### ❓ How fresh is the data?

The Ninth Circuit sample above was collected five days after the arguments were heard, and CourtListener typically indexes a recording within hours of the court posting it. `dateAdded` on every row tells you exactly when it landed.

#### ❓ Am I charged for failed requests?

No. Error rows carry only the `error` field and are pushed without a charge event. You pay per delivered recording.

### 🔌 Integrate with any app

The dataset is available through the Apify API and the JavaScript and Python clients, and every run can be scheduled, triggered by webhook or wired into Make, Zapier, n8n, Airbyte, Google Sheets, Slack and GitHub from the **Integrations** tab.

### 🔗 Recommended Actors

- [CourtListener Civil Cases Scraper](https://apify.com/parseforge/courtlistener-civil-cases-scraper?fpr=vmoqkp): federal civil dockets by nature of suit, with parties, counsel and firms.
- [CourtListener Scraper](https://apify.com/parseforge/courtlistener-docket-scraper?fpr=vmoqkp): all six CourtListener indexes, including judges and dockets.
- [CourtListener Opinions Scraper](https://apify.com/parseforge/court-listener-opinions-scraper?fpr=vmoqkp): full opinion text, walked by court feed.
- [CourtListener Business Bankruptcy Scraper](https://apify.com/parseforge/business-bankruptcy-filings-scraper?fpr=vmoqkp): US business bankruptcy filings by chapter and court.
- [Justia Case Law Scraper](https://apify.com/parseforge/justia-case-law-scraper?fpr=vmoqkp): published opinions from Justia by court and year.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more court, government and public-records scrapers.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA) with your run ID, your input, and what you expected.

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the Free Law Project or CourtListener. It collects only publicly available court data through the public API. You are responsible for using the data and the audio in compliance with CourtListener's terms and applicable laws. Court recordings capture real people speaking: do not use them to identify, profile, or target individuals.

# Actor input Schema

## `query` (type: `string`):

Full-text query across the case caption and the machine transcript of the recording, so a phrase a judge said is searchable. Supports quoted phrases and AND/OR/NOT. Leave empty to browse with the filters alone.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000. Leave empty on a paid plan for 100 rows.

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

Restrict to one or more courts. These 16 courts hold every one of the 103,018 recordings in the archive (measured 2026-09-08). Leave empty for all of them.

## `arguedAfter` (type: `string`):

Earliest argument date, as MM/DD/YYYY or YYYY-MM-DD. The archive starts in 1969 and the bulk of it is 2005 onwards.

## `arguedBefore` (type: `string`):

Latest argument date, as MM/DD/YYYY or YYYY-MM-DD.

## `caseName` (type: `string`):

Match words in the case caption, for example "smith" or "united states".

## `docketNumber` (type: `string`):

Exact appellate docket number, for example 25-727 or 22-1008.

## `judge` (type: `string`):

Surname of a judge on the panel, for example thomas or kagan. CourtListener names the panel on about a quarter of the recordings, so this filter narrows to those.

## `orderBy` (type: `string`):

How to order recordings. Relevance only means anything when a search query is set.

## `includeTranscript` (type: `boolean`):

Add the complete machine transcript of every recording, often 30,000 characters or more, as the transcript and transcriptCharacters columns. Costs one extra request per recording, so runs are slower. Off by default, when each row still carries the opening of the transcript.

## `courtListenerKey` (type: `string`):

A free CourtListener API key (Profile > API on courtlistener.com) lifts the anonymous throttle and makes long runs faster. Leave empty to run anonymously.

## `proxyConfiguration` (type: `object`):

Off by default: the CourtListener API is open. Turn it on for long anonymous runs so each request gets a fresh exit IP and its own throttle allowance. Not used when an API key is supplied.

## Actor input object example

```json
{
  "maxItems": 10,
  "courts": [
    "ca9"
  ],
  "orderBy": "dateArgued desc",
  "includeTranscript": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields: case, court, docket number, argument date, duration, audio links, judges, transcript excerpt

## `fullData` (type: `string`):

Complete dataset with all 27 fields, plus the full transcript when that option is on

# 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 = {
    "maxItems": 10,
    "courts": [
        "ca9"
    ],
    "orderBy": "dateArgued desc",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/courtlistener-oral-arguments-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 = {
    "maxItems": 10,
    "courts": ["ca9"],
    "orderBy": "dateArgued desc",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/courtlistener-oral-arguments-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 '{
  "maxItems": 10,
  "courts": [
    "ca9"
  ],
  "orderBy": "dateArgued desc",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call parseforge/courtlistener-oral-arguments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/courtlistener-oral-arguments-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/0VgtYjq17Sk7h4Lhe/builds/Q78tCVpieQuMGe7GJ/openapi.json