# Japan Government Subsidies & Grants (jGrants) (`jpopendata/japan-grants`) Actor

Open Japanese government subsidy calls (補助金) from the official jGrants public API run by the Digital Agency. English field schema, source attribution embedded in every record, optional per-subsidy detail enrichment.

- **URL**: https://apify.com/jpopendata/japan-grants.md
- **Developed by:** [JP Open Data](https://apify.com/jpopendata) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Japan Government Subsidies & Grants (jGrants)

**Structured English-schema data on Japanese government subsidy programs (補助金) — straight from the official jGrants API.**

This Actor queries the public API of jGrants, the national subsidy application platform operated by Japan's Digital Agency (デジタル庁), and returns open subsidy calls as clean, English-field JSON: program title, granting institution, maximum amount in JPY, application window, target regions and company sizes. No scraping, no browser, no API key — two documented JSON endpoints, politely.

> **Unofficial tool.** Not affiliated with or endorsed by the Digital Agency or the Government of Japan. This Actor uses the jGrants public API; every record embeds the source, the portal link, and the retrieval timestamp.

***

### Quick start — verified input

Copy-paste this into the Actor's input (JSON tab) or pass it via API — it was run successfully on 2026-09-02 (100 currently-open subsidy calls, sorted by deadline, ~5 seconds):

```json
{
  "keyword": "補助金",
  "acceptanceOnly": true,
  "maxItems": 100
}
```

#### Common input mistakes

| Wrong | Right | Why |
|---|---|---|
| `"keyword": "IT"` (1 character) | `"keyword": "IT導入"` | The jGrants API requires at least 2 characters; the run stops immediately with this explanation. |
| `"targetAreaSearch": "Tokyo"` in the UI | choose `東京都` in the dropdown (via API `Tokyo` / `13` are mapped for you) | The portal matches its own Japanese labels; the actor maps English names when the run comes from the API. |
| `"targetAreaSearch": "Kanto"` | `"targetAreaSearch": "全国"` or one prefecture | Regions are not portal areas; the run stops with the list of valid areas. |
| `"targetNumberOfEmployees": "10 people"` | `"targetNumberOfEmployees": "20名以下"` | Portal labels verbatim (dropdown). |
| `"industry": "IT"` | `"industry": "情報通信業"` | JSIC division label in Japanese; a non-matching value returns 0 items with a warning (not an error). |
| `"maxItems": "100"` | `"maxItems": 100` | Numbers are numbers in JSON — the platform rejects a numeric string before the run starts. |

Every invalid value stops the run **immediately** (before any upstream request) with a message that names the field and lists the valid values. Fields with a fixed list of values are validated by the Apify platform before the run even starts.

#### Empty results?

A run that finishes with `items: 0` and `complete: true` is not an error — the portal simply has no open call matching every filter. Typical causes: `usePurpose` / `industry` values that are not the portal's verbatim Japanese labels (the log warns), `acceptanceOnly: true` combined with a niche keyword outside application season, or a prefecture-scoped `targetAreaSearch` (many programmes are registered as 全国 only). Drop one filter at a time and re-run.

***

### Who is this for?

- **Foreign-owned subsidiaries and their advisors** — Japan runs thousands of subsidy programs (the jGrants platform lists on the order of 3,600), for equipment, IT adoption, R\&D, energy efficiency, regional expansion. Most are announced only in Japanese. Track the ones your Japanese entity qualifies for.
- **Consultants and grant advisories** — monitor new calls and closing deadlines by purpose, industry, region, and company size, feeding your own pipeline instead of re-checking a portal.
- **AI / data teams** — build subsidy-matching tools on structured JSON with normalized ISO dates, instead of parsing a Japanese web portal.

### What you get

- **Server-side filtering** by keyword, purpose, industry, target region, and company size — the same filters the official portal uses.
- **Normalized fields**: `maxLimitAmountJpy` (with the upstream's "0 = not specified" mapped honestly to `null`), ISO 8601 datetimes, acceptance windows, and a `detailUrl` that always points to the human-readable jGrants page.
- **Optional detail enrichment** (`includeDetail: true`): purpose and industry tags, subsidy rate, catch phrase, application periods, and attachment *metadata* (document type and file name).

### Sample output (dataset item)

```json
{
  "subsidyId": "a0WXXXXXXXXXXXX",
  "title": "小規模事業者持続化補助金（一般型）",
  "institutionName": "全国商工会連合会",
  "targetArea": "全国",
  "maxLimitAmountJpy": 2000000,
  "acceptanceStartDate": "2026-07-01T01:00:00.000Z",
  "acceptanceEndDate": "2026-09-30T08:00:00.000Z",
  "targetNumberOfEmployees": "20名以下",
  "detailFetched": false,
  "detailUrl": "https://www.jgrants-portal.go.jp/subsidy/a0WXXXXXXXXXXXX",
  "source": "jGrants（デジタル庁）",
  "sourceUrl": "https://www.jgrants-portal.go.jp/",
  "license": "jGrants public API terms (attribution required; confirm for your use case)",
  "retrievedAt": "2026-08-25T09:12:44Z"
}
```

### Input reference

```json
{
  "keyword": "IT導入",
  "usePurpose": "設備整備・IT導入をしたい",
  "targetAreaSearch": "東京都",
  "targetNumberOfEmployees": "300名以下",
  "acceptanceOnly": true,
  "includeDetail": true,
  "maxItems": 100
}
```

Filter values are matched verbatim against the portal's Japanese labels (`targetAreaSearch` and `targetNumberOfEmployees` are dropdowns; the input schema lists working examples for `usePurpose` / `industry`). A non-matching free-text value returns zero hits with a warning — the Actor tells you instead of silently returning nothing forever.

### Pricing

Pay per result — see the pricing tab. No subscription; a run that finds nothing new costs almost nothing.

### FAQ

**Where does the data come from?**
From the public API of jGrants (jgrants-portal.go.jp), the national subsidy application system operated by the Digital Agency. Every record carries `source`, `sourceUrl`, `license`, and `retrievedAt` fields, and `detailUrl` links to the official program page.

**Is this an official government service?**
No. This is an **unofficial** tool, built and maintained independently. It is not affiliated with, operated by, or endorsed by the Digital Agency or any Japanese government body.

**How complete is the coverage?**
The Actor returns what the jGrants API returns for your search. jGrants is the national platform, but not every Japanese subsidy is administered through it (some ministries and municipalities run their own schemes). We don't claim "all Japanese subsidies" — no single source can.

**Why don't I get the application documents?**
The detail API embeds whole attachment files; this Actor deliberately keeps **metadata only** (document type and file name) and never outputs the binary content. It also never outputs the free-form program description HTML, because that field routinely contains office contact blocks (staff names, phone numbers, e-mails). This is a privacy-by-design decision, enforced by automated tests, not a missing feature. Use `detailUrl` to read the full program page on the official portal.

**How fast is detail enrichment?**
The Actor limits itself to one connection with ≥1.2 s between requests, so enrichment throughput is about 50 records per minute, capped by a per-run request budget. Records beyond the budget still arrive with list-level fields and `detailFetched: false`, and the run summary reports whether enrichment completed. List-only runs are near-instant (the list endpoint returns all hits in one request).

**What about rate limits?**
The Actor backs off exponentially on HTTP 429/5xx and fails visibly rather than hammering the API or evading limits. No proxy-rotation tricks, by design.

### Search terms this Actor answers

Japan government subsidies · Japan grants for business · jGrants API English · 補助金 data · Japan subsidy database · government funding Japan · Japan SME subsidies · Japan R\&D grants

### More Japan public-data Actors by the same developer

- **Japan Government Tenders & Awards** — tender notices and award results (who won, at what price) from the kkj.go.jp portal.
- **Japan Medical Facilities** — every registered hospital, clinic, dental clinic, and pharmacy (MHLW open data).
- **Japan Care Facilities** — long-term care providers across 35 service types (MHLW open data, CC BY).
- **Japan Renewable Energy FIT/FIP Facilities** — METI-certified renewable installations, privacy-safe schema.
- **Japan Financial Licenses & Registrations** — FSA-licensed banks, securities firms, crypto exchanges and more.
- **Japan Construction & Real-Estate Licenses** — licensed contractors and brokers from MLIT's register.
- **Japan Trade Statistics** — monthly import/export flows by HS code and partner country, from Japan Customs.

***

*Data source: jGrants — 補助金電子申請システム（デジタル庁）— https://www.jgrants-portal.go.jp/ . This Actor uses the jGrants public API and states so in every record.*

# Actor input Schema

## `keyword` (type: `string`):

Optional, default 補助金 ("subsidy", matches broadly). Full-text search keyword, minimum 2 characters (upstream API requirement; Japanese works best, e.g. IT導入, ものづくり, 創業).

## `acceptanceOnly` (type: `boolean`):

Optional, default true. If enabled, only subsidies whose application window is currently open are returned (upstream acceptance=1). Disable to include closed/upcoming calls.

## `includeDetail` (type: `boolean`):

Optional, default false. If enabled, the actor calls the detail API once per record (politeness-throttled, ~1 record / 1.2 s) and adds usePurpose, industry, subsidyRate, application periods, and attachment METADATA (file names only — binaries are never downloaded). Each detail is one API request, so coverage is capped by `maxApiRequests`.

## `usePurpose` (type: `string`):

Optional server-side filter. Must match one of the portal's Japanese labels verbatim, e.g. 新たな事業を行いたい, 設備整備・IT導入をしたい, 販路拡大・海外展開をしたい, 研究開発・実証事業を行いたい, 人材育成を行いたい, 資金繰りを改善したい, まちづくり・地域振興支援がほしい. A non-matching value is not an error: the run completes with 0 items and a warning (see README "Empty results?").

## `industry` (type: `string`):

Optional server-side filter. Japan Standard Industrial Classification division label in Japanese, verbatim — e.g. 製造業, 情報通信業, 建設業, 卸売業、小売業, 宿泊業、飲食サービス業, 医療、福祉. A non-matching value is not an error: the run completes with 0 items and a warning.

## `targetAreaSearch` (type: `string`):

Optional server-side filter: 全国 (nationwide programmes) or one prefecture (programmes targeting that prefecture). Via API the English name ("Tokyo"), JIS code ("13") or Japanese name is accepted and mapped to the portal label.

## `targetNumberOfEmployees` (type: `string`):

Optional server-side filter on the eligible company size (portal labels, verbatim).

## `sort` (type: `string`):

Optional, default acceptance\_end\_datetime (application deadline, soonest first with order=ASC).

## `order` (type: `string`):

Optional, default ASC.

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

Optional, default 100. Maximum number of records to output (1..5000). The list API returns the full hit set in one request; this truncates client-side (after upstream sorting).

## `maxApiRequests` (type: `integer`):

Optional, default 60. Hard safety cap on upstream API requests in one run (1 request is the list; with includeDetail each record costs 1 more). When the cap is hit the run still SUCCEEDS with the records collected so far (remaining records carry list-level fields only).

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

Optional. Apify proxy settings. Default: NO proxy (direct connection works). The actor backs off exponentially on 429/5xx and fails visibly on a persistent block — it never attempts rate-limit evasion.

## Actor input object example

```json
{
  "keyword": "ものづくり",
  "acceptanceOnly": true,
  "includeDetail": false,
  "usePurpose": "設備整備・IT導入をしたい",
  "industry": "情報通信業",
  "targetAreaSearch": "",
  "targetNumberOfEmployees": "",
  "sort": "acceptance_end_datetime",
  "order": "ASC",
  "maxItems": 100,
  "maxApiRequests": 60,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `records` (type: `string`):

Structured records with source attribution (source, sourceUrl, license, retrievedAt) on every item.

# 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 = {
    "keyword": "補助金",
    "maxItems": 100,
    "maxApiRequests": 60
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/japan-grants").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 = {
    "keyword": "補助金",
    "maxItems": 100,
    "maxApiRequests": 60,
}

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/japan-grants").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 '{
  "keyword": "補助金",
  "maxItems": 100,
  "maxApiRequests": 60
}' |
apify call jpopendata/japan-grants --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpopendata/japan-grants"
        }
    }
}

```

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/VM2KmcAh4SCPPTkIS/builds/agNRt4ZPQTfwMzfkq/openapi.json