# Integrating the jobdata API with Make

Automate job-data workflows in minutes by connecting the jobdata API to Make with the HTTP v4 module, native pagination, and resilient error handling.

---

Integrating the jobdata API with [Make](https://www.make.com/) lets you automatically fetch and process job listings for use cases like analytics dashboards, enrichment pipelines, notifications, and internal reporting.

This updated guide reflects current Make features (HTTP v4, keychain credentials, built-in pagination, modern error handling) and current jobdata API behavior.

## Prerequisites

- **Make account**: Active Make account
- **jobdata API key**: Generate from your [dashboard](/accounts/dashboard/)
- **Use case**: Know where you want to send the results (Google Sheets, Airtable, DB, Slack, etc.)

## Quick API Notes (Important)

Before building your scenario, keep these current API behaviors in mind:

- Use endpoint URLs with a trailing slash, e.g. `https://jobdataapi.com/api/jobs/`
- API auth header format is:
  - `Authorization: Api-Key YOUR_API_KEY`
- Jobs responses are paginated with:
  - `count`, `next`, `previous`, `results`
- `/api/jobs/` defaults to `max_age=90` if no explicit age/range slicing is provided
- Some filters/features are plan-gated and can return `403` if your plan does not include them

## Step 1: Create a New Scenario

1. In Make, click **Create a new scenario**.
2. Add the **HTTP** app (use **HTTP v4**, not legacy).
3. Select **Make a request**.

## Step 2: Configure HTTP Request (Recommended Setup)

Configure the module like this:

- **URL**: `https://jobdataapi.com/api/jobs/`
- **Method**: `GET`
- **Authentication type**: `API key` (recommended)
- **Parse response**: `Yes`

### API Key Configuration (Keychain)

In HTTP v4, store credentials in Make’s keychain instead of hardcoding headers.

- **Key**: `Api-Key YOUR_API_KEY`
- **API key placement**: `In the header`
- **API key parameter name**: `Authorization`

This produces the required header safely:
`Authorization: Api-Key YOUR_API_KEY`

> You can still use `api_key` query parameter for quick testing, but header auth is preferred for security.

## Step 3: Add Query Parameters

Add filters relevant to your use case. Example starter set:

- `title=python`
- `max_age=7`
- `has_remote=true`
- `page_size=200`

Example request:
`https://jobdataapi.com/api/jobs/?title=python&max_age=7&has_remote=true&page_size=200`

### Notes

- If you want older data, set `max_age` explicitly.
- On eligible plans, you can disable max-age filtering with `max_age=off` (or `null` / `0`).
- Some advanced filters are restricted by subscription tier.

## Step 4: Enable Native Pagination (HTTP v4)

If you want more than one page, use HTTP v4 pagination instead of manual looping.

Set:

- **Pagination type**: `URL or link based`
- **Items path**: `results`
- **Next page URL path**: `next`
- **Output format**: `Array of items` (recommended)

This follows `next` until no further page is returned.

## Step 5: Process the Results

After the HTTP module:

1. Map fields from each item in `results` (or paginated item output).
2. Add destination modules, e.g.:
   - Google Sheets / Airtable / Notion
   - PostgreSQL / MySQL
   - Slack / Email notifications
3. Optionally deduplicate by stable identifiers (`id`, `application_url`, or your own keying strategy).

## Step 6: Add Error Handling

For production scenarios, add explicit error behavior:

- Enable **Return error if HTTP request fails** in the HTTP module
- Add an error handler route (Retry / Resume / Skip depending on business impact)
- Keep payload-safe fallback behavior for non-critical branches

Make also applies automatic exponential backoff for transient connection/timeout failures, but explicit handlers give you more control.

## Step 7: Scenario Settings for Stability

In Scenario Settings, consider enabling:

- **Store incomplete executions**: On
- **Sequential processing**: On (especially for scheduled polling)
- **Number of consecutive errors**: Set a value your team monitors

These settings reduce missed runs and make recovery easier.

## Step 8: Test End-to-End

1. Click **Run once**.
2. Verify:
   - Auth works (no `401/403` due to key formatting)
   - Pagination returns expected volume
   - Output mapping is correct
   - Destination modules receive valid data

## Step 9: Schedule and Activate

- Set schedule cadence (e.g. every 15 minutes, hourly, daily)
- Activate scenario
- Monitor first runs and adjust filters/page size as needed

## Optional: Make the Scenario Reusable with Inputs

Use **Scenario Inputs** for reusable templates (now broadly available), e.g.:

- `keywords`
- `country_code`
- `max_age`
- `page_size`
- `destination_table`

This lets non-technical teammates run the same scenario with different parameters without editing modules.

## Troubleshooting

- **301 redirect**: You used `/api/jobs` instead of `/api/jobs/`
- **403 Forbidden**: Filter/feature likely requires higher plan tier
- **429 Too Many Requests**: Reduce run frequency/concurrency and add retries
- **Unexpectedly “recent only” results**: `max_age` default behavior is active; set it explicitly

## Conclusion

With HTTP v4 keychain auth, URL-based pagination, and modern error handling, Make is a strong fit for reliable jobdata API automation. Start with a narrow filter set, verify output quality, then scale cadence and destinations once stable.