# JMA Japan Earthquake Scraper (`parseforge/jma-japan-earthquake-scraper`) Actor

Collects earthquake events from the Japan Meteorological Agency public feed. Returns each event as a flat row with magnitude, shindo intensity, hypocenter coordinates, depth, and tsunami advisory text.

- **URL**: https://apify.com/parseforge/jma-japan-earthquake-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Other
- **Stats:** 1 total users, 0 monthly users, 86.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### JMA Japan Earthquake Scraper

**Scrape Japan earthquake data directly from the JMA feed, filtered by magnitude, up to a million events per run.** Every record includes hypocenter coordinates, depth, maximum seismic intensity, and tsunami advisories. No API key required. Export to CSV, JSON, Excel, or XML.

The Japan Meteorological Agency publishes real-time earthquake bulletins, but consuming the XML feed and parsing the Japanese seismic intensity scale takes engineering time. This Actor reads the official JMA feed directly, filters events by minimum magnitude, and returns each earthquake in one flat, consistent row. It handles the JMA's unique intensity scale and depth notation so you get clean, analysis-ready records.

| Who uses it | What they scrape JMA for |
|---|---|
| Seismology researchers | Building a historical catalog of Japan earthquake events for statistical analysis. |
| Disaster response teams | Monitoring recent seismic activity to assess aftershock patterns and deploy resources. |
| News aggregators | Pulling the latest earthquake bulletins to populate a breaking-news feed or map. |
| Insurance analysts | Correlating reported shaking intensity with claims data for a given region. |

### What it does

This Actor collects earthquake events from the Japan Meteorological Agency's public feed and returns each one as a flat row with hypocenter, magnitude, depth, and intensity.

- 📊 **Magnitude filter:** set a minimum magnitude threshold and only events at or above it reach your dataset.
- 🗾 **JMA intensity scale:** returns the Japanese shindo (震度) scale value, from 1 to 7, as published by the agency.
- 🌊 **Tsunami advisories:** captures any tsunami warning, advisory, or forecast text attached to the event.
- 📁 **Flat row output:** every earthquake is one row with hypocenter name, coordinates, depth, magnitude, and timestamp.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with JMA data

**📈 Build a Japan earthquake catalog.**

A seismology student sets a minimum magnitude of 3.0 and runs the Actor daily to accumulate a research dataset of all moderate and large events across Japan.

**🗺️ Populate a live hazard map.**

A newsroom developer runs the Actor every five minutes, pulling the latest events to display on a public-facing map with shindo intensity shading.

**📋 Filter for significant events only.**

An insurance analyst sets the minimum magnitude to 5.0 and exports a weekly CSV of strong earthquakes to cross-reference with policy exposure by prefecture.

**🌊 Monitor tsunami potential.**

A coastal municipality's safety officer scrapes all events and filters the output for any record where the tsunami advisory field is not empty, triggering an internal review.

### Why choose this scraper

|  | What you get |
|---|---|
| **Official JMA source** | Data comes straight from the Japan Meteorological Agency XML feed, the authoritative source for Japan seismic information. |
| **JMA intensity scale** | Returns the shindo (震度) scale value, which measures shaking at the surface, distinct from magnitude. |
| **No API registration** | Reads the public feed without requiring an application, OAuth token, or rate-limit negotiation. |
| **Structured output** | Every event is normalized into the same flat schema, ready for CSV, JSON, Excel, or XML export. |

### How it compares

No other Store actor targets JMA the same way, so the honest comparison is with the alternatives teams actually weigh.

| | JMA Japan Earthquake Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When JMA changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor by setting a minimum magnitude, and optionally cap the number of events returned. Filtering runs as each bulletin is read so only matching earthquakes reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10
}
```

A larger pull:

```json
{
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.0085 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.85 |
| 1,000 results | $8.50 |
| 10,000 results | $85.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [JMA Japan Earthquake Scraper](https://apify.com/parseforge/jma-japan-earthquake-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to JMA through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/jma-japan-earthquake-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your minimum magnitude setting. If it is set too high, the Actor may filter out all recent events. Try lowering it to 1.0 or removing the filter entirely to confirm the feed is reachable.

**Why do some earthquakes have a blank intensity field?**

JMA does not always assign a seismic intensity, especially for deep or offshore events where surface shaking is not measured. An empty intensity field means the bulletin did not include one.

**The depth value looks unusual or is zero.**

JMA sometimes reports very shallow events with a depth of 0 km or a descriptive term. The Actor passes the value through as published. Cross-reference the hypocenter name for context.

**I hit the free-user limit of 10 events.**

Upgrade to a paid Apify plan to raise the maxItems limit. Paid users can set the maximum up to 1,000,000 earthquakes per run.

### FAQ

| Question | Answer |
|---|---|
| What is the difference between magnitude and JMA seismic intensity? | Magnitude measures the energy released at the hypocenter. JMA seismic intensity (shindo, 震度) measures the shaking felt at a specific location on a scale from 0 to 7. This Actor returns both when the JMA bulletin includes them. |
| How often is the JMA feed updated? | The Japan Meteorological Agency updates its earthquake feed within minutes of an event. You can schedule this Actor to run as frequently as every minute on a paid Apify plan to catch new bulletins. |
| Does this Actor return historical earthquake data? | The JMA public feed focuses on recent events. For long-term historical catalogs, you would need to run the Actor regularly and accumulate the results in your own storage, or use a dedicated historical dataset. |
| What does the depth field look like? | Depth is returned in kilometers as published by JMA. Very shallow events may be reported with a depth of 0 km or a descriptive phrase, which the Actor passes through as-is. |
| Can I filter by region or prefecture? | The input schema currently supports filtering by minimum magnitude and maximum number of events. Region filtering is not built in, but you can apply it to the exported dataset using the hypocenter name field. |
| Is the tsunami advisory field always populated? | No. The tsunami field contains text only when JMA issues a warning, advisory, or forecast for that specific event. Most earthquakes will have an empty tsunami field. |
| What export formats are supported? | You can export your earthquake dataset to CSV, JSON, Excel, or XML from the Apify platform after the run completes. |
| Do I need an API key from JMA? | No. This Actor reads the public XML feed that JMA makes available without authentication. You do not need to register an application or manage tokens. |
| How many earthquakes can I scrape in one run? | Free Apify users are limited to 10 events per run as a preview. Paid users can set the maxItems input up to 1,000,000 events. |
| What is the hypocenter name field? | The hypocenter name is the JMA's label for the earthquake's origin location, such as a region name or a more specific geographic descriptor like 'Off the Coast of Iwate Prefecture'. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Japan Meteorological Agency. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `minMagnitude` (type: `number`):

Only include events at or above this magnitude.

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

Free users limited to 10 earthquakes (preview). Paid users optional, up to 1,000,000.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/jma-japan-earthquake-scraper").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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/jma-japan-earthquake-scraper").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 '{
  "maxItems": 10
}' |
apify call parseforge/jma-japan-earthquake-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/tYW8bIayWTvPvcThs/builds/kyqeJ6iLuUaXNGfjH/openapi.json