# 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.

***

### 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 example

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

Filter values are matched verbatim against the portal's Japanese labels (the input schema lists working examples). A non-matching 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`):

Full-text search keyword, minimum 2 characters (upstream API requirement; Japanese works best). Default `補助金` ("subsidy") matches broadly.

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

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

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

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 simply returns 0 hits (the actor warns).

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

Optional server-side filter. Japan Standard Industrial Classification division label in Japanese, verbatim — e.g. `製造業`, `情報通信業`, `建設業`, `医療、福祉`. A non-matching value returns 0 hits (the actor warns).

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

Optional server-side filter: `全国` (nationwide) or a prefecture name in Japanese, e.g. `東京都`, `大阪府`, `北海道`, `神奈川県`.

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

Optional server-side filter. Portal labels, verbatim — e.g. `従業員数の制約なし`, `5名以下`, `20名以下`, `50名以下`, `100名以下`, `300名以下`, `900名以下`, `901名以上`.

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

Upstream sort field. Default sorts by application deadline (soonest first with order=ASC).

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

Sort order

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

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

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

Hard safety cap on upstream API requests in one run (politeness: the API rate-limits sustained bulk access). 1 request is the list; with includeDetail each record costs 1 more. The run stops enriching gracefully when the cap is hit.

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

Apify proxy settings. Default is NO proxy (direct connection). 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": "300名以下",
  "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 = {};

// 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 = {}

# 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 '{}' |
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/WfQPHDf5X4n4cFpcW/openapi.json