# Amazon Jobs Scraper (`solidcode/amazon-jobs-scraper`) Actor

\[💰 $0.01 / 1K] Extract job postings from Amazon's official careers site (amazon.jobs). Search by keyword and location, filter by category, job type, and country, or paste ready-made search URLs. Get titles, locations, qualifications, categories, teams, posting dates, and apply links.

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

## Pricing

from $0.01 / 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/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

## Amazon Jobs Scraper

Pull job postings from Amazon's official careers site (amazon.jobs) at scale — titles, locations, categories, teams, employment types, both basic and preferred qualification blocks, posting dates, and direct apply links for every open role worldwide. Built for recruiters, talent-intelligence teams, and labor-market researchers who need structured Amazon hiring data without copy-pasting listings off the careers site one page at a time.

### Why This Scraper?

- **20 countries in one filter** — target the United States, United Kingdom, Germany, India, Japan, Canada, Brazil, the UAE and 12 more by country, or leave it blank for worldwide coverage in a single run.
- **38 job categories, matched to Amazon's own taxonomy** — narrow to Software Development, Applied Science, Machine Learning Science, Data Science, Supply Chain / Transportation Management, Fulfillment Associate, and 32 more exactly as Amazon labels them, so a category filter returns real hits instead of silent zeros.
- **Six employment-schedule types** — Full-time, Part-time, Part-time (20-29 hours), Reduced-time (30-39 hours), Flex time, and Flex-time (under 19 hours) — the same schedule facets Amazon exposes on its own search.
- **Both qualification blocks on every job** — separate `basicQualifications` and `preferredQualifications` fields, so you can screen must-haves against nice-to-haves without parsing one description blob.
- **22 structured fields per posting** — job title, two job IDs, apply and job-page links, city/state/country, category, job family, team, business category, schedule type, qualifications, full description and short summary, posted and updated dates — all flat and spreadsheet-ready.
- **Team and business-category taxonomy** — every row carries Amazon's internal `team` and `businessCategory` labels (e.g. AWS, Alexa, Operations), so you can slice hiring by org, not just by title.
- **Sort by relevance or newest first** — flip `sortBy` to `recent` to monitor brand-new postings on a schedule, or keep `relevant` for the best keyword matches.
- **Ready-made-URL power mode** — paste any amazon.jobs search URL you built on the site (filters already applied) and the scraper paginates it to completion, running searches the structured fields don't cover.
- **Up to 10,000 results per search** — walks Amazon's full result window with automatic pagination and per-job deduplication; narrow with a category, country, or keyword to reach deeper into large result sets.

### Use Cases

**Talent Intelligence**
- Track how many roles Amazon is opening by category, country, and team
- Watch a specific org (AWS, Alexa, Operations) ramp or slow its hiring
- Map the mix of full-time versus flex and reduced-time roles across markets
- Build a live snapshot of Amazon's open headcount for briefings

**Recruitment & Sourcing**
- Pull apply-ready role lists with direct links for a target city or country
- Benchmark your own job specs against Amazon's basic and preferred qualifications
- Identify high-volume categories worth building candidate pipelines around
- Feed structured postings straight into an ATS or sourcing spreadsheet

**Labor-Market Research**
- Measure demand for skills like machine learning, data science, or supply chain
- Compare category mix across 20 countries in a single dataset
- Track how quickly new postings appear with `sortBy: recent`
- Quantify part-time, flex, and reduced-time offerings by region

**Relocation & Geographic Analysis**
- List every open role in an exact city (Seattle, Berlin, Bengaluru)
- Compare opportunity volume between candidate cities and countries
- Surface roles by country for cross-border hiring and mobility planning
- Map where a job family (e.g. Software Development) is concentrated

**Competitive Hiring Intelligence**
- Read team growth signals from category and business-category trends
- Track qualification bars Amazon sets for comparable roles
- Monitor which markets Amazon is expanding into by watching new country coverage
- Enrich a competitor-tracking dashboard with fresh Amazon postings

### Getting Started

#### Newest software roles

The simplest start — a keyword and a result cap:

```json
{
    "searchKeyword": "software engineer",
    "maxResults": 100
}
````

#### Data-science roles in the US, newest first

```json
{
    "searchKeyword": "data scientist",
    "countries": ["USA"],
    "categories": ["Data Science"],
    "sortBy": "recent",
    "maxResults": 300
}
```

#### Full-time roles in an exact city

```json
{
    "location": "Bengaluru",
    "jobTypes": ["Full-Time"],
    "categories": ["Software Development"],
    "maxResults": 200
}
```

#### Advanced — paste your own search URLs

```json
{
    "searchUrls": [
        "https://www.amazon.jobs/en/search?base_query=machine+learning&normalized_country_code%5B%5D=USA&sort=recent",
        "https://www.amazon.jobs/en/search?category%5B%5D=Applied+Science&sort=relevant"
    ],
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchKeyword` | string | `"software engineer"` | Word or phrase matched across the job title and description. Leave blank to collect every job matching the filters below. |
| `location` | string | `""` (any) | Filter to a single city. This is an exact match against Amazon's own city name, so spell it as Amazon does — "Bengaluru" returns results, "Bangalore" returns none. |
| `searchUrls` | string\[] | `[]` | Advanced: paste one or more full amazon.jobs search URLs (filters already applied on the site). Each runs as its own search and is paginated to completion, in addition to the keyword search. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `categories` | array (multi-select) | `[]` (all) | Keep only jobs in these Amazon job categories. 38 categories available, matched to Amazon's exact labels. |
| `jobTypes` | array (multi-select) | `[]` (all) | Keep only these employment-schedule types: Full-time, Part-time, Part-time (20-29 hours), Reduced-time (30-39 hours), Flex time, Flex-time (under 19 hours). |
| `countries` | array (multi-select) | `[]` (worldwide) | Keep only jobs in these countries. 20 countries available (United States, United Kingdom, Germany, India, Japan, and more). |
| `sortBy` | select | `Relevance` | Order jobs are collected in: Relevance or Most recent. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Hard cap on the total number of jobs per search. Set to 0 for no cap. Amazon returns at most 10,000 results for any single search; the run keeps the full last page even if it slightly overshoots. |

### Output

Each job is returned as one flat record:

```json
{
    "title": "Software Development Engineer, AWS Lambda",
    "jobId": "2801234",
    "url": "https://account.amazon.com/jobs/2801234/apply",
    "detailUrl": "https://www.amazon.jobs/en/jobs/2801234/software-development-engineer-aws-lambda",
    "location": "US, WA, Seattle",
    "normalizedLocation": "Seattle, Washington, USA",
    "locations": [
        {
            "city": "Seattle",
            "state": "Washington",
            "countryCode": "USA",
            "country": "United States",
            "display": "Seattle, Washington, USA"
        }
    ],
    "city": "Seattle",
    "state": "Washington",
    "countryCode": "USA",
    "jobCategory": "Software Development",
    "jobFamily": "Software Development",
    "team": "AWS Lambda",
    "businessCategory": "Amazon Web Services",
    "jobScheduleType": "full-time",
    "companyName": "Amazon.com Services LLC",
    "basicQualifications": "3+ years of non-internship professional software development experience...",
    "preferredQualifications": "Experience with distributed systems and cloud infrastructure...",
    "description": "As a Software Development Engineer on AWS Lambda you will design, build, and operate the serverless compute platform used by millions of developers worldwide. You will own services end to end...",
    "descriptionShort": "Join the AWS Lambda team to build the world's leading serverless platform...",
    "postedDate": "March 12, 2026",
    "updatedAt": "2026-03-14T09:20:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title as published |
| `jobId` | string | Stable public Amazon job identifier (used for deduplication) |
| `url` | string | Direct apply link for the role |
| `detailUrl` | string | Link to the full job posting page |
| `companyName` | string | Hiring Amazon entity for the role |
| `descriptionShort` | string | Short summary of the role |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `location` | string | Location as published (e.g. "US, WA, Seattle") |
| `normalizedLocation` | string | Cleaned, human-readable location string |
| `locations` | object\[] | All locations for multi-site roles, each with city, state, country code, country, and display name |
| `city` | string | Primary city |
| `state` | string | Primary state or region |
| `countryCode` | string | ISO country code (e.g. USA, GBR, DEU) |

#### Classification

| Field | Type | Description |
|-------|------|-------------|
| `jobCategory` | string | Amazon job category (one of 38) |
| `jobFamily` | string | Job family the role belongs to |
| `team` | string | Internal team label (e.g. AWS Lambda, Alexa) |
| `businessCategory` | string | Business category / org (e.g. Amazon Web Services) |
| `jobScheduleType` | string | Employment schedule type (e.g. full-time) |

#### Qualifications & Dates

| Field | Type | Description |
|-------|------|-------------|
| `basicQualifications` | string | Required qualifications for the role |
| `preferredQualifications` | string | Preferred (nice-to-have) qualifications |
| `description` | string | Full role description — responsibilities, team context, and day-to-day scope |
| `postedDate` | string | Date the role was posted |
| `updatedAt` | string | Timestamp the posting was last updated |

### Tips for Best Results

- **Spell cities the way Amazon does** — `location` is an exact match against Amazon's own city name, so "Bengaluru" returns results while "Bangalore" returns none, and "Köln" beats "Cologne". Use the Countries filter for broad geography.
- **Narrow to reach deeper than 10,000** — any single search stops at Amazon's 10,000-result window. To go further, split it into several runs by category, country, or keyword, or add multiple entries to Search URLs.
- **Use `sortBy: recent` for monitoring** — set it to Most recent on a schedule and you capture brand-new postings first, which is ideal for daily alerts and freshness tracking.
- **Pick categories from the list, don't type them** — category filtering matches Amazon's exact labels, so choosing from the dropdown guarantees hits instead of silent zeros.
- **Start small to validate** — run with `maxResults` of 50 first to confirm your filter mix returns the roles you expect, then scale up.
- **Screen with both qualification blocks** — filter your results on `basicQualifications` for hard requirements and `preferredQualifications` for differentiators, rather than parsing one description field.
- **Search URLs are the escape hatch** — build a search on amazon.jobs with any filters you like, copy the URL, and paste it into Search URLs to run combinations the structured fields don't cover.

### Pricing

**From $0.01 per 1,000 results** — among the most affordable job-board scrapers on the platform. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.0025 | $0.0020 | $0.0015 | $0.0010 |
| 1,000 | $0.025 | $0.020 | $0.015 | $0.010 |
| 10,000 | $0.25 | $0.20 | $0.15 | $0.10 |
| 100,000 | $2.50 | $2.00 | $1.50 | $1.00 |

A "result" is any job row in the output dataset. Platform fees are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate recruitment research, talent intelligence, and labor-market analysis using publicly available job postings. Users are responsible for complying with applicable laws and Amazon's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data contained in postings responsibly and in line with applicable privacy regulations.

# Actor input Schema

## `searchKeyword` (type: `string`):

Word or phrase to match across the job title and description (e.g. 'software engineer', 'data scientist', 'operations manager'). Leave blank to collect every job matching the filters below.

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

Filter to a single city (e.g. 'Seattle', 'Berlin', 'Bengaluru'). This is an EXACT match against Amazon's own city name, so spell it as Amazon does — 'Bengaluru' returns results but 'Bangalore' returns none. For broad geography, use the Countries filter below instead. Leave blank for jobs anywhere.

## `searchUrls` (type: `array`):

Advanced: paste one or more full amazon.jobs search URLs (e.g. copied from your browser after applying filters on the site). Each URL uses the filters baked into it and ignores the structured Keyword/City/Filters fields above, so it is the power-user way to run searches the fields don't cover. URLs are scraped in addition to the keyword search, and each is paginated to completion.

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

Only include jobs in these Amazon job categories. Leave empty to include all categories.

## `jobTypes` (type: `array`):

Only include jobs of these employment types. Leave empty to include all types.

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

Only include jobs in these countries. Leave empty to include jobs worldwide.

## `sortBy` (type: `string`):

Order in which jobs are collected.

## `maxResults` (type: `integer`):

Hard cap on the total number of jobs returned per search. Default 100 — increase for bigger runs, or set to 0 for no cap. Amazon's careers search returns at most 10,000 results for any single search, so a broad search stops at 10,000 no matter how high you set this — to collect more, split your search with narrower filters (a specific category, country, or keyword) or add several entries to the Search URLs field. The actor stops requesting new pages once your cap is reached but keeps the full final page even if it slightly overshoots.

## Actor input object example

```json
{
  "searchKeyword": "software engineer",
  "searchUrls": [],
  "categories": [],
  "jobTypes": [],
  "countries": [],
  "sortBy": "relevant",
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of jobs with the most useful fields — title, location, category, job type, posting date, and apply link.

## `details` (type: `string`):

Full per-job rows including qualifications, description, team, business category, all locations, and timestamps.

# 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 = {
    "searchKeyword": "software engineer",
    "location": "",
    "searchUrls": [],
    "categories": [],
    "jobTypes": [],
    "countries": [],
    "sortBy": "relevant",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchKeyword": "software engineer",
    "location": "",
    "searchUrls": [],
    "categories": [],
    "jobTypes": [],
    "countries": [],
    "sortBy": "relevant",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/amazon-jobs-scraper").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 '{
  "searchKeyword": "software engineer",
  "location": "",
  "searchUrls": [],
  "categories": [],
  "jobTypes": [],
  "countries": [],
  "sortBy": "relevant",
  "maxResults": 100
}' |
apify call solidcode/amazon-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/amazon-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Jobs Scraper",
        "description": "[💰 $0.01 / 1K] Extract job postings from Amazon's official careers site (amazon.jobs). Search by keyword and location, filter by category, job type, and country, or paste ready-made search URLs. Get titles, locations, qualifications, categories, teams, posting dates, and apply links.",
        "version": "1.0",
        "x-build-id": "qVtvsNBfxkDdkNEto"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~amazon-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-amazon-jobs-scraper",
                "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/solidcode~amazon-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-amazon-jobs-scraper",
                "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/solidcode~amazon-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-amazon-jobs-scraper",
                "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",
                "properties": {
                    "searchKeyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Word or phrase to match across the job title and description (e.g. 'software engineer', 'data scientist', 'operations manager'). Leave blank to collect every job matching the filters below."
                    },
                    "location": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter to a single city (e.g. 'Seattle', 'Berlin', 'Bengaluru'). This is an EXACT match against Amazon's own city name, so spell it as Amazon does — 'Bengaluru' returns results but 'Bangalore' returns none. For broad geography, use the Countries filter below instead. Leave blank for jobs anywhere."
                    },
                    "searchUrls": {
                        "title": "Search URLs (advanced)",
                        "type": "array",
                        "description": "Advanced: paste one or more full amazon.jobs search URLs (e.g. copied from your browser after applying filters on the site). Each URL uses the filters baked into it and ignores the structured Keyword/City/Filters fields above, so it is the power-user way to run searches the fields don't cover. URLs are scraped in addition to the keyword search, and each is paginated to completion.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Job Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include jobs in these Amazon job categories. Leave empty to include all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Operations, IT, & Support Engineering",
                                "Software Development",
                                "Fulfillment & Operations Management",
                                "Sales, Advertising, & Account Management",
                                "Project/Program/Product Management--Non-Tech",
                                "Project/Program/Product Management--Technical",
                                "Facilities, Maintenance, & Real Estate",
                                "Solutions Architect",
                                "Finance & Accounting",
                                "Medical, Health, & Safety",
                                "Supply Chain/Transportation Management",
                                "Administrative Support",
                                "Systems, Quality, & Security Engineering",
                                "Hardware Development",
                                "Human Resources",
                                "Corporate Operations",
                                "Applied Science",
                                "Marketing & PR",
                                "Business & Merchant Development",
                                "Design",
                                "Buying, Planning, & Instock Management",
                                "Business Intelligence",
                                "Investigation & Loss Prevention",
                                "Fulfillment Associate",
                                "Data Science",
                                "Legal",
                                "Fulfillment / Warehouse Associate",
                                "Customer Service",
                                "Machine Learning Science",
                                "Editorial, Writing, & Content Management",
                                "Procurement",
                                "Research Science",
                                "Leadership Development & Training",
                                "PR",
                                "Audio / Video / Photography Production",
                                "Economics",
                                "Public Policy",
                                "Database Administration"
                            ],
                            "enumTitles": [
                                "Operations, IT & Support Engineering",
                                "Software Development",
                                "Fulfillment & Operations Management",
                                "Sales, Advertising & Account Management",
                                "Project/Program/Product Management (Non-Tech)",
                                "Project/Program/Product Management (Technical)",
                                "Facilities, Maintenance & Real Estate",
                                "Solutions Architect",
                                "Finance & Accounting",
                                "Medical, Health & Safety",
                                "Supply Chain / Transportation Management",
                                "Administrative Support",
                                "Systems, Quality & Security Engineering",
                                "Hardware Development",
                                "Human Resources",
                                "Corporate Operations",
                                "Applied Science",
                                "Marketing & PR",
                                "Business & Merchant Development",
                                "Design",
                                "Buying, Planning & Instock Management",
                                "Business Intelligence",
                                "Investigation & Loss Prevention",
                                "Fulfillment Associate",
                                "Data Science",
                                "Legal",
                                "Fulfillment / Warehouse Associate",
                                "Customer Service",
                                "Machine Learning Science",
                                "Editorial, Writing & Content Management",
                                "Procurement",
                                "Research Science",
                                "Leadership Development & Training",
                                "Public Relations",
                                "Audio / Video / Photography Production",
                                "Economics",
                                "Public Policy",
                                "Database Administration"
                            ]
                        },
                        "default": []
                    },
                    "jobTypes": {
                        "title": "Job Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include jobs of these employment types. Leave empty to include all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Full-Time",
                                "Part-Time",
                                "Part-Time (20-29 hours)",
                                "Reduced-Time (30-39 hours)",
                                "Flex Time",
                                "Flex-Time (<19 hours)"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Part-time (20-29 hours)",
                                "Reduced-time (30-39 hours)",
                                "Flex time",
                                "Flex-time (under 19 hours)"
                            ]
                        },
                        "default": []
                    },
                    "countries": {
                        "title": "Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include jobs in these countries. Leave empty to include jobs worldwide.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "USA",
                                "CAN",
                                "GBR",
                                "IRL",
                                "DEU",
                                "FRA",
                                "ESP",
                                "ITA",
                                "NLD",
                                "POL",
                                "IND",
                                "JPN",
                                "CHN",
                                "SGP",
                                "AUS",
                                "BRA",
                                "MEX",
                                "ARE",
                                "ZAF",
                                "EGY"
                            ],
                            "enumTitles": [
                                "United States",
                                "Canada",
                                "United Kingdom",
                                "Ireland",
                                "Germany",
                                "France",
                                "Spain",
                                "Italy",
                                "Netherlands",
                                "Poland",
                                "India",
                                "Japan",
                                "China",
                                "Singapore",
                                "Australia",
                                "Brazil",
                                "Mexico",
                                "United Arab Emirates",
                                "South Africa",
                                "Egypt"
                            ]
                        },
                        "default": []
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "relevant",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Order in which jobs are collected.",
                        "default": "relevant"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the total number of jobs returned per search. Default 100 — increase for bigger runs, or set to 0 for no cap. Amazon's careers search returns at most 10,000 results for any single search, so a broad search stops at 10,000 no matter how high you set this — to collect more, split your search with narrower filters (a specific category, country, or keyword) or add several entries to the Search URLs field. The actor stops requesting new pages once your cap is reached but keeps the full final page even if it slightly overshoots.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
