# Japan Subsidies & Grants: jGrants + City Programs (`jp-data-lab/japan-subsidies-cities`) Actor

Japanese government subsidies and grants in one schema: national and prefectural programs from the official jGrants API, plus city programs that jGrants does not list (Yokohama, Nagoya). Dates (including Japanese era years), caps in yen, subsidy rates and open/closed status are normalized.

- **URL**: https://apify.com/jp-data-lab/japan-subsidies-cities.md
- **Developed by:** [JP Data Lab](https://apify.com/jp-data-lab) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 subsidy programs

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Japan Subsidies & Grants: jGrants + City Programs

Get Japanese government subsidy and grant programs as clean JSON, **including city programs that jGrants does not list**.

Most Japanese subsidy tools read only jGrants, the Digital Agency's portal. jGrants covers national programs and many prefectures, but big cities usually publish their own programs only on their own websites. For example, on 2026-10-27 jGrants had **0** open city programs from Yokohama or Nagoya. This Actor fills that gap and returns everything in one schema.

### Sources

| `source` | Coverage | How |
|---|---|---|
| `jgrants` | National ministries and agencies, many prefectures (e.g. Tokyo), some cities | Official jGrants public API |
| `yokohama` | Yokohama City business support programs (中小企業支援) | Crawls the official city website |
| `nagoya` | Nagoya City industry programs (産業振興) | Crawls the official city website |

More cities will be added based on usage.

### Output

One item per program:

```json
{
  "id": "yokohama:1fdcce9f13f1",
  "source": "yokohama",
  "issuer": "横浜市",
  "title": "太陽光発電導入支援助成金",
  "url": "https://www.city.yokohama.lg.jp/business/kigyoshien/keieishien/capex/solar.html",
  "targetArea": "横浜市",
  "maxAmountYen": 5000000,
  "subsidyRate": null,
  "applicationStart": "2026-05-01",
  "applicationEnd": "2026-10-30",
  "status": "open",
  "periodText": "申請期間は、令和8年5月1日(金曜日)10時 ~ 令和8年10月30日(金曜日)17時までです。",
  "pageUpdatedAt": "2026-10-26",
  "scrapedAt": "2026-10-27T01:19:56+09:00"
}
```

| Field | Meaning |
|---|---|
| `maxAmountYen` | Largest cap stated on the page, in yen (`5億円` → `500000000`) |
| `subsidyRate` | As written, normalized: `1/2`, `2/3`, `20%以内`, `定額` |
| `applicationStart` / `applicationEnd` | ISO dates. Japanese era years (令和・平成) are converted. Either can be `null` |
| `status` | `open`, `upcoming`, `closed` (judged against today in JST), or `unknown` when the page states no dates; these are often year-round programs |
| `periodText` | The sentence the dates came from, so you can check them |

### Input

| Field | Default | |
|---|---|---|
| `sources` | all | Any of `jgrants`, `yokohama`, `nagoya` |
| `keywords` | none | Keep programs whose title contains any keyword (Japanese), e.g. `省エネ`, `創業`, `DX` |
| `statuses` | `open`, `upcoming`, `unknown` | Add `closed` to include past programs |
| `maxItems` | 1000 | You pay per result |

A full run takes about 3 minutes, because city websites are crawled politely on purpose (at most one new request per second per site). Run it on a daily or weekly schedule.

### Limitations

- City fields are extracted from free-form Japanese web pages with rules, not from a database. Always check `url` before applying. `periodText` shows where the dates came from.
- When a page lists several rounds (第1回, 第2回), the round that includes today is returned. If none does, the latest round is returned.
- Dates written without a year are read as the same Japanese fiscal year (April to March) as the page's last update. Deadlines like 「毎年度1月31日」 become the next upcoming date.
- If only a start date is known, `status` is `open` only when the program started in the current fiscal year. Otherwise it is `unknown`.
- Many city programs close early when the budget runs out (先着順). `status: open` means the deadline has not passed. It does not mean budget is left.
- Only facts (name, dates, amounts, rates, link) are output. Page text is not copied.
- jGrants items have no `subsidyRate` (the list API does not return it).
- Not affiliated with the Digital Agency, Yokohama City or Nagoya City.

***

### 日本語

国の補助金（Jグランツ）と、Jグランツに載らない市の補助金（横浜市・名古屋市）を同じ形式の JSON で取得します。和暦の日付、上限額（円）、補助率、受付状況（受付中・受付前・終了）をそろえて出力します。市の情報は公式サイトの各制度ページから事実項目だけを抜き出したものです。申請の前に必ず元のページ（`url`）を確認してください。

# Actor input Schema

## `sources` (type: `array`):

Where to collect from. jgrants = national and prefectural programs (official jGrants API). yokohama / nagoya = city programs crawled from the city's official website.

## `keywords` (type: `array`):

Keep only programs whose title contains any of these words, e.g. 省エネ, 創業, DX. Leave empty for all programs. For jGrants each keyword (2+ characters) is also sent to the API search.

## `statuses` (type: `array`):

open = accepting applications today (JST), upcoming = not started yet, closed = deadline passed, unknown = the page states no dates (often year-round programs).

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

Stop after this many results. You are charged per result.

## Actor input object example

```json
{
  "sources": [
    "jgrants",
    "yokohama",
    "nagoya"
  ],
  "keywords": [],
  "statuses": [
    "open",
    "upcoming",
    "unknown"
  ],
  "maxItems": 1000
}
```

# Actor output Schema

## `subsidies` (type: `string`):

One item per subsidy or grant program: title, issuer, URL, application dates (ISO), status (open / upcoming / closed / unknown), max amount in yen and subsidy rate.

## `runSummary` (type: `string`):

Number of programs found and returned per source in this run.

# 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 = {
    "sources": [
        "jgrants",
        "yokohama",
        "nagoya"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jp-data-lab/japan-subsidies-cities").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 = { "sources": [
        "jgrants",
        "yokohama",
        "nagoya",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jp-data-lab/japan-subsidies-cities").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 '{
  "sources": [
    "jgrants",
    "yokohama",
    "nagoya"
  ]
}' |
apify call jp-data-lab/japan-subsidies-cities --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jp-data-lab/japan-subsidies-cities"
        }
    }
}
```

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/0PeMyFniBKQAs7bwU/builds/1XErQWMh9UiXt4MWU/openapi.json