# USGS Earthquake Risk Analyzer - Free Seismic Activity API (`ntriqpro/usgs-earthquake-risk-analyzer`) Actor

Free API for real-time USGS earthquake monitoring and risk analysis. No subscription. Search by location and date for magnitude, depth, risk levels, seismic activity. Government data, pay-per-use.

- **URL**: https://apify.com/ntriqpro/usgs-earthquake-risk-analyzer.md
- **Developed by:** [daehwan kim](https://apify.com/ntriqpro) (community)
- **Categories:** AI, Business
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$100.00 / 1,000 charged when a job search or analysis is successfus

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Search, filter, and analyze job listings from four free job platforms in a single run — no API keys, no account setup, no rate limit headaches. Designed for job seekers who want aggregated results, developers building job boards or career tools, and researchers tracking hiring trends across the tech and remote work market.

### What does Job Aggregator do?

Job Aggregator queries Arbeitnow, Remotive, Jobicy, and The Muse simultaneously, then merges, deduplicates, and sorts the results into one clean dataset. Instead of manually checking multiple job boards or managing separate API integrations for each platform, you get a unified output with consistent field naming across all sources.

The actor supports three modes. Use `search_jobs` to find positions by keyword and location across all platforms at once. Use `remote_jobs` to surface remote-only listings with salary data where available, grouped by category. Use `job_trends` to analyze the job market itself — which skills are most in demand, which companies are hiring most actively, and how salary ranges and remote ratios break down by role type. All three modes are powered entirely by free public APIs that require no credentials.

#### Key features

- Aggregates results from four platforms in a single run: Arbeitnow, Remotive, Jobicy, and The Muse
- Automatic deduplication and date-sorted merging across sources
- Remote-only filtering with salary data where platforms provide it
- Job market trend analysis: in-demand skills, top hiring companies, salary ranges, remote vs. on-site breakdown
- Keyword and location filtering for targeted searches
- No API keys or platform accounts required
- Consistent output schema regardless of which source(s) returned results

### Use cases

- **Job seekers in tech and remote roles**: Search across multiple boards at once instead of visiting each site separately, and filter to remote-only positions with salary data upfront.
- **Developers building job boards or career apps**: Pull structured, deduplicated listings from multiple sources without negotiating individual platform API agreements or building your own scrapers.
- **Recruiters and hiring teams**: Monitor how many openings exist for a given role type, which companies are actively hiring for specific skills, and what salary ranges competitors are posting.
- **Labor market researchers**: Run `job_trends` mode to extract aggregate data on skill demand, remote work prevalence, and compensation patterns across industries and geographies.
- **Career coaches and educational content creators**: Identify which skills and certifications are most frequently appearing in job postings to advise students or produce relevant content.

### How to use Job Aggregator

1. **Configure input** — Choose a mode (`search_jobs`, `remote_jobs`, or `job_trends`), set a keyword and optional location, and adjust the result limit if needed.
2. **Run the actor** — Click "Start" in the Apify Console or trigger the run via API. The default mode (`remote_jobs`) works without any required configuration.
3. **Get structured results** — Download the unified JSON dataset, access results via the Apify API, or connect to your own pipeline or storage destination.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mode` | string (enum) | No | `remote_jobs` | Analysis mode: `search_jobs`, `remote_jobs`, `job_trends` |
| `keyword` | string | No | `software engineer` | Job title, skill, or search term to query across platforms |
| `location` | string | No | — | Location filter (city, country, or region). Leave empty for global results. |
| `remote` | boolean | No | `true` | When `true`, filters results to remote-only positions |
| `limit` | integer | No | `20` | Maximum number of job listings to return |

### Output example

```json
{
  "mode": "search_jobs",
  "keyword": "data engineer",
  "totalResults": 20,
  "jobs": [
    {
      "title": "Senior Data Engineer",
      "company": "Acme Corp",
      "location": "Remote",
      "remote": true,
      "salaryMin": 120000,
      "salaryMax": 160000,
      "salaryCurrency": "USD",
      "category": "Engineering",
      "tags": ["Python", "Spark", "AWS"],
      "url": "https://remotive.com/remote-jobs/data/senior-data-engineer-123",
      "source": "remotive",
      "postedAt": "2026-03-12T00:00:00Z"
    }
  ],
  "timestamp": "2026-03-14T12:00:00Z"
}
````

### Cost of usage

Pay-per-event at **$0.05 per search completion**.

| Usage | Approximate cost |
|-------|-----------------|
| 1 search | $0.05 |
| 100 searches | $5.00 |
| 1,000 searches | $50.00 |
| Daily monitoring (30 days) | $1.50 |

New Apify users get **$5 in free credits** — enough for 100 searches to test the actor against your use case.

### Data sources

- [Arbeitnow](https://www.arbeitnow.com) — International job board with strong European and remote coverage
- [Remotive](https://remotive.com) — Curated remote tech and knowledge-worker jobs
- [Jobicy](https://jobicy.com) — Remote jobs with salary data included for many listings
- [The Muse](https://www.themuse.com) — US-focused company profiles and job listings

All four APIs are free and require no API key or account.

### Related actors

- [Online Course Finder](https://apify.com/ntriqpro/online-course-finder) — Find courses and certifications for skills appearing in job postings
- [Stock Market Scanner](https://apify.com/ntriqpro/stock-market-scanner) — Track publicly traded companies that are actively hiring to surface investment signals

### FAQ

#### Is an API key required?

No. All four data sources — Arbeitnow, Remotive, Jobicy, and The Muse — offer free public APIs that do not require authentication. The actor works out of the box with no credential configuration.

#### How does deduplication work?

The actor identifies duplicate listings by comparing job title, company name, and posting URL across sources. When a match is found, the listing from the source with the most complete data (e.g., salary information) is kept.

#### Can I search for jobs in a specific country or city?

Yes. Set the `location` parameter to a city, country, or region name. Not all platforms support location filtering equally — Arbeitnow and The Muse have the most granular location support, while Remotive and Jobicy focus primarily on remote roles without location constraints.

#### Does the `job_trends` mode return individual job listings?

No. The `job_trends` mode returns aggregate statistics: top skills by frequency, most active hiring companies, salary range distributions, and remote vs. on-site ratios. It does not return individual job listings.

#### How fresh is the data?

Each run fetches live data directly from the source APIs at the time of execution. Results reflect listings active on those platforms at the moment the actor runs. There is no internal cache or static dataset.

### Limitations

- Salary data is only available for listings where the originating platform includes it — Jobicy provides the most consistent salary coverage
- Location filtering precision varies by platform; broad searches (e.g., country-level) return more reliable results than city-level filtering
- The `limit` parameter caps total results across all sources combined, so very low limits may under-represent some platforms
- Job market data reflects only the four integrated platforms and should not be treated as a complete picture of the broader job market

# Actor input Schema

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

Select the type of job search to perform

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

Job title or skill to search for (e.g., 'software engineer', 'data scientist', 'python')

## `location` (type: `string`):

Preferred location filter (e.g., 'United States', 'Remote', 'Europe'). Leave empty for worldwide.

## `remote` (type: `boolean`):

Filter for remote positions only

## `limit` (type: `integer`):

Maximum number of job listings to return

## Actor input object example

```json
{
  "mode": "remote_jobs",
  "keyword": "software engineer",
  "remote": true,
  "limit": 20
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("ntriqpro/usgs-earthquake-risk-analyzer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("ntriqpro/usgs-earthquake-risk-analyzer").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call ntriqpro/usgs-earthquake-risk-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ntriqpro/usgs-earthquake-risk-analyzer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USGS Earthquake Risk Analyzer - Free Seismic Activity API",
        "description": "Free API for real-time USGS earthquake monitoring and risk analysis. No subscription. Search by location and date for magnitude, depth, risk levels, seismic activity. Government data, pay-per-use.",
        "version": "1.0",
        "x-build-id": "XjvO5RC4fPsb6hRgK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ntriqpro~usgs-earthquake-risk-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ntriqpro-usgs-earthquake-risk-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ntriqpro~usgs-earthquake-risk-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-ntriqpro-usgs-earthquake-risk-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ntriqpro~usgs-earthquake-risk-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-ntriqpro-usgs-earthquake-risk-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Search Mode",
                        "enum": [
                            "search_jobs",
                            "remote_jobs",
                            "job_trends"
                        ],
                        "type": "string",
                        "description": "Select the type of job search to perform",
                        "default": "remote_jobs"
                    },
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Job title or skill to search for (e.g., 'software engineer', 'data scientist', 'python')",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Preferred location filter (e.g., 'United States', 'Remote', 'Europe'). Leave empty for worldwide."
                    },
                    "remote": {
                        "title": "Remote Only",
                        "type": "boolean",
                        "description": "Filter for remote positions only",
                        "default": true
                    },
                    "limit": {
                        "title": "Results Limit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of job listings to return",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
