# Amazon Careers Openings Explorer: Pay Ranges, Locations & Teams (`xyrelith-data/amazon-jobs-scraper`) Actor

Scrape every open Amazon, AWS, Twitch and subsidiary role from amazon.jobs. Filter by country, state, city, category, business unit, team, schedule and age, with full descriptions, qualifications, every location and published pay ranges.

- **URL**: https://apify.com/xyrelith-data/amazon-jobs-scraper.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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 Careers Openings Explorer: Pay Ranges, Locations & Teams

Every open Amazon, AWS, Twitch, Zoox, Annapurna and subsidiary role on **amazon.jobs**, read from the site's public search data and job pages. No login, no cookies, no API key and no browser.

This actor is built for hiring-market research, recruiting intelligence and compensation benchmarking. It returns the full job record, all locations with coordinates and workplace type, the qualifications as lists, and the pay range Amazon publishes for each location.

### What it does

- **Two modes:** search the live index, or fetch exact jobs by numeric ID / URL.
- **Deep filters:** countries, states, cities, a radius around a place, Amazon's 37 job categories, 61 business units, team labels, schedule type, employee class, manager-only, intern-only and virtual-only.
- **Pay ranges per location:** reads each job page and turns Amazon's printed pay lines into numbers (`min`, `max`, `currency`, `period`) plus a job-level summary.
- **All locations:** every city the role can be done in, with normalized names, coordinates, onsite/virtual type and building codes.
- **Facet counts and a run report:** optional `recordType=facet` and `recordType=report` records for dashboards.
- **New-only monitoring:** remembers delivered job IDs in a named key-value store, so a daily schedule only emits jobs it has not seen.
- **Past the 10,000-result wall:** a single Amazon.jobs query returns at most 10,000 results, so large pulls are split automatically by category, then country, then business unit and state, and deduplicated by job ID.

### Modes

#### `search` (default)

Runs one Amazon.jobs search per keyword, applies the filters server-side, reads the pages, and emits one record per job. Leave `keywords` empty to scan every open job that matches the filters.

#### `jobDetails`

Fetches exact jobs by numeric Amazon job ID or by an `amazon.jobs` job URL. Each record includes the full description, qualifications and pay ranges even when the search index no longer returns the job.

```json
{
  "mode": "jobDetails",
  "jobIds": [
    "10573768",
    "https://www.amazon.jobs/en/jobs/10544235/senior-software-engineer-graviton-software"
  ]
}
```

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `mode` | select | `search` | `search` or `jobDetails`. |
| `keywords` | string list | `["software engineer"]` | One Amazon.jobs search per keyword. Empty = every job matching the filters. |
| `jobIds` | string list | `[]` | Numeric IDs or job URLs (mode=`jobDetails`). |
| `countries` | multi-select | `[]` | ISO3 country codes. 59 countries with open roles. Empty = worldwide. |
| `states` | string list | `[]` | Normalized state/region names exactly as Amazon writes them (`Washington`, `Bavaria`, `Karnataka`). |
| `cities` | string list | `[]` | City names exactly as Amazon writes them (`Seattle`, `Bengaluru`, `London`). |
| `locationQuery` | text | `""` | Place name for a radius search (`Seattle`, `Berlin`, `San Francisco, CA`). |
| `radiusKm` | integer | `50` | Radius around `locationQuery`, 1-500 km. |
| `jobCategories` | multi-select | `[]` | Amazon's 37 job categories. Empty = all. |
| `businessCategories` | multi-select | `[]` | Amazon's 61 business units (`aws`, `retail`, `advertising`, `devices`, `subsidiaries`, …). |
| `teams` | string list | `[]` | Amazon team labels (`aws.team-sde-primary`, `operations.team-infrastructure`, …). |
| `scheduleType` | select | `any` | `any`, `full-time`, `part-time` (all part-time variants), `reduced-time`, `flex-time`. |
| `employeeClasses` | multi-select | `[]` | Regular full-time, regular reduced/part-time, intern, seasonal, apprentice, fixed-term contractor, temporary. |
| `managerOnly` | boolean | `false` | Only people-manager roles (`is_manager=1`). |
| `internOnly` | boolean | `false` | Only internships (`is_intern=1`). |
| `workFromHomeOnly` | boolean | `false` | Only virtual-location jobs. |
| `postedWithinDays` | integer | – | Drop jobs posted more than N days ago (client-side, 1-365). |
| `sort` | select | `recent` | `recent` or `relevant`. |
| `language` | select | `en` | Amazon.jobs locale: `en`, `de`, `fr`, `it`, `es`, `pt`, `zh`, `pl`. |
| `includeDetails` | boolean | `true` | Read job pages for pay ranges. One extra request per job. |
| `onlyWithSalary` | boolean | `false` | Keep only jobs that print a pay range. Forces job-page reads. |
| `includeFacets` | boolean | `false` | Emit one `recordType=facet` record per facet group. |
| `includeReport` | boolean | `false` | Emit one `recordType=report` summary per keyword. |
| `onlyNewJobs` | boolean | `false` | Skip job IDs delivered by earlier runs with the same search and filters. |
| `stateKey` | text | `""` | Optional name to share one seen-jobs memory across schedules. |
| `maxItems` | integer | `100` | Hard cap on job records (1-30,000). Facets/reports do not count. |
| `maxItemsPerKeyword` | integer | `0` | Optional cap per keyword (0 = no per-keyword cap). |

### Output

One record per job with `recordType: "job"`. Empty values are omitted, never `null`.

| Field | Description |
|---|---|
| `jobId` | Public Amazon job ID (e.g. `10605142`). |
| `internalRequisitionId` | Internal search-record UUID. |
| `title`, `companyName` | Job title and hiring legal entity. |
| `businessCategory`, `businessCategoryName` | Business-unit slug and human-readable name. |
| `team`, `teamLabels`, `primarySearchLabel` | Team label and the team tags Amazon attaches to the job. |
| `jobCategory`, `jobFamily`, `jobFunctionId` | Amazon category taxonomy. |
| `scheduleType`, `isManager`, `isIntern` | Schedule and role flags when Amazon provides them. |
| `city`, `state`, `countryCode`, `country` | Primary location. `countryCode` is ISO3. |
| `location`, `normalizedLocation` | Primary location as printed and normalized. |
| `locations[]` | Every location: `display`, `normalized`, `city`, `state`, `countryCode`, `country`, `latitude`, `longitude`, `type` (`ONSITE`/`VIRTUAL`), `buildingCodes[]`. |
| `locationType`, `workplaceType`, `isRemote` | Primary location type (`ONSITE`/`VIRTUAL`), plus `onsite`/`remote`/`hybrid` and a remote flag derived only from Amazon's own location types. |
| `postedDate`, `updatedTime` | ISO posting date and Amazon's relative update text. |
| `descriptionShort`, `description` | Cleaned plain-text summaries. |
| `basicQualifications[]`, `preferredQualifications[]` | Bullet lists; boilerplate is removed. |
| `salaryRanges[]` | Per-location pay: `location`, `min`, `max`, `currency`, `period`. |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Job-level summary when all ranges share one currency and period. |
| `salaryCurrencies[]` | Present instead of the summary when a job mixes currencies. |
| `salaryRangeCount` | Number of parsed pay lines. |
| `jobUrl`, `applyUrl` | Public job page and application link. |
| `keyword`, `siteLanguage`, `scrapedAt` | Search traceability. |

#### Facet records

When `includeFacets` is on, the dataset also contains records like:

```json
{
  "recordType": "facet",
  "facet": "countries",
  "values": [{"value": "USA", "count": 12275}, {"value": "IND", "count": 2085}],
  "keyword": "software engineer",
  "siteLanguage": "en"
}
```

Groups: `countries`, `states`, `cities`, `locations`, `jobCategories`, `businessCategories`, `scheduleTypes`, `employeeClasses`, `jobFunctions`, `manager`, `intern`.

#### Report records

When `includeReport` is on, one `recordType: "report"` record per keyword contains the source total, jobs emitted, pay coverage, counts by country/city/category/business unit/schedule, median pay by currency and top pay locations.

### Pay ranges

Amazon prints pay lines on most US and Canadian jobs and on some European postings. Examples handled:

```
USA, CA, SAN FRANCISCO - 127,100.00 - 185,000.00 USD annually
CAN, ON, Toronto - 141,900.00 - 236,900.00 CAD annually
Rovigo, ITA - 64,800.00 EUR Annually
Okmiany, POL - 15,541.67 PLN monthly
```

The actor parses each line into `salaryRanges`, then computes `salaryMin`/`salaryMax` when every range shares a currency and period. A job with no printed pay line simply has no salary fields. Pay is never estimated.

### Limits and honest notes

- **10,000-result wall.** Amazon.jobs returns at most 10,000 results for one query and rejects offsets at or above 10,000. The actor detects the cap and splits by category, then country, then business unit, then state. Very broad pulls can still require narrower filters; the run summary reports when the cap was hit.
- **Pay is only what Amazon prints.** US and Canadian roles usually show a range; many roles outside those markets do not. `onlyWithSalary` drops the rest.
- **Manager/intern output flags.** Amazon's search feed currently returns `is_manager` and `is_intern` as null on job records even though the server-side filters work. The filters are honoured, and the flags appear in output only when Amazon provides them.
- **Posted-date filter is client-side.** Amazon.jobs has no server-side date parameter, so `postedWithinDays` is applied after the search. With `sort=recent` the actor stops early once a page is older than the cutoff.
- **Locale, not translation.** `language` changes the Amazon.jobs locale used for search and job pages. Job text stays exactly as Amazon publishes it.
- **Location radius.** `locationQuery` is resolved through Amazon.jobs' public location service. If that service cannot resolve the place, the actor falls back to an exact city/state/country match from Amazon's own facet values.
- **New-only state.** `onlyNewJobs` uses the named key-value store `amazon-jobs-seen`. It is per Apify account and persists across runs. Use `stateKey` to share one memory across schedules.

### Examples

#### Software roles in the US and India, with pay

```json
{
  "mode": "search",
  "keywords": ["software development engineer"],
  "countries": ["USA", "IND"],
  "jobCategories": ["Software Development"],
  "sort": "recent",
  "includeDetails": true,
  "maxItems": 200
}
```

#### Remote manager roles, facets and a report

```json
{
  "mode": "search",
  "keywords": ["manager"],
  "workFromHomeOnly": true,
  "managerOnly": true,
  "includeDetails": true,
  "includeFacets": true,
  "includeReport": true,
  "maxItems": 100
}
```

#### Daily new-job feed

```json
{
  "mode": "search",
  "keywords": ["data engineer"],
  "countries": ["USA"],
  "postedWithinDays": 2,
  "sort": "recent",
  "onlyNewJobs": true,
  "stateKey": "data-engineer-us",
  "maxItems": 50
}
```

### Data source and scope

Amazon.jobs is Amazon's public careers site. This actor reads the same public search data and job pages a visitor sees. It does not log in, does not use candidate data, and is not affiliated with Amazon. Review Amazon.jobs' terms and your local data rules before using the output commercially.

### FAQ

**Do I need a proxy?** No. The public endpoints work from Apify's datacenter network without a proxy.

**Why did I get fewer jobs than `maxItems`?** The search may have fewer matches than requested, the filters may be narrow, or the 10,000-result wall was hit. Check the run summary and the status message.

**Why do some jobs have no salary?** Amazon did not print a pay range on that job page. The actor never guesses pay.

**Can I get jobs from a specific city?** Yes. Use `cities` with Amazon's spelling (`Seattle`, not `seattle, wa`), or use `locationQuery` with `radiusKm`.

**Can I scrape only new jobs each day?** Yes. Turn on `onlyNewJobs` and schedule the actor. The first run delivers the current matches; later runs skip IDs already delivered with the same search and filters.

# Actor input Schema

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

Search the live Amazon.jobs index, or fetch exact jobs by numeric ID / URL.

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

One Amazon.jobs search per keyword (title and description text). Leave empty to scan every open job that matches the filters below.

## `jobIds` (type: `array`):

Amazon numeric job IDs or amazon.jobs job URLs (mode=jobDetails). Examples: 10573768 or https://www.amazon.jobs/en/jobs/10573768/software-engineer-i.

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

Keep jobs in these countries (ISO3). Leave empty for all countries.

## `states` (type: `array`):

Keep jobs in these normalized state or region names, exactly as Amazon writes them (e.g. Washington, Bavaria, Karnataka, Ontario). Leave empty for all states.

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

Keep jobs in these city names, exactly as Amazon writes them (e.g. Seattle, Bengaluru, London). Leave empty for all cities.

## `locationQuery` (type: `string`):

A city or place name used for a radius search, e.g. Seattle, Berlin or San Francisco, CA. Resolved to coordinates through Amazon.jobs' public location service; falls back to exact city/state/country matching.

## `radiusKm` (type: `integer`):

Radius around locationQuery, in kilometres. Ignored when locationQuery is empty.

## `jobCategories` (type: `array`):

Keep jobs in these Amazon job categories. Amazon's 37 categories. Leave empty for all categories.

## `businessCategories` (type: `array`):

Keep jobs in these Amazon business units (AWS, retail, advertising, devices, subsidiaries and more).

## `teams` (type: `array`):

Keep jobs tagged with these Amazon team labels (optional_search_labels), e.g. aws.team-sde-primary or operations.team-infrastructure. Leave empty for all teams.

## `scheduleType` (type: `string`):

Amazon schedule type. Part-time includes part-time, reduced-time and flex-time variants.

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

Keep jobs in these employee classes. Regular full-time groups both Amazon spellings.

## `managerOnly` (type: `boolean`):

Only jobs Amazon marks as people-manager roles (is_manager=1).

## `internOnly` (type: `boolean`):

Only jobs Amazon marks as internships (is_intern=1).

## `workFromHomeOnly` (type: `boolean`):

Only jobs with Amazon's virtual-location flag.

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

Drop jobs posted more than this many days ago. Applied after the search because Amazon.jobs has no server-side date parameter. Leave empty for any age.

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

Order jobs are read from Amazon.jobs.

## `language` (type: `string`):

Amazon.jobs site locale used for search and job pages. Job text itself is kept exactly as Amazon publishes it.

## `includeDetails` (type: `boolean`):

Open each job page to read the published pay range per location. Adds one request per job; turn it off for very large runs without salary data.

## `onlyWithSalary` (type: `boolean`):

Keep only jobs whose job page prints a pay range. Forces job-page reads.

## `includeFacets` (type: `boolean`):

Write one recordType=facet record per facet group (countries, states, cities, categories, business units, schedules and more).

## `includeReport` (type: `boolean`):

Write one recordType=report summary per keyword with counts, pay coverage and median pay by currency and location.

## `onlyNewJobs` (type: `boolean`):

Remember delivered job IDs in the key-value store and skip jobs seen on previous runs with the same search and filters. Ideal for daily schedules.

## `stateKey` (type: `string`):

Optional name to share one seen-jobs memory across schedules or keywords. Leave empty to derive a key from the search and filters.

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

Hard cap on emitted job records. Facet and report records do not count toward this cap. Searches over 10,000 results are split automatically by category, country and business unit.

## `maxItemsPerKeyword` (type: `integer`):

Optional cap for each keyword in a multi-keyword search (0 = no per-keyword cap). The overall Max items cap still applies.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "software engineer"
  ],
  "jobIds": [],
  "countries": [
    "USA"
  ],
  "states": [],
  "cities": [],
  "locationQuery": "",
  "radiusKm": 50,
  "jobCategories": [],
  "businessCategories": [],
  "teams": [],
  "scheduleType": "any",
  "employeeClasses": [],
  "managerOnly": false,
  "internOnly": false,
  "workFromHomeOnly": false,
  "sort": "recent",
  "language": "en",
  "includeDetails": false,
  "onlyWithSalary": false,
  "includeFacets": false,
  "includeReport": false,
  "onlyNewJobs": false,
  "stateKey": "",
  "maxItems": 2,
  "maxItemsPerKeyword": 0
}
```

# Actor output Schema

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

Dataset containing Amazon.jobs postings, optional facet counts and optional run reports.

# 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": "search",
    "keywords": [
        "software engineer"
    ],
    "jobIds": [],
    "countries": [
        "USA"
    ],
    "states": [],
    "cities": [],
    "locationQuery": "",
    "radiusKm": 50,
    "jobCategories": [],
    "businessCategories": [],
    "teams": [],
    "scheduleType": "any",
    "employeeClasses": [],
    "managerOnly": false,
    "internOnly": false,
    "workFromHomeOnly": false,
    "sort": "recent",
    "language": "en",
    "includeDetails": false,
    "onlyWithSalary": false,
    "includeFacets": false,
    "includeReport": false,
    "onlyNewJobs": false,
    "stateKey": "",
    "maxItems": 2,
    "maxItemsPerKeyword": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/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 = {
    "mode": "search",
    "keywords": ["software engineer"],
    "jobIds": [],
    "countries": ["USA"],
    "states": [],
    "cities": [],
    "locationQuery": "",
    "radiusKm": 50,
    "jobCategories": [],
    "businessCategories": [],
    "teams": [],
    "scheduleType": "any",
    "employeeClasses": [],
    "managerOnly": False,
    "internOnly": False,
    "workFromHomeOnly": False,
    "sort": "recent",
    "language": "en",
    "includeDetails": False,
    "onlyWithSalary": False,
    "includeFacets": False,
    "includeReport": False,
    "onlyNewJobs": False,
    "stateKey": "",
    "maxItems": 2,
    "maxItemsPerKeyword": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/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 '{
  "mode": "search",
  "keywords": [
    "software engineer"
  ],
  "jobIds": [],
  "countries": [
    "USA"
  ],
  "states": [],
  "cities": [],
  "locationQuery": "",
  "radiusKm": 50,
  "jobCategories": [],
  "businessCategories": [],
  "teams": [],
  "scheduleType": "any",
  "employeeClasses": [],
  "managerOnly": false,
  "internOnly": false,
  "workFromHomeOnly": false,
  "sort": "recent",
  "language": "en",
  "includeDetails": false,
  "onlyWithSalary": false,
  "includeFacets": false,
  "includeReport": false,
  "onlyNewJobs": false,
  "stateKey": "",
  "maxItems": 2,
  "maxItemsPerKeyword": 0
}' |
apify call xyrelith-data/amazon-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xyrelith-data/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/yeCaxRkHeOeM2Wy57/builds/6b3cdixN8wGlUvQU3/openapi.json
