# Google Scholar Case Law API (`johnvc/google-scholar-case-law`) Actor

API for Google Scholar US case law. Search opinions and pull full case details with court, year, and citation filters. Returns structured JSON. MCP-ready.

- **URL**: https://apify.com/johnvc/google-scholar-case-law.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** AI, MCP servers, Automation
- **Stats:** 20 total users, 6 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.85 / 1,000 search 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

## 🏛️ Google Scholar Case Law API

Case law API for US court opinions on Google Scholar. Search opinions and pull full case details (parties, court, decision dates, full citations, cited cases) as structured JSON. Filter by court, by decision year, by language. MCP-ready, so Claude and other AI agents can call it as a tool inside AI agent workflows.

***

### 📋 What this API returns

| Field | Where | Description |
|---|---|---|
| `result_id` | search results | Google Scholar identifier. Use to fetch full case detail. |
| `title` | both | Case title with reporter citation. |
| `snippet` | search results | Short text preview from the opinion. |
| `publication_info` | search results | Author, source, and date block. |
| `inline_links` | search results | Cited-by, related, versions, cached links. |
| `name` | case detail | Short party-name designation (e.g. *Brown v. Board of Education*). |
| `court_name` | case detail | Deciding court. |
| `dates` | case detail | Decision, argued, and filed dates with type labels. |
| `short_citations` | case detail | Abbreviated case references. |
| `case_numbers` | case detail | Docket numbers. |
| `cited_cases` | case detail | Every case referenced in the opinion. |
| `first_page`, `last_page` | case detail | Reporter page range. |

***

### 🔍 Use cases

- **Legal research API.** Pull every Supreme Court opinion mentioning a phrase, scoped by year.
- **Citation analysis.** Get `cited_cases` for a known opinion and walk the citation graph.
- **Jurisdictional studies.** Restrict to a specific court (e.g. `158` for SCOTUS, `33` for New York state courts) and export the corpus.
- **Litigation prep.** Pre-load case-fact summaries into your case-management workflow.
- **AI agent workflows.** Drive this API over MCP from Claude (see below) to research case law in-conversation.

***

### 🔌 Integrations: Automate Case Law API Monitoring and AI Agent Workflows

A single run answers one question ("which Ninth Circuit opinions cite qualified immunity?"). The real value comes from running this case law API on a repeat, so new opinions land in your stack the moment Google Scholar indexes them. See the full list of [Apify platform integrations](https://docs.apify.com/platform/integrations).

**Tasks and Schedules (the core recipe).** Save one [task](https://docs.apify.com/platform/actors/running/tasks) per query you watch (a phrase like "qualified immunity" scoped to a court, or a citation-tracking query for a landmark opinion), then attach a [schedule](https://docs.apify.com/platform/schedules) from the Actor's Actions, then Schedule menu. Useful cron strings: `0 7 * * *` (daily at 7 AM), `0 */6 * * *` (every six hours), `0 9 * * 1` (Mondays). One schedule can trigger many tasks at once, so a whole watchlist of legal queries refreshes on one timer. The [Find Ninth Circuit opinions on qualified immunity](https://apify.com/johnvc/google-scholar-case-law/examples/find-ninth-circuit-opinions-on-qualified-immunity?fpr=9n7kx3) task is a ready-made starting point.

**n8n.** This API ships an n8n community node (see the n8n integration section below). A four-step monitor: Schedule Trigger, then the Google Scholar Case Law API node, then a Filter on `court_name`, then Slack or email.

**Make and Zapier.** The same pattern works no-code with [Make](https://docs.apify.com/platform/integrations/make) and [Zapier](https://docs.apify.com/platform/integrations/zapier): trigger on a schedule, run the Actor, then route the new opinions where you need them.

**Store the history (Supabase).** Send each run's rows into a table so a case law archive accumulates across runs. No-code: the n8n Actor node, then a Supabase node. Or in Python (each row carries `result_type`, `title`, `case_id`, `court_name`, `publication_info`, and `snippet`):

```python
from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("YOUR_APIFY_TOKEN")
supabase = create_client("YOUR_SUPABASE_URL", "YOUR_SUPABASE_KEY")

run = apify.actor("johnvc/google-scholar-case-law").call(run_input={
    "query": "qualified immunity",
    "maxResults": 30,
    "yearFrom": 2015,
})
rows = list(apify.dataset(run["defaultDatasetId"]).iterate_items())
supabase.table("case_law").upsert(rows).execute()
```

**MCP and AI agents.** Add this API as a tool in Claude or Cursor through the Apify MCP server so an agent can search opinions and pull case detail mid-conversation, the building block for legal-research AI agent workflows (see the Use this API from Claude section below).

**Webhooks.** For anything custom, fire an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) on `ACTOR.RUN.SUCCEEDED` to push each run's dataset into your own service.

***

### ⚙️ Input examples

#### Basic search

```json
{
  "query": "patent infringement",
  "maxResults": 20
}
```

#### Court-filtered, year-bounded search

```json
{
  "query": "First Amendment school speech",
  "maxResults": 30,
  "yearFrom": 2010,
  "yearTo": 2024,
  "courts": ["158"],
  "sortByDate": true
}
```

`courts: ["158"]` restricts to the Supreme Court of the United States. Leave `courts` empty to search every US state and federal court.

#### Fetch full case detail by ID

```json
{
  "caseIds": [
    "1810530706706468549",
    "5036225562552830387"
  ]
}
```

#### Search and auto-fetch detail for every hit

```json
{
  "query": "trademark dilution",
  "maxResults": 5,
  "fetchCaseDetailsForResults": true
}
```

Returns 5 `search_result` rows AND 5 `case_detail` rows in the dataset.

***

### 🧾 Common court codes

| Code | Court |
|---|---|
| (omitted / empty `courts`) | All US state and federal |
| `158` | Supreme Court of the United States |
| `159` | US Court of Appeals, Federal Circuit |
| `160` to `172` | US Courts of Appeals, 1st through DC Circuits |
| `192` | US Tax Court |
| `33` | New York state courts |
| `5` | California state courts |

Any numeric court code shown in Google Scholar's case-law UI is accepted.

***

### 🔌 Use this API from Claude (MCP)

This Actor is MCP-server-compatible. Once published to the Apify Store, it is reachable from any MCP client (Claude Desktop, [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), etc.) via Apify's hosted MCP server at `https://mcp.apify.com`.

Add it with this Actor-specific URL:

https://mcp.apify.com/?tools=actors,docs,johnvc/google-scholar-case-law

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

Add this to your MCP client config (e.g. `~/.claude/mcp.json` or Claude Desktop's `claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Then ask Claude:

> *"Use the Google Scholar Case Law API to find `patent infringement` cases from 2020 onward. Return the top 5 results, then fetch the full case detail for each one."*

Claude will call this Actor through the MCP server. The input schema's field descriptions become tool-arg docs, and the structured dataset comes straight back into the conversation.

***

### 💸 Pay per run with crypto (x402)

The Google Scholar Case Law API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/google-scholar-case-law) and it can
discover, pay for, and run this Actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### 💰 Pricing (pay-per-event)

| Event | Price | When it fires |
|---|---|---|
| `actor-start` | $0.02 | Once per Actor run, at startup. |
| `search-result` | $0.02 | Per organic search result returned. |
| `case-detail` | $0.02 | Per full case detail fetched. |

A 10-result search costs $0.02 + 10 x $0.02 = **$0.22**.
A 10-result search plus detail for every result costs $0.02 + 10 x $0.02 + 10 x $0.02 = **$0.42**.

***

### 🚀 How to get started

1. Open the Actor and enter a `query` (add `yearFrom` / `yearTo` or `courts` to narrow it).
2. Set `maxResults`, then run the Actor.
3. Read the rows from the dataset (JSON, CSV, Excel, or API). Set `fetchCaseDetailsForResults: true` to also pull the full case detail for every hit.

[View on Apify Store](https://apify.com/johnvc/google-scholar-case-law?fpr=9n7kx3)

Want working code? See the [Google Scholar Case Law API example repo](https://github.com/johnisanerd/Apify-Google-Scholar-Case-Law-API) for a Python quick-start and MCP setup walkthroughs for Claude, Cursor, and ChatGPT.

Data source: [Google Scholar case law](https://scholar.google.com/).

***

### 🗂️ Output format

Every dataset item has a `result_type` field. It is either `"search_result"`, `"case_detail"`, or `"error"`. Filter the dataset on this field to separate the two kinds of rows. Search results carry `result_id`; case-detail rows carry `case_id` (they are the same identifier).

#### Example output (real search result row)

```json
{
  "result_type": "search_result",
  "position": 1,
  "title": "Markman v. Westview Instruments, Inc.",
  "link": "https://scholar.google.com/scholar_case?case=10285146068541901213&q=patent+infringement&hl=en&num=1&as_sdt=80006",
  "publication_info": {
    "summary": "52 F. 3d 967 - Court of Appeals, Federal Circuit, 1995 - Google Scholar"
  },
  "snippet": "... not useful, however, in the context of a patent infringement suit ... Patents are not contracts per se and patent infringement ...",
  "inline_links": {
    "cited_by": {
      "total": 7058,
      "link": "https://scholar.google.com/scholar?cites=10285146068541901213&as_sdt=80005&sciodt=80006&hl=en&num=1",
      "cites_id": "10285146068541901213"
    }
  },
  "result_id": "nQlyNtstvI4J",
  "case_id": "10285146068541901213",
  "fetched_at": "2026-07-03T23:55:09.942747+00:00"
}
```

***

### n8n integration

Available as an n8n community node, **[n8n-nodes-google-scholar-case-law-api](https://www.npmjs.com/package/n8n-nodes-google-scholar-case-law-api)**. In n8n: Settings, Community Nodes, install `n8n-nodes-google-scholar-case-law-api`, then use it in any workflow (it also works as an AI Agent tool).

***

### 🔗 Related Tools

Building a legal or academic research pipeline? These tools from the same catalog pair well with US case law:

- [Google Scholar API](https://apify.com/johnvc/google-scholar-api?fpr=9n7kx3): research papers, author profiles, and academic citations, for the scholarship that surrounds a legal question.
- [Google Scholar Lite API](https://apify.com/johnvc/google-scholar-lite-api?fpr=9n7kx3): cheap bulk academic paper metadata when you need volume over full detail.
- [Google Patents API](https://apify.com/johnvc/google-patents-api?fpr=9n7kx3): the patent record behind an infringement dispute, to pair with the case law that interprets it.

Alternatives such as [Google Scholar Case Law Scraper](https://apify.com/jungle_synthesizer/google-scholar-case-law-scraper?fpr=9n7kx3) exist, but show minimal adoption (a handful of users and no reviews) and bill a $0.10 start fee on every run. This API is actively maintained, returns structured JSON with full case detail (parties, court, citations, and every cited case), carries public reviews, and is MCP-ready out of the box.

***

### ❓ FAQ

#### How do I find a court code?

Use the common codes table above; any numeric court code shown in Google Scholar's case-law court picker works here. Leave `courts` empty to search every US state and federal court.

#### Why did I get fewer results than `maxResults`?

`maxResults` is a ceiling, not a guarantee. Tight `yearFrom` / `yearTo` bounds or a narrow court filter simply match fewer opinions.

#### How do I get the full opinion details?

Either pass known IDs in `caseIds`, or set `fetchCaseDetailsForResults: true` on a search to auto-fetch the detail for every hit.

#### What does `result_type` mean?

Each dataset row is `"search_result"`, `"case_detail"`, or `"error"`. Filter on it to separate the row kinds.

#### A query came back empty - what should I try?

Widen the year range, drop the court filter, or simplify the query phrase; very specific phrases may match no opinions.

#### Can I schedule case law searches?

Yes. Any run can be automated on a [schedule](https://docs.apify.com/platform/schedules). Create a [saved task](https://docs.apify.com/platform/actors/running/tasks) with your query, court, and year filters, then attach a schedule from the Actor's Actions, then Schedule menu. Concrete cron strings: `0 7 * * *` for daily at 7 AM, `0 */6 * * *` for every six hours, `0 9 * * 1` for Mondays. One schedule can trigger many tasks at once, so a full watchlist of legal queries refreshes together. See the Integrations section above for the full Tasks-and-Schedules monitoring recipe.

#### Should I use an API or a web scraper for case law?

Both, and this Actor is both. An official legal-data API is usually rate limited, quota bound, and often paywalls full opinions, while a plain [web scraper](https://en.wikipedia.org/wiki/Web_scraping) returns messy HTML you still have to parse. This Actor gives you the clean, structured result of a purpose-built [API](https://en.wikipedia.org/wiki/API): call it yourself or run it no-code, pay per result, no quotas, and get the same JSON whether you want one opinion or a full corpus.

#### Can I use the Case Law API programmatically?

Yes. The Apify API runs the Actor, schedules it, and fetches datasets, and the `apify-client` package exists for both Node.js and Python. See the Actor's [API tab](https://apify.com/johnvc/google-scholar-case-law/api?fpr=9n7kx3) for ready-made snippets and your endpoint URLs.

#### Can I use this API through an MCP server?

Yes. Add it as a tool in any MCP client (Claude, Cursor, and others) through the hosted [Apify MCP server](https://mcp.apify.com/) with the Actor-specific URL `https://mcp.apify.com/?tools=actors,docs,johnvc/google-scholar-case-law`. In [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) or [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial) your agent can then research US case law in-conversation, with citations and courts. See the [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

#### Can I integrate this API with other apps?

Yes. It connects to almost any cloud service through [Apify integrations](https://docs.apify.com/platform/integrations): [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), the n8n community node, and [webhooks](https://docs.apify.com/platform/integrations/webhooks) on `ACTOR.RUN.SUCCEEDED` for custom actions. See the Integrations section above for the full recipes.

#### What are AI agent workflows for case law research?

AI agent workflows chain one or more AI agents and tools so a model can complete a multi-step task on its own. For legal research, an agent connected to this API over MCP can search opinions on [Google Scholar](https://scholar.google.com/), read the `snippet` and `publication_info`, then follow `cited_cases` to walk the citation graph, all without a human running each query. That turns a one-shot search into an autonomous research loop.

#### What is citation analysis?

Citation analysis studies which cases cite which, and how often, to measure influence and trace how a legal doctrine developed. This API supports it directly: each search result carries a `cited_by` count and link, and every `case_detail` row lists its `cited_cases`, so you can build a citation graph from a seed opinion outward. Background: [citation analysis](https://en.wikipedia.org/wiki/Citation_analysis).

#### How else can I research legal and academic sources?

Pair this API with related tools in the same catalog: the [Google Scholar API](https://apify.com/johnvc/google-scholar-api?fpr=9n7kx3) for research papers, author profiles, and academic citations, the [Google Scholar Lite API](https://apify.com/johnvc/google-scholar-lite-api?fpr=9n7kx3) for cheap bulk paper metadata, and the [Google Patents API](https://apify.com/johnvc/google-patents-api?fpr=9n7kx3) for the patent record behind an infringement dispute. See the Related Tools section above for how each one fits.

***

### Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can
run it on your account in one click.

- [Find Ninth Circuit opinions on qualified immunity](https://apify.com/johnvc/google-scholar-case-law/examples/find-ninth-circuit-opinions-on-qualified-immunity?fpr=9n7kx3) - Ninth Circuit qualified-immunity cases with citation, date, and snippet.
- [Export case law search results to CSV](https://apify.com/johnvc/google-scholar-case-law/examples/export-case-law-search-results-to-csv?fpr=9n7kx3) - case law search results as clean rows, export ready for legal review.
- [Do legal research in Claude with a case law MCP](https://apify.com/johnvc/google-scholar-case-law/examples/do-legal-research-in-claude-with-a-case-law-mcp?fpr=9n7kx3) - US case law search inside Claude chat via MCP, with citations and courts.

***

- [Search US case law with a free API](https://apify.com/johnvc/google-scholar-case-law/examples/search-us-case-law-with-a-free-api?fpr=9n7kx3) - search US federal and state case law by keyword with a free API.
- [Find Supreme Court cases citing Chevron deference](https://apify.com/johnvc/google-scholar-case-law/examples/find-supreme-court-cases-citing-chevron-deference?fpr=9n7kx3) - search Supreme Court opinions on Chevron deference.
- [检索美国商业秘密判例(结构化 JSON)](https://apify.com/johnvc/google-scholar-case-law/examples/meiguo-shangye-mimi-panli-jiansuo?fpr=9n7kx3) - 按关键词检索美国联邦与州法院判例: 案件名、法院、日期、引用与摘要, 结构化 JSON 输出。
- [查找美国专利侵权判例(联邦巡回法院)](https://apify.com/johnvc/google-scholar-case-law/examples/meiguo-zhuanli-qinquan-panli?fpr=9n7kx3) - 检索联邦巡回上诉法院的专利侵权判例: 判决日期、引用次数与案件链接, 支持按年份筛选。

***

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
See the [Google Scholar Case Law API source page](https://www.alphaosint.com/sources/google-scholar-case-law-api/) for related tools and use cases.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/google-scholar-case-law/issues/open?fpr=9n7kx3).

Last Updated: 2026.09.10

# Actor input Schema

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

Case-law search query (e.g. 'patent infringement', 'Roe v. Wade', 'First Amendment school speech'). Either `query` or `caseIds` must be provided. Supports Google Scholar operators like 'author:' and 'source:'.

## `maxResults` (type: `integer`):

Maximum number of search results to return. Up to 20 results are fetched per upstream page; results above 20 paginate. Default 20, max 100.

## `yearFrom` (type: `integer`):

Earliest decision year to include in the search (inclusive). Optional.

## `yearTo` (type: `integer`):

Latest decision year to include in the search (inclusive). Optional.

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

List of Google Scholar court codes to limit the search to specific jurisdictions. Leave empty to search ALL US state and federal courts. Common codes: '158' Supreme Court (SCOTUS), '159' Federal Circuit, '160' 1st Circuit, '161' 2nd Circuit, '162' 3rd Circuit, '192' US Tax Court, '33' New York state courts. Any numeric code from Google Scholar's case-law filter is accepted.

## `language` (type: `string`):

Two-letter language code for the search interface (ISO 639-1, e.g. 'en', 'es', 'fr'). Defaults to 'en'.

## `sortByDate` (type: `boolean`):

When true, sort results by decision date (newest first) instead of relevance.

## `excludeCitations` (type: `boolean`):

When true, exclude bare citation entries from results (only return full opinions).

## `caseIds` (type: `array`):

List of Google Scholar case IDs to pull full case detail for. Each ID is the value of `result_id` from a previous search. If `query` is empty, only these IDs are processed.

## `fetchCaseDetailsForResults` (type: `boolean`):

When true and a `query` is provided, fetch the full case detail for every search result returned (one detail charge per result). Off by default to keep search-only runs cheap.

## Actor input object example

```json
{
  "query": "patent infringement",
  "maxResults": 20,
  "language": "en",
  "sortByDate": false,
  "excludeCitations": false,
  "fetchCaseDetailsForResults": false
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every dataset item from this run: search results (result\_type='search\_result'), case details (result\_type='case\_detail'), and any error rows.

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

Tabular overview of every dataset item using the dataset schema's default view. Columns: type, result id, case id, title, name, court, snippet, link, publication info, dates, citations, cited cases, fetched-at.

# 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 = {
    "query": "patent infringement",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/google-scholar-case-law").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 = {
    "query": "patent infringement",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/google-scholar-case-law").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 '{
  "query": "patent infringement",
  "language": "en"
}' |
apify call johnvc/google-scholar-case-law --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnvc/google-scholar-case-law"
        }
    }
}

```

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/w8SNoAPyZLk7sLuOl/builds/eZ6ZaM43Vgr5imXjD/openapi.json