# Amazon Jobs Scraper: Open Roles & Pay Ranges by Location (`precious_bathmat/amazon-jobs-scraper`) Actor

Scrape Amazon and AWS jobs from amazon.jobs: title, team, job family, category, every location, posted date, qualifications, plus the pay range Amazon lists for each location. A hiring and pay report per search. No login, no API key.

- **URL**: https://apify.com/precious_bathmat/amazon-jobs-scraper.md
- **Developed by:** [Mariam Ahmed](https://apify.com/precious_bathmat) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 jobs

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon Jobs Scraper: Open Roles & Pay Ranges by Location

Scrape **Amazon and AWS jobs from amazon.jobs** with no login and no API key, with the **pay range Amazon lists for each location**, and get a **hiring and pay report for every search**:

- **Every job**: title, team, job family, category, business area, location and every other location, schedule, posted date, summary, full description, basic and preferred qualifications, link
- **Pay ranges as numbers**: Amazon prints a range per location on most US and Canadian jobs (for example "Seattle, WA - $142,800 to $193,200 a year" or "$26 to $28 an hour"); you get each range plus the lowest and highest
- **Filters**: countries, cities, the 37 Amazon job categories, internships, seasonal or part-time jobs, posted within N days
- **No 10,000 limit**: amazon.jobs stops paging at 10,000 matches, so bigger searches are read country by country, then by category
- **Report per search**: open roles by country, city, category and business area, top job families and teams, yearly and hourly pay (median and middle half), pay by location and by job family, freshness, highest-paid roles

### What does this Amazon jobs scraper do?

```
Amazon · "software development engineer" · 1,740 open roles
 United States 1,186 · India 244 · Canada 118 · Ireland 46
 Pay shown on 77% of jobs · median $169,050 a year (US)
 By city: Santa Clara $194,400 · New York $185,950 · Seattle $169,050
```

1. Enter **keywords** (or leave empty for every Amazon job) and, optionally, **countries**, **cities** or **job categories**.
2. Keep **pay ranges** on to open each job page and read its pay table.
3. You get **one row per job** and **one report per keyword**.

```mermaid
flowchart LR
    A[Keywords,<br/>countries, cities,<br/>categories] --> B[amazon.jobs<br/>search]
    B --> C[Jobs<br/>team, family,<br/>locations]
    C --> D[Job pages<br/>pay range<br/>per location]
    D --> E[Report<br/>roles by country,<br/>pay by city<br/>and job family]
```

### Who is it for?

- **Job seekers and candidates**: what Amazon pays for a role in each city before you negotiate
- **Recruiters and talent teams at other companies**: where Amazon is hiring, for which teams, and the pay you compete with
- **HR and compensation analysts**: salary benchmarks from Amazon's own published ranges by role, family and location
- **Market and investment analysts**: Amazon and AWS hiring by country, business area and category, tracked over time
- **Career coaches and job boards**: fresh Amazon roles with pay for your audience

### What data do you get?

**Jobs** (dataset, one row per job)

| Field | What it tells you |
|---|---|
| `id`, `title`, `url`, `applyUrl` | The job and where to apply |
| `company`, `businessArea`, `team`, `category`, `jobFamily` | Which Amazon company, business and team, and the kind of job |
| `location`, `city`, `state`, `country`, `countryCode` | The main location |
| `locationCount`, `otherLocations`, `isRemote` | Every other location the job can be done in |
| `payMin`, `payMax`, `payCurrency`, `payPeriod` | Lowest and highest pay across the listed locations, per year or per hour |
| `payRanges` | Each location's own range: `{ location, min, max, currency, period }` |
| `schedule`, `postedAt`, `updated` | Full-time or not, when posted, last update |
| `summary`, `description`, `basicQualifications`, `preferredQualifications` | The ad itself |

**Report** (`REPORTS`, one per keyword)

| Field | What it tells you |
|---|---|
| `totalOnAmazonJobs`, `jobsRead` | Every open role that matches, and how many were read |
| `openRolesByCountry`, `openRolesByCity`, `openRolesByCategory`, `openRolesByBusinessArea` | Counts over every match on amazon.jobs |
| `topJobFamilies`, `topTeams`, `topLocations` | Among the jobs read |
| `payShownPercent`, `yearlyPay`, `hourlyPayUsd` | Pay median and middle half (yearly per currency, hourly in USD) |
| `yearlyPayByLocation`, `yearlyPayByJobFamily` | Median pay per city and per job family |
| `remotePercent`, `multiLocationPercent`, `freshness`, `highestPaid` | Remote share, multi-location jobs, how new, best-paid roles |

### Example: 17 October 2026

Three keywords, 500 jobs each, pay ranges on: **1,500 jobs, 3 reports, 174 seconds, no failed requests**.

| Keyword | Open roles | Pay shown | Median pay (US) | Middle half |
|---|---|---|---|---|
| Software development engineer | 1,740 | 77% | $169,050 a year | $169,050 – $194,400 |
| Data engineer | 729 | 55% | $153,350 a year | $138,400 – $160,700 |
| Warehouse | 1,190 | 44% | $27.00 an hour | $22.31 – $27.00 |

- **About 95% of US jobs show a pay range**; most jobs outside the US, Canada and a few EU countries show none.
- **Every Amazon job**, with no keyword: **22,119 open roles** (US 13,174, India 2,319, UK 783, Japan 767, Germany 678). A run reading 12,000 of them took 100 seconds.

### Pricing

**$0.001 per job**, **$0.001 per job with a pay range** (only jobs that show one) and **$0.02 per search report**.

- 500 US software jobs with pay and a report: about **$1.00**
- 1,000 jobs without pay ranges and without a report: **$1.00**

Turn off pay ranges or reports to pay for jobs only.

### Good to know

- **Pay ranges** are copied from Amazon's job pages. Jobs that list several cities have one range per city; `payMin` and `payMax` span them. Sign-on bonuses and stock are not included (Amazon does not print them).
- **Keywords** use amazon.jobs' own search, which also matches related words (a "warehouse" search finds some corporate roles too); use **categories** to narrow.
- **Cities** must be written as Amazon writes them ("Seattle", "Bengaluru", "London").
- **Job categories**: five of them (Applied Science, Corporate Operations, Fulfillment Associate, Procurement, PR) cannot be filtered on amazon.jobs, so they are matched after reading.
- **No contact details**: emails in ad text are hidden.
- Data comes from **amazon.jobs' public job search**. **Not affiliated with Amazon.**

### Input

| Field | Meaning |
|---|---|
| **Keywords** | One search each; empty = every Amazon job |
| **Countries** | Names or codes ("Germany", "DE", "IND") |
| **Cities** | As Amazon writes them |
| **Job categories** | Any of Amazon's 37 |
| **Job type** | Full-time, internship, seasonal, fixed-term (EU), reduced or part time, apprenticeship |
| **Posted within (days)** | Only newer jobs |
| **Sort** | Newest first or most relevant |
| **Jobs per search** | 1 to 30,000 (default 200) |
| **Pay ranges** | On by default |
| **Reports** | On by default |

### Integrations

Export to JSON, CSV, Excel or Google Sheets, or connect through the Apify API, webhooks, Make, Zapier and n8n. **Schedule it daily** with "Posted within 1 day" for a feed of new Amazon jobs with pay.

# Actor input Schema

## `keywords` (type: `array`):

Job titles or skills, one search each, e.g. "software development engineer", "data engineer", "warehouse associate". Empty = every Amazon job (with the filters below).

## `countries` (type: `array`):

Optional countries, by name or code, e.g. "United States", "Germany", "IN". Empty = every country.

## `cities` (type: `array`):

Optional cities exactly as Amazon writes them, e.g. "Seattle", "Bengaluru", "London".

## `categories` (type: `array`):

Optional: only these Amazon job categories.

## `employeeClasses` (type: `array`):

Optional: only these job types.

## `postedWithinDays` (type: `integer`):

Only jobs posted in the last N days. Empty = any time.

## `sort` (type: `string`):

Which jobs are read first when a search has more than the maximum.

## `maxJobsPerSearch` (type: `integer`):

Most jobs to read per keyword (1 to 30,000). Searches past 10,000 are read country by country.

## `includePayRanges` (type: `boolean`):

Open each job page and read the pay range Amazon lists per location (yearly or hourly). Charged only for jobs that show one.

## `includeReports` (type: `boolean`):

One report per keyword: open roles by country, city, category and business area, top job families and teams, yearly and hourly pay, pay by location and job family, freshness, highest-paid roles.

## Actor input object example

```json
{
  "keywords": [
    "software development engineer"
  ],
  "countries": [
    "United States"
  ],
  "sort": "date",
  "maxJobsPerSearch": 200,
  "includePayRanges": true,
  "includeReports": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

One row per job: title, team, job family, category, location and other locations, posted date, qualifications, description, pay range per location, link.

## `reports` (type: `string`):

Per keyword: open roles by country, city, category and business area, pay by location and job family, freshness, highest-paid roles.

## `reportsCsv` (type: `string`):

One flat row per keyword.

## `summary` (type: `string`):

Requests, problems and the limits of the data.

# 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 = {
    "keywords": [
        "software development engineer"
    ],
    "countries": [
        "United States"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("precious_bathmat/amazon-jobs-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 = {
    "keywords": ["software development engineer"],
    "countries": ["United States"],
}

# Run the Actor and wait for it to finish
run = client.actor("precious_bathmat/amazon-jobs-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 '{
  "keywords": [
    "software development engineer"
  ],
  "countries": [
    "United States"
  ]
}' |
apify call precious_bathmat/amazon-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,precious_bathmat/amazon-jobs-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/r67SuXST2nfprGhSc/builds/Eploffsl3BLQsuNrD/openapi.json