# Japan Legal Corpus (e-Gov) MCP Server (`aulvem/egov-mcp-apify`) Actor

Pay-per-call MCP server giving AI agents structured access to Japan's official legal corpus from e-Gov (Acts, Cabinet Orders, Ministerial Ordinances). Article-level retrieval, revision diffs, and full source attribution in LLM-optimized JSON. Information retrieval only — not legal advice.

- **URL**: https://apify.com/aulvem/egov-mcp-apify.md
- **Developed by:** [Aulvem](https://apify.com/aulvem) (community)
- **Categories:** AI, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Japan Legal Corpus (e-Gov) MCP Server

A pay-per-call MCP server giving AI agents structured access to **Japan's official legal corpus** from [e-Gov](https://laws.e-gov.go.jp/) — Acts, Cabinet Orders, and Ministerial Ordinances. Article-level retrieval, revision diffs, and full source attribution in LLM-optimized JSON.

> ⚖️ **Information retrieval only — not legal advice.** This server returns text from the official e-Gov legal corpus. It does not interpret, summarize, or provide legal opinions. Always consult a qualified Japanese legal professional for advice on a specific matter.

### What does this Actor do?

It exposes the Japanese government's legal corpus as five typed MCP tools so AI agents can look up statutes the same way they call any other tool. Behind the proxy is a Cloudflare Workers MCP server with KV-cached law data sourced from e-Gov; this Actor wraps that endpoint with Apify's pay-per-event billing, OAuth, and standby hosting so MCP clients can authenticate with their existing Apify token.

### Why use this Actor?

- **Compliance & due diligence** — pull primary-source statute text into research workflows with citation URLs preserved
- **Legal research agents** — let an LLM resolve "which Article of the 労働基準法 covers overtime pay?" in one tool call
- **Revision tracking** — diff two revisions of the same law to surface changes between effective dates
- **Multi-language** — Japanese law text with English-friendly tool descriptions
- **Sub-second** — most queries complete inside the model's tool-call budget instead of stalling generation

Source-of-truth: every response carries the e-Gov publication metadata and the canonical `laws.e-gov.go.jp` URL.

### Tools

| Tool | What it does |
|---|---|
| `search_law` | Keyword search across Acts / Cabinet Orders / Ministerial Ordinances (Japanese or English keywords). Returns ranked law IDs and titles. |
| `get_article` | Fetch a specific article (条) from a law by ID + article number. Returns full text plus structural context (chapter / section). |
| `list_categories` | Enumerate law categories (e.g., 憲法, 民事, 刑事, 労働, 税). Useful for narrowing search scope. |
| `get_law_metadata` | Enactment date, last revision, promulgation number, competent ministry, current effective status. |
| `compare_revisions` | Diff two revisions of the same law/article and return added/removed/modified passages. |

### Performance

- **p50: 196 ms warm** (KV-cache hit on the upstream Worker)
- **p95: < 1 s cold** (cache miss — full e-Gov fetch + parse)

These are upstream-Worker numbers. Apify standby adds a ~50 ms proxy hop and an additional cold-start delay if the Actor has been idle.

### Pricing

Pay Per Event: **$0.018 per tool call**. `initialize`, `tools/list`, and notifications are free. Only successful `tools/call` invocations are billed — JSON-RPC errors and `isError: true` responses are not charged.

#### Cost estimation

A typical legal research session runs ~10–30 tool calls (search → metadata → article → compare). At $0.018/call that's roughly **$0.18–$0.54 per session**. Bulk corpus extraction is also viable: 1,000 article fetches ≈ $18.

### How to connect

Once the Actor is running in Standby mode, point any MCP-capable client at:

````

https://aulvem--egov-mcp-apify.apify.actor/mcp

````

with `Authorization: Bearer <YOUR_APIFY_API_TOKEN>` so Apify can meter and bill per call.

#### Example: Claude Desktop config

```json
{
  "mcpServers": {
    "egov": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://aulvem--egov-mcp-apify.apify.actor/mcp",
        "--header",
        "Authorization: Bearer ${APIFY_API_TOKEN}"
      ],
      "env": { "APIFY_API_TOKEN": "<YOUR_APIFY_API_TOKEN>" }
    }
  }
}
````

### Input

This Actor runs in **Standby mode** — there is no input form. Send JSON-RPC over HTTP to `/mcp` instead of starting a run with input.

### Output

Tool responses are LLM-optimized JSON. Example for `get_article`:

```json
{
  "lawId": "322AC0000000049",
  "lawTitle": "労働基準法",
  "lawTitleEn": "Labor Standards Act",
  "article": {
    "number": "37",
    "title": "時間外、休日及び深夜の割増賃金",
    "text": "使用者が、第三十三条又は前条第一項の規定により労働時間を延長し、又は休日に労働させた場合においては…",
    "chapter": "第四章 労働時間、休憩、休日及び年次有給休暇"
  },
  "revision": {
    "effectiveFrom": "2023-04-01",
    "promulgationNumber": "令和X年法律第Y号"
  },
  "source": {
    "publisher": "e-Gov",
    "url": "https://laws.e-gov.go.jp/law/322AC0000000049"
  }
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data fields (article responses)

| Field | Type | Description |
|---|---|---|
| `lawId` | string | Canonical e-Gov law ID |
| `lawTitle` | string | Official Japanese title |
| `lawTitleEn` | string | English title (when published by e-Gov) |
| `article.number` | string | Article number (条) |
| `article.title` | string | Article heading |
| `article.text` | string | Full article body |
| `article.chapter` | string | Containing chapter / section path |
| `revision.effectiveFrom` | string | ISO date the current text became effective |
| `revision.promulgationNumber` | string | Promulgation reference (法令番号) |
| `source.url` | string | Citation URL on `laws.e-gov.go.jp` |

### Companion server: Japan Statistics (e-Stat)

Pair this with the [Japan Statistics (e-Stat) MCP Server](https://apify.com/aulvem/estat-mcp-apify) for quantitative data — labor force, prices, population. Common workflows combine the two: pull the relevant statute via this Actor, then pull supporting time-series data from e-Stat.

### FAQ

**Is this legal advice?** No. Information retrieval only. The text is sourced from e-Gov; interpretation is up to a qualified attorney.

**Is the data current?** Revisions are pulled from e-Gov. The upstream Worker refreshes its cache regularly, but for time-critical filings always verify against `laws.e-gov.go.jp` directly using the citation URL in the response.

**Affiliation?** Unofficial. Not affiliated with the Government of Japan, e-Gov, the Ministry of Justice, or Anthropic.

**English coverage?** e-Gov publishes English translations for selected major laws. `lawTitleEn` and English article text are returned when available; otherwise Japanese only.

**Support / feedback?** Open an issue on the Actor's Issues tab.

# Actor input Schema

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("aulvem/egov-mcp-apify").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("aulvem/egov-mcp-apify").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call aulvem/egov-mcp-apify --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=aulvem/egov-mcp-apify",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Japan Legal Corpus (e-Gov) MCP Server",
        "description": "Pay-per-call MCP server giving AI agents structured access to Japan's official legal corpus from e-Gov (Acts, Cabinet Orders, Ministerial Ordinances). Article-level retrieval, revision diffs, and full source attribution in LLM-optimized JSON. Information retrieval only — not legal advice.",
        "version": "0.2",
        "x-build-id": "wyDULHMW1CdKhdSxM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/aulvem~egov-mcp-apify/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-aulvem-egov-mcp-apify",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/aulvem~egov-mcp-apify/runs": {
            "post": {
                "operationId": "runs-sync-aulvem-egov-mcp-apify",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/aulvem~egov-mcp-apify/run-sync": {
            "post": {
                "operationId": "run-sync-aulvem-egov-mcp-apify",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {}
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
