Amazon APIamazon.jobs ↗
Search Amazon job listings by keyword, location, and category. Retrieve full job details including description, qualifications, team info, and application URL.
What is the Amazon API?
The Amazon Jobs API gives developers structured access to amazon.jobs through 3 endpoints covering search, category enumeration, and individual job detail retrieval. search_jobs returns paginated results across all of Amazon's open roles, filterable by keyword, city, region, country, and category. get_job_details returns the full job description, qualifications, team metadata, geographic coordinates, and a direct application URL for any single listing.
curl -X GET 'https://api.parse.bot/scraper/c8e2ace2-fff0-4b07-88af-334f1ccb52ec/search_jobs?sort=relevant&limit=5&query=software+engineer&offset=0&category=Software+Development' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace amazon-jobs-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Amazon Jobs API — search jobs, browse categories, fetch details."""
from parse_apis.amazon_jobs_api import AmazonJobs, Sort, JobNotFound
client = AmazonJobs()
# List available job categories
for cat in client.categories.list(limit=5):
print(cat.displayName, cat.url)
# Search for software engineer jobs sorted by recency
for job in client.jobs.search(query="software engineer", sort=Sort.RECENT, limit=3):
print(job.title, job.company, job.normalized_location)
# Drill into the first result for full details
summary = client.jobs.search(query="data scientist", country="USA", limit=1).first()
if summary:
detail = summary.details()
print(detail.title, detail.schedule_type, detail.normalized_location)
for loc in detail.locations:
print(loc.city, loc.normalizedStateName, loc.coordinates)
# Fetch a job directly by ID with typed error handling
try:
job = client.jobs.get(id="10439110")
print(job.title, job.company, job.category)
except JobNotFound as exc:
print(f"Job not found: {exc.job_id}")
print("exercised: categories.list / jobs.search / summary.details / jobs.get")
Full-text search over Amazon job listings. query matches title and description; results can be filtered by category, city, region, and country. Paginated via offset. Each returned job includes summary-level fields; use get_job_details for full description and qualifications.
| Param | Type | Description |
|---|---|---|
| city | string | City filter (e.g., 'Seattle', 'San Francisco') |
| sort | string | Sort order for results. |
| limit | integer | Number of results per page (max varies, typically 10-100) |
| query | string | Search keyword/query (e.g., 'software engineer', 'data scientist') |
| offset | integer | Pagination offset (0-based) |
| region | string | State/region abbreviation filter (e.g., 'WA', 'CA', 'NSW') |
| country | string | 3-letter country code filter (e.g., 'USA', 'GBR', 'IND', 'AUS'). Uses ISO 3166-1 alpha-3 codes as returned in the country_code field of job results. |
| category | string | Job category filter (e.g., 'Software Development', 'Data Science'). Use get_job_categories for valid values. |
{
"type": "object",
"fields": {
"jobs": "array of job summary objects with id, title, company, location, category, posted_date, and other fields",
"limit": "integer, results per page requested",
"offset": "integer, current pagination offset",
"total_hits": "integer, total number of matching jobs",
"jobs_returned": "integer, number of jobs in this response"
}
}About the Amazon API
Searching and Filtering Jobs
search_jobs accepts a free-text query matched against job titles and descriptions, plus optional filters for city, region (state/province abbreviation), country (ISO 3166-1 alpha-3 code), and category. Results paginate via integer offset and configurable limit. Each response includes total_hits so you can calculate page counts, and jobs_returned to confirm the actual slice size. Individual job objects in the jobs array carry title, location, category, posted date, and a short description preview.
Job Categories
get_job_categories returns the full list of available category objects, each with an identifier, displayName, description, and url. The identifier value maps directly to the category filter in search_jobs, so you can enumerate categories programmatically before building a filtered query rather than guessing string values.
Full Job Details
get_job_details accepts a single job_id (the iCIMS numeric ID surfaced as id in search results) and returns the complete record: full HTML job description, qualifications, title, company, category, state, city, location, job_path, uuid, a team object with team metadata, and the application URL. Location data includes geographic coordinates where available. This is the endpoint to use when you need the untruncated job content rather than the search-result summary.
The Amazon API is a managed, monitored endpoint for amazon.jobs — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when amazon.jobs changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official amazon.jobs API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a job alert system that polls
search_jobswith a keyword and emails newtotal_hitsdeltas to subscribers. - Aggregate Amazon engineering roles by
regionandcategoryto produce a geographic hiring heatmap. - Feed
get_job_detailsresults into an LLM to auto-generate candidate preparation notes from the full HTML description and qualifications. - Use
get_job_categoriesto populate a dropdown filter in an internal recruiting dashboard without hardcoding category names. - Track changes in Amazon's open headcount over time by recording
total_hitspercategoryon a daily schedule. - Cross-reference
cityandcountryfields from search results with salary datasets to estimate compensation by location. - Sync Amazon job listings into an ATS or spreadsheet using paginated
search_jobscalls with incrementaloffset.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Amazon Jobs have an official developer API?+
What does `get_job_details` return beyond what `search_jobs` shows?+
search_jobs returns a short description preview, basic location text, category, and posted date. get_job_details returns the complete HTML job description, full qualifications text, a structured team object, geographic coordinates, an internal uuid, the relative job_path, and the direct application URL — fields that are not included in the search result objects.How does pagination work in `search_jobs`?+
offset to 0 for the first page, then increment by the limit value for subsequent pages. The total_hits field in every response tells you the total number of matching jobs, so you can compute exactly how many pages exist for a given query and stop when offset exceeds total_hits.Does the API expose salary or compensation data for job listings?+
search_jobs, get_job_details, and get_job_categories do not include pay range data. The API covers job metadata, full descriptions, qualifications, team info, and location. You can fork this API on Parse and revise it to add a compensation-focused endpoint if Amazon Jobs surfaces that data on individual listing pages.Can I retrieve application status or submit applications through this API?+
get_job_details which links to the Amazon-hosted application form. You can fork this API on Parse and revise it to add endpoints targeting application-related pages if needed.