# Japan Government Tenders & Awards (kkj.go.jp) (`jpopendata/japan-tenders`) Actor

Structured Japanese government procurement notices (national / prefectural / municipal) from the official kkj.go.jp search API. English field schema, source attribution embedded in every record.

- **URL**: https://apify.com/jpopendata/japan-tenders.md
- **Developed by:** [JP Open Data](https://apify.com/jpopendata) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 0.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 Tenders & Awards

**Structured English-schema data on Japanese government tenders — including who won and at what price.**

This Actor queries the official cross-government procurement portal of Japan (kkj.go.jp, operated by the SME Agency) and returns tender notices **and award results** from national ministries, prefectures, municipalities, and public agencies as clean, English-field JSON. Think of it as a *SAM.gov or TED equivalent for Japan* — one API call instead of a Japanese-only XML portal.

> **Unofficial tool.** Not affiliated with or endorsed by the SME Agency (中小企業庁) or the Government of Japan. Data is retrieved via the portal's public search API; every record links back to the official source.

***

### Who is this for?

- **Sales & BD teams entering the Japanese market** — find public-sector opportunities in your category, and see which competitors won similar contracts and at what price, without reading Japanese.
- **Procurement intelligence & research firms** — feed Japanese tender and award data into your own database with a stable schema, explicit sourcing, and a license trail on every record.
- **AI / data engineers** — skip the Japanese XML parsing. Get LLM-ready JSON for tender-alert bots, RAG pipelines, and market dashboards. Works with Apify schedules, webhooks, and the Apify API out of the box.

If you already work with SAM.gov, TED (EU), or India CPPP data, the field layout will feel familiar. This is the missing piece for Japan procurement data.

### What makes it different

1. **Awards, not just notices.** Most Japan tender tools stop at announcements. This Actor also returns award records — awardee name and award amount in JPY — the data you need for competitor analysis and pricing.
2. **Notice-to-award linkage.** Tender notices and their award results share identifiers, so you can follow a procurement from publication to contract in one dataset.
3. **English-first schema.** Field names, organization levels, and procurement categories are in English. Original Japanese text (titles, organization names) is preserved untouched, so nothing is lost in translation.

### Sample output (dataset item)

```json
{
  "noticeId": "kkj-2026-XXXXXXX",
  "noticeType": "award",
  "title": "庁舎ネットワーク機器更新一式",
  "organization": {
    "name": "国土交通省",
    "level": "national"
  },
  "prefecture": { "code": "13", "name": "Tokyo" },
  "publishedDate": "2026-07-14",
  "deadline": null,
  "procurementCategory": {
    "code": "71",
    "ja": "情報処理関連",
    "en": "IT & data processing services"
  },
  "awardee": { "name": "○○株式会社" },
  "awardAmountJpy": 24750000,
  "awardDate": "2026-07-10",
  "detailUrl": "https://www.kkj.go.jp/...",
  "source": "官公需情報ポータルサイト（中小企業庁）",
  "sourceUrl": "https://www.kkj.go.jp/",
  "license": "kkj.go.jp API terms (attribution + link required)",
  "retrievedAt": "2026-08-25T09:12:44Z"
}
```

Tender-notice records (`noticeType: "tender_notice"`) carry `deadline` instead of the award fields. A `raw` object preserves the original API response fields for anyone who needs the untouched Japanese source data.

### Input example

```json
{
  "keyword": "ネットワーク",
  "noticeType": "both",
  "organizationLevel": ["national", "prefecture"],
  "prefecture": "13",
  "dateFrom": "2026-07-01",
  "dateTo": "2026-08-25",
  "maxItems": 500
}
```

- `keyword` — search term (Japanese works best today; see FAQ).
- `noticeType` — `"tender"`, `"award"`, or `"both"` (default `"both"`).
- `organizationLevel` — filter by national / prefecture / municipal issuers.
- `prefecture` — JIS prefecture code, or national-level only.
- `dateFrom` / `dateTo` — publication date window (ISO 8601).
- `maxItems` — default 100, max 10,000. The Actor never does an unbounded full crawl by default.

### Pricing

Pay per result: **$3 per 1,000 records** (+ $0.05 per Actor start). No subscription. A monthly pull of ~500 IT-related notices and awards costs about $1.55. Compare that with tender-alert subscriptions that run $50–several hundred per month whether you use them or not.

### FAQ

**Where does the data come from?**
From the public search API of the 官公需情報ポータルサイト (kkj.go.jp), the cross-government procurement information portal operated by Japan's SME Agency. It aggregates tender notices and award information published by national ministries, incorporated agencies, prefectures, and municipalities. Every record includes `source`, `sourceUrl`, `license`, and `retrievedAt` fields, and `detailUrl` always points to the official portal or issuing organization. This is a mandatory part of the portal's API terms — and it makes the data audit-friendly for your own compliance.

**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 SME Agency or any Japanese government body. This Actor uses the portal's public API and displays the required attribution and link.

**How complete is the coverage?**
The Actor returns what the kkj.go.jp portal publishes through its API. The portal aggregates a large share of public-sector notices across government levels, but not every Japanese public contract appears there (some organizations publish only on their own sites). We deliberately do not claim "all Japanese tenders" — no source can honestly claim that.

**How fresh is the data?**
The portal receives new notices continuously on business days. Run the Actor on an Apify schedule (e.g., daily) to keep a rolling window of new notices and awards.

**Do I need to read Japanese?**
The schema, categories, and organization levels are English. Titles and organization names remain in original Japanese — deliberately, so records stay verifiable against the official source. Piping titles through a translation step (or an LLM) works well; the structure is already done for you.

**What about rate limits and server load?**
The Actor throttles itself (~1 request / 1.2 s), respects the portal's terms prohibiting sustained bulk access, and backs off exponentially on HTTP 429. It does **not** attempt to evade rate limiting via proxy rotation. This keeps the tool sustainable and the source healthy. If you need very large historical pulls, split them across runs.

**Can I redistribute the data?**
The portal's terms require attribution and a link when its API is used — the Actor embeds both in every record. Review the portal's API terms (linked from each record) for your specific use case before republishing; this README is not legal advice.

### Search terms this Actor answers

Japan government tenders · Japan government procurement in English · Japan tender API · Japan procurement data · Japanese public sector bids · government contract awards Japan · SAM.gov equivalent for Japan · TED equivalent Japan · kkj.go.jp API English

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

- **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 Government Subsidies & Grants** — open subsidy calls from the official jGrants API.
- **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: 官公需情報ポータルサイト（中小企業庁）— https://www.kkj.go.jp/ . This Actor uses the portal's public search API and is required to state so and link back; we consider that a feature, not fine print.*

# Actor input Schema

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

Full-text search keyword (Japanese works best, e.g. 情報システム). Supports the portal's operators: `A AND B`, `A OR B`, `A ANDNOT B`, `NOT A`, parentheses (half-width spaces around operators are required). At least one of keyword / a two-digit prefecture code is required unless noticeType is `award` (`prefecture: national` is client-side only and does not count).

## `noticeType` (type: `string`):

`tender` = call-for-tender notices only, `award` = award/bid-result documents only (title-based classification, see README for coverage caveats), `both` = everything.

## `organizationLevel` (type: `array`):

Filter by issuing organization level (heuristic classification from the organization name). Empty = all levels.

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

JIS X 0401 prefecture code (01 Hokkaido ... 47 Okinawa), or `national` to keep only records classified as national-government level. Empty = no geographic filter. Note: `national` is filtered client-side, so it must be combined with a keyword (or noticeType `award`).

## `dateFrom` (type: `string`):

Filter by notice publication date (CFT\_Issue\_Date), inclusive start. If omitted and the result set needs more than one API request, deep pagination only covers the last 365 days — set this explicitly to reach older notices.

## `dateTo` (type: `string`):

Filter by notice publication date (CFT\_Issue\_Date), inclusive end.

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

Maximum number of records to output. The upstream API returns at most 1,000 records per request; beyond that the actor slices the date range into windows (more requests, politeness-throttled).

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

Hard safety cap on upstream API requests in one run (politeness: the portal forbids sustained bulk access). The run stops gracefully when the cap is hit.

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

Apify proxy settings. Default is NO proxy (direct connection). Note: kkj.go.jp has been observed to challenge/rate-limit datacenter IPs; the actor backs off and stops on repeated 429s — it never attempts WAF evasion.

## Actor input object example

```json
{
  "keyword": "情報システム",
  "noticeType": "both",
  "organizationLevel": [],
  "prefecture": "",
  "dateFrom": "2026-08-01",
  "dateTo": "2026-08-31",
  "maxItems": 50,
  "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": "情報システム"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/japan-tenders").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": "情報システム" }

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/japan-tenders").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": "情報システム"
}' |
apify call jpopendata/japan-tenders --silent --output-dataset

```

## MCP server setup

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

```

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/ad8W8drGNefarBvPf/builds/eD3axUh1LWHZjKUpQ/openapi.json