# Japan AMeDAS Weather Observations (JMA official data) (`jpopendata/japan-amedas-observations`) Actor

Unofficial tool reading Japan Meteorological Agency (JMA) AMeDAS open data: live surface observations (temperature, rain, wind, sunshine, humidity, snow) from ~1,300 stations, per-station time series, and the station directory, English-labelled. Public open data, no API key. Not affiliated with JMA.

- **URL**: https://apify.com/jpopendata/japan-amedas-observations.md
- **Developed by:** [JP Open Data](https://apify.com/jpopendata) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.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 AMeDAS Weather Observations (JMA official data)

Turn the **Japan Meteorological Agency (JMA / 気象庁)** AMeDAS network — Japan's ~1,300-station automated surface-observation grid (地域気象観測システム) — into clean, English-labelled records. This Actor reads JMA's own public `bosai` AMeDAS JSON (the same data that powers the live map on jma.go.jp) and restructures it: station names and prefectures resolved to English, `[deg, min]` coordinates converted to decimal degrees, wind directions decoded to English cardinals, and every measurement labelled with its unit.

No API key. No login. Public government open data.

> **Observations, not forecasts.** This is the *live-measurement* sibling of **[Japan Weather Forecast & Warnings (JMA)](https://apify.com/jpopendata/japan-weather-jma)**, which reads JMA's *forecast* and *warning* feeds. Use this Actor for what the weather **is** right now; use the forecast Actor for what it **will be**.

### Quick start — verified input

Copy, paste, run. This exact input is verified on the platform (SUCCEEDED, items > 0):

```json
{
  "mode": "latest",
  "prefecture": "Tokyo",
  "maxItems": 500
}
```

Running with **no input at all** also works (same defaults). `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"`, `"Tokyo-to"`). For one specific station use `{"mode": "by_station", "stationCode": "44132"}`.

### What you get

Pick a **mode**:

- **`latest`** — the most recent 10-minute snapshot for **every reporting station** nationwide (or filtered to a prefecture / list of stations). One record per station.
- **`by_station`** — the full 10-minute **time series** for the station(s) you name (the latest 3-hour file), including daily max/min temperature and peak gust. One record per timestep.
- **`stations`** — the AMeDAS **station directory**: code, names (EN / 漢字 / カナ), latitude, longitude, altitude, prefecture, and which elements each station observes.

#### Example output (`latest`, one station)

```json
{
  "mode": "latest",
  "stationCode": "44132",
  "stationNameEn": "Tokyo",
  "stationNameJa": "東京",
  "prefectureCode": "13",
  "prefectureNameEn": "Tokyo",
  "latitude": 35.6917,
  "longitude": 139.75,
  "altitude": 25,
  "observedAt": "2026-08-26T04:20:00+09:00",
  "temperatureC": 26.9,
  "humidity": 89,
  "precipitation1hMm": 0,
  "windSpeedMs": 1.8,
  "windDirectionCode": 14,
  "windDirection": "Northwest",
  "sunshineHours": 0,
  "pressureHpa": 1006.8,
  "source": "気象庁 アメダス bosai JSON ... / Japan Meteorological Agency (JMA) AMeDAS surface-observation open data",
  "sourceUrl": "https://www.jma.go.jp/bosai/amedas/",
  "license": "出典：気象庁ホームページ（https://www.jma.go.jp/）。...",
  "retrievedAt": "2026-08-26T12:00:00.000Z"
}
```

Every record carries the four attribution fields (`source`, `sourceUrl`, `license`, `retrievedAt`).

#### Measured fields

`temperatureC`, `humidity` (%), `precipitation10mMm` / `precipitation1hMm` / `precipitation3hMm` / `precipitation24hMm`, `windSpeedMs` (10-min mean), `windDirectionCode` (JMA 1–16) + `windDirection` (English cardinal), `sunshine10mMin` / `sunshineHours`, `snowDepthCm`, `pressureHpa`, `seaLevelPressureHpa`, and (in `by_station`) `gustSpeedMs` + `gustDirection`. Any value a station does not measure — or that is missing at that moment — is `null` (never fabricated).

### Input

| Field | Description |
|-------|-------------|
| `mode` | `latest` (default), `by_station`, or `stations`. Case-insensitive. |
| `prefecture` | Optional filter for `latest` / `stations`: one of the 47 prefectures — English (`"Tokyo"`), Japanese (`"東京都"`), or JIS code (`"13"`). |
| `stationCode` | 5-digit AMeDAS code(s), comma-separated or as a list (e.g. `"44132"` Tokyo, `"62078"` Osaka). **Required for `by_station`**; optional filter for `latest`. |
| `maxItems` | Max records to output, 1–2000 (default 500). |
| `maxApiRequests` | Hard per-run request cap, 1–60 (default 12). |
| `proxyConfiguration` | Apify proxy; default is a direct connection. |

Station codes live in [`amedastable.json`](https://www.jma.go.jp/bosai/amedas/const/amedastable.json), or run mode `stations` to list them. A station's prefecture is derived from the leading two digits of its code via JMA's own prefecture-block table.

Values are validated **before** the first request; an invalid value fails the run immediately with a message that lists the valid values.

#### Common input mistakes

| Mistake | Correct |
|---------|---------|
| `"prefecture": "Osaka-shi"` / `"Yokohama"` (a city) | `"prefecture": "Osaka"` / `"Kanagawa"` — prefectures only |
| `"mode": "by_station"` without `stationCode` | add `"stationCode": "44132"` — or use `"mode": "latest"` with a `prefecture` |
| `"stationCode": "Tokyo"` | a 5-digit code: `"44132"` (find it with `"mode": "stations"`) |
| `"stationCode": "4413"` (4 digits) | `"44132"` — codes are exactly 5 digits |
| `"mode": "observations"` / `"current"` | `"mode": "latest"` (these two aliases are accepted, other words are not) |
| `"maxItems": "all"` | a number, e.g. `500` |

#### Empty results?

The run completes with 0 items (and a warning in the log, not a failure) when the filter matches no station: a `prefecture` + `stationCode` pair that do not belong together (e.g. `"prefecture": "Tokyo"` with `"stationCode": "62078"` Osaka), or a station code that JMA has retired. Also note that `latest` only lists stations that reported in the most recent 10-minute slot — a station under maintenance is absent until it reports again. Drop the extra filter or take a current code from mode `stations`.

### How it fetches (politeness)

A single sequential connection, **≥ 1.2 s between requests**, exponential backoff on 429/5xx, and a hard per-run request budget. A `latest` run makes only ~3 requests (station table + latest-time pointer + one all-station map). The Actor never evades a block: on a persistent 429 it fails visibly rather than hammering the server.

### Attribution, terms & disclaimer

- **Public open data.** JMA website content is provided under the 公共データ利用規約（第1.0版）(Public Data License 1.0), which permits copying, adaptation, and **commercial** use provided the source is displayed. The required credit — **出典：気象庁** — is embedded verbatim in every record's `license` field. See the [JMA terms of use](https://www.jma.go.jp/jma/kishou/info/coment.html).
- **Unofficial — not affiliated.** This is an independent tool. It is **not** affiliated with, endorsed by, or operated by the Japan Meteorological Agency.
- **Edited / adapted.** Per the terms, note that this tool **edits and adapts** JMA data (structuring Japanese data into English); it does not present the data as if produced by JMA. It redistributes JMA-published observation values; it is **not a forecasting service** (気象業務法第17条) and does **not itself issue warnings** (第23条). For life-safety decisions, always consult the official JMA site.
- **Your responsibility.** You are responsible for your own compliance with the JMA website terms and any applicable law (including data-protection law such as the GDPR) in how you use the output. The data is aggregate meteorology and contains no personal data.

### Search terms

japan amedas data · japan weather observation api · japan temperature data english · jma amedas · japan rainfall data · japan wind observation · japan weather station data · tokyo temperature api · japan meteorological observations · 気象庁 アメダス json

# Actor input Schema

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

What to fetch. `latest` (default) = the most recent 10-minute observation for every reporting station (filter with prefecture / stationCode). `by_station` = the 10-minute time series for the station(s) in stationCode (stationCode required). `stations` = the AMeDAS station directory (metadata + which elements each observes). Example: "latest".

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

Optional. Keep only stations in this prefecture — pick one of the 47 prefectures by English name, e.g. "Tokyo", "Osaka", "Hokkaido" (via the API the Japanese name "東京都" or JIS code "13" also work). Applies to `latest` and `stations` modes; ignored by `by_station`. Leave empty for all of Japan.

## `stationCode` (type: `string`):

Optional for `latest`, REQUIRED for `by_station`. 5-digit AMeDAS station code, e.g. "44132" (Tokyo), "62078" (Osaka), "14163" (Sapporo). Several codes may be comma-separated: "44132, 62078". Find codes in https://www.jma.go.jp/bosai/amedas/const/amedastable.json or run mode `stations`.

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

Maximum number of records to output (1-2000). One record = one station at one timestamp (`latest`/`stations` emit up to one per station; `by_station` emits one per 10-minute step). Example: 500.

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

Hard safety cap on requests to www.jma.go.jp per run (1-60; `latest` needs ~3: station table + latest\_time + map). Politeness (1 connection, >= 1.2 s spacing, exponential backoff on 429/5xx) is enforced in code. Example: 12.

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

Apify proxy settings. Default is NO proxy (direct connection) — a public JSON feed 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": "latest",
  "prefecture": "Tokyo",
  "stationCode": "44132",
  "maxItems": 500,
  "maxApiRequests": 12,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

JMA AMeDAS records (latest / by\_station / stations) 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 = {
    "mode": "latest",
    "prefecture": "Tokyo",
    "maxItems": 500,
    "maxApiRequests": 12
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/japan-amedas-observations").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": "latest",
    "prefecture": "Tokyo",
    "maxItems": 500,
    "maxApiRequests": 12,
}

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/japan-amedas-observations").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": "latest",
  "prefecture": "Tokyo",
  "maxItems": 500,
  "maxApiRequests": 12
}' |
apify call jpopendata/japan-amedas-observations --silent --output-dataset

```

## MCP server setup

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

```

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/KSriYmoNHXSQt5gew/builds/HN2gKmB2QO2wfQuf5/openapi.json