# Japan Company Data — gBizINFO (Official API) (`jpopendata/japan-gbizinfo-companies`) Actor

Search Japan's 4.5M+ corporations via the official gBizINFO REST API: by name/prefecture/industry, or by 13-digit corporate number. Returns number, name, address, capital, employees, founding date and more (English-keyed). Bring your own free token. Personal names excluded. Unofficial.

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

## Pricing

from $2.00 / 1,000 record scrapeds

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 Company Data — gBizINFO (Official API v1)

**Search Japan's 4.5M+ corporations through the official gBizINFO REST API (JSON) — filter by name, prefecture, business item or corporate type, or look up companies by their 13-digit corporate number. Get corporate number, name, address, capital, employees, establishment date, business items and more, English-keyed, with a legal envelope on every record.**

This Actor is a thin, polite client for the **official** gBizINFO REST API v1 (`info.gbiz.go.jp/hojin/v1/hojin`) of Japan's Ministry of Economy, Trade and Industry (経済産業省 gBizINFO). It is **not a scraper** — it calls the documented JSON API the way METI intends, using **your own gBizINFO API token**, and returns each result as a flat record with a legal envelope (`source` / `sourceUrl` / `license` / `retrievedAt`) on every item.

> **Unofficial tool.** Independently built and maintained. **Not affiliated with, endorsed by, or connected to the Ministry of Economy, Trade and Industry or gBizINFO.** gBizINFO data is provided under the **政府標準利用規約（第2.0版）** (Government Standard Terms of Use v2.0), which permits commercial reuse, adaptation and redistribution with attribution; the required 出典 statement **「出典：gBizINFO(経済産業省)」** is embedded in the `license` of every record.

> **No personal names.** gBizINFO exposes a representative's name and title (代表者氏名・役職). This Actor **excludes them by construction** — the output projection is a strict allow-list that never reads those fields, and an automated test asserts no representative name reaches the dataset.

***

### Quick start — verified input

Copy, paste, replace the key, run (verified against mock API fixtures in `npm test`; a live run needs your own token — see the next section for how to get one in two minutes):

```json
{
  "apiToken": "<your key>",
  "mode": "search",
  "searchWord": "トヨタ",
  "maxItems": 100
}
```

Get the token at https://info.gbiz.go.jp/hojin/api\_registration/form (free; it is e-mailed to you). `prefecture` is a dropdown of the 47 English prefecture names; via the API you may also pass the Japanese name (`"東京都"`), the JIS code (`"13"`), or common romanisations (`"osaka-fu"`, `"Ōsaka"`).

### ⚠️ You need your own gBizINFO API token

This Actor **does not bundle an API key.** You must supply your **own** free gBizINFO API token in the `apiToken` input.

1. Register and request a token (free): **https://info.gbiz.go.jp/hojin/api\_registration/form**
2. Paste the issued token into this Actor's `apiToken` field (it is stored as a secret, sent only in the `X-hojinInfo-api-token` request header, and never written to logs or URLs).

**Why this design?** By running under **your** token, every call stays inside **your** own gBizINFO registration and any access limits apply to you. Compliance with the [gBizINFO API terms of use](https://info.gbiz.go.jp/hojin/APIManual) is the responsibility of the token holder — i.e. you.

### Source-display obligation (出典表示義務)

gBizINFO data is released under the 政府標準利用規約（第2.0版）, which requires the source to be displayed. This Actor embeds the credit **「出典：gBizINFO(経済産業省)（https://info.gbiz.go.jp/）」** verbatim in the `license` field of every record. If you display or republish the data, keep that credit visible.

### Two modes

#### 1. `search` — filtered corporate search (GET /v1/hojin)

Give a `searchWord` (company name / keyword) and/or a `prefecture`, `businessItem`, or `corporateType`, and get back matching corporations. At least one filter is required (this is a targeted search over 4.5M corporations, not a full-database dump). Results are paged automatically up to `maxItems`.

#### 2. `by_corporate_number` — look up specific companies (GET /v1/hojin/{number})

Give one or more 13-digit corporate numbers (法人番号) and get one record per company. Numbers not found in gBizINFO are skipped with a log line.

### Sample output

```json
{
  "corporateNumber": "5010001000001",
  "companyName": "サンプル商事株式会社",
  "companyNameEn": "Sample Shoji Co., Ltd.",
  "companyNameKana": "サンプルショウジ",
  "location": "東京都千代田区霞が関1-3-1",
  "postalCode": "1000013",
  "prefecture": "東京都",
  "prefectureCode": "13",
  "capitalStockJpy": 50000000,
  "employeeNumber": 120,
  "establishmentDate": "1998-04-01",
  "foundingYear": 1998,
  "businessItems": ["卸売業", "電気機械器具"],
  "businessSummary": "電気機械器具の卸売および輸出入。",
  "corporateType": "301",
  "status": "-",
  "companyUrl": "https://example.co.jp/",
  "lastUpdate": "2026-07-15",
  "profileUrl": "https://info.gbiz.go.jp/hojin/ichiran?hojinBango=5010001000001",
  "source": "gBizINFO REST API（経済産業省）/ gBizINFO REST API, Ministry of Economy, Trade and Industry of Japan",
  "sourceUrl": "https://info.gbiz.go.jp/",
  "license": "出典：gBizINFO(経済産業省)（https://info.gbiz.go.jp/）。政府標準利用規約（第2.0版）… Unofficial … Representative (personal) names are excluded.",
  "retrievedAt": "2026-08-26T09:12:44Z"
}
```

`location` is the corporation's **registered head-office address** — public corporate-registry data. The `representative_name` / `representative_position` (a person's name and title) that gBizINFO also returns are **not** included.

### Input example

```json
{
  "apiToken": "<your key>",
  "mode": "search",
  "searchWord": "製作所",
  "prefecture": "Osaka",
  "corporateType": "301",
  "maxItems": 500
}
```

#### Common input mistakes

| Mistake | Correct |
|---------|---------|
| `"apiToken": "<your key>"` left as is / empty | paste your real gBizINFO token (the run fails immediately with a link to get one) |
| `{"apiToken": "…", "mode": "search"}` with no filter | add `"searchWord": "トヨタ"` (or `prefecture` / `businessItem` / `corporateType`) |
| `{"mode": "search", "corporateNumber": ["5010001000001"]}` | `"mode": "by_corporate_number"` (the Actor switches for you when `mode` is omitted) |
| `"corporateNumber": "T5010001000001"` (invoice-registration number) | drop the `T`: `"5010001000001"` — 13 digits |
| `"prefecture": "Osaka-shi"` / `"Yokohama"` (a city) | `"prefecture": "Osaka"` / `"Kanagawa"` — prefectures only |
| `"corporateType": "株式会社"` | the code: `"301"` |

#### Empty results?

A run that finds nothing completes with 0 items and a warning in the log (not a failure). Typical causes: an English `searchWord` (corporate names are indexed in Japanese — try `トヨタ` instead of `Toyota`), a `prefecture` + `searchWord` pair that do not belong together, a `businessItem`/`corporateType` code that no corporation matches, or a corporate number that gBizINFO has no record for (HTTP 404, reported per number). Broaden the search or drop a filter and retry. HTTP 401/403 means the token is wrong or expired — that fails the run visibly.

### Pricing

Pay per result — see the pricing tab. A `search` run returns one record per matching corporation (paged); a `by_corporate_number` run returns one record per number you supply.

### FAQ

**Is this official?**
No. **Unofficial**, not affiliated with METI. It is a client of gBizINFO's official public API.

**Why is `apiToken` required and not provided?**
Every call runs under your own gBizINFO token. It is entered as a secret, sent only in the `X-hojinInfo-api-token` header, and redacted from all logs.

**Do you return representative (director) names?**
No. Representative name and title are excluded by construction, and an automated test verifies they never appear in the output.

**How fresh is the data?**
Live at request time — the same data gBizINFO serves through its API.

**Rate limits / server load?**
One sequential connection, ≥ 1.2 s between requests, exponential backoff on 429/5xx, a hard per-run request budget, and no rate-limit evasion — gBizINFO returns HTTP 429 on short-burst bulk access, so a persistent block fails the run visibly.

### Search terms this Actor answers

japan company data api · gbizinfo · japan corporate registry english · japan business database · japan corporate number lookup · 法人番号 api · japan company search api · japanese companies dataset · METI gBizINFO API · japan corporate data enrichment

### Note for the Apify automated build test

This Actor **requires** a valid personal gBizINFO `apiToken` (secret) to make any live call, so Apify's default automated run test cannot pass unattended (no key). **An automated-test exemption is requested for this Actor** (same handling as other key-required API Actors, e.g. japan-estat-statistics and japan-yahoo-shopping-api). Functionality is covered by the unit test suite (`npm test`, 27 tests) over mock API fixtures; a live run needs the buyer's own token.

***

*Official API: gBizINFO REST API v1 — https://info.gbiz.go.jp/hojin/APIManual . Terms: 政府標準利用規約 v2.0 — commercial use, adaptation and redistribution permitted with attribution (embedded in every record). Credit 「出典：gBizINFO(経済産業省)」 is embedded in every record. Representative (personal) names are excluded. Unofficial; not affiliated with METI.*

# Actor input Schema

## `apiToken` (type: `string`):

REQUIRED. YOUR OWN gBizINFO API token (a long alphanumeric string). This Actor does NOT bundle a shared key — every request runs under your own token, sent in the X-hojinInfo-api-token header, and gBizINFO's access limits apply to you. Register (free) and issue a token: https://info.gbiz.go.jp/hojin/api\_registration/form → the token is e-mailed to you.

## `mode` (type: `string`):

`search` (default) runs a filtered full-text search over corporations (GET /v1/hojin) — set at least one of searchWord / prefecture / businessItem / corporateType. `by_corporate_number` looks up specific corporations by 13-digit number (GET /v1/hojin/{number}) — set corporateNumber. If you pass only corporate numbers the Actor switches to by\_corporate\_number for you. Example: "search".

## `searchWord` (type: `string`):

search mode: full-text search over the corporate name (maps to the API `name` filter), Japanese matches best, e.g. "トヨタ", "製作所". At least one filter (searchWord, prefecture, businessItem, or corporateType) is required in search mode.

## `corporateNumber` (type: `array`):

by\_corporate\_number mode (REQUIRED there): one or more 13-digit Japanese corporate numbers (法人番号), e.g. \["5010001000001"]. A comma-separated string is also accepted; hyphens/full-width digits are tolerated.

## `prefecture` (type: `string`):

search mode (optional): restrict the search to a prefecture — pick one of the 47 prefectures by English name, e.g. "Tokyo", "Osaka" (via the API the Japanese name "東京都", the JIS code "13" or romanisations such as "osaka-fu" also work).

## `businessItem` (type: `string`):

search mode (optional): restrict by 営業品目 (business item) code — maps to the API `business_item` filter (e.g. "101"). See the gBizINFO API spec for the code list.

## `corporateType` (type: `string`):

search mode (optional): restrict by 法人種別 (corporate type) 3-digit code — maps to the API `corporate_type` filter, e.g. "301" (株式会社), "302" (有限会社), "305" (合同会社).

## `includeClosed` (type: `boolean`):

Include closed/dissolved corporations too (sets exist\_flg=true). Default: active corporations only. "true"/"false" strings are tolerated.

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

Maximum number of company records to output, 1-100000 (default 1000). Search results are paged automatically. PPE charges per record.

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

Hard safety cap on API requests per run, 1-50 (default 20). Politeness (1 connection, >= 1.2 s spacing, exponential backoff on 429/5xx) is enforced in code; gBizINFO returns HTTP 429 on short-burst bulk access.

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

Apify proxy settings. Default is NO proxy (direct connection) — an official JSON API rarely needs one. 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
{
  "mode": "search",
  "searchWord": "トヨタ",
  "corporateNumber": [
    "5010001000001"
  ],
  "corporateType": "301",
  "includeClosed": false,
  "maxItems": 1000,
  "maxApiRequests": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Corporation records with source attribution (source, sourceUrl, license, retrievedAt) on every item. Representative (personal) names are excluded.

# 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 = {
    "mode": "search",
    "searchWord": "トヨタ",
    "maxItems": 1000,
    "maxApiRequests": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/japan-gbizinfo-companies").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 = {
    "mode": "search",
    "searchWord": "トヨタ",
    "maxItems": 1000,
    "maxApiRequests": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/japan-gbizinfo-companies").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 '{
  "mode": "search",
  "searchWord": "トヨタ",
  "maxItems": 1000,
  "maxApiRequests": 20
}' |
apify call jpopendata/japan-gbizinfo-companies --silent --output-dataset

```

## MCP server setup

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

```

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/Mlhkc2sUlDIFvd3nY/builds/C2GiSKN3GQK3a5IDk/openapi.json