# Connect Make to Atlas Labs

> To connect Make to Atlas Labs, create a **Custom webhook** module to receive events and an HTTP **Make a request** module to call the API with an `Authorization: Bearer` header stored in a Credentials keychain. Make assigns the webhook URL on a `hook.<region>.make.com` host, which Atlas Labs accepts as a shared automation destination.

Canonical: `https://automationatlas.io/labs/docs/tools/make/` · Checked: `2026-10-15`

Atlas Labs is a fictional company's API; every figure in every response is simulation data.

*Reference table — Atlas Labs API fields and Make's documented module names, not part of the fictional simulation. Make docs checked `15 Oct 2026`.*

| At a glance | Value |
| --- | --- |
| Receive events | Webhooks → **Custom webhook**; Advanced settings **Get request headers** = Yes |
| Call the API | HTTP → **Make a request** |
| Where the key goes | Authentication type **API key** → Credentials → **Create a keychain**: Key `Bearer lab_off_YOUR_KEY`, API key placement **Header**, API key parameter name `Authorization`. Make recommends the keychain over the Headers field. |
| Body | Body type **Raw**, Content type **JSON (application/json)**, Request content = your JSON |
| `Idempotency-Key` | A Headers item whose value is the `webhook-id` header from the Custom webhook (Get request headers = Yes; it equals the event `id`), or the body's `id` once the body is parsed |
| Webhook host | `hook.<region>.make.com` is a recognised platform host with a higher delivery allowance |
| Retries | None on the HTTP module; Scenario settings → **Store incomplete executions** plus the **Retry** error handler |
| OpenAPI import | None for HTTP calls; use the HTTP module |

> **Start a sandbox and your keys are filled in for you.** This page uses `lab_off_YOUR_KEY` and `lab_fac_YOUR_KEY`. After you [start a sandbox](https://automationatlas.io/labs/#start-sandbox-heading), the “Connect it” panel's Make tab shows the keychain values with your real keys and a copy button.

- Atlas Labs → Your scenario: signed webhook, to hook.<region>.make.com
- Your scenario → Atlas Labs: Make a request, API key keychain
- Your scenario → Your apps: router

Both legs are optional: a scenario can only listen, only call, or do both.

## How do I receive Atlas Labs events in Make?

1. **Add module → Webhooks → Custom webhook → Add**, name it and Save. Make generates the URL and starts listening.
2. **Open Advanced settings.** Set **Get request headers** to Yes so `webhook-id`, `webhook-timestamp` and `webhook-signature` are mappable. Set **JSON pass-through** to Yes if you plan to verify the signature: the body then reaches later modules as one text string, not as fields, so parse it first (Make's JSON parsing tools; we did not confirm the module name in a live account) before mapping `id` or `data.sales_order_id`. Leave pass-through off to get parsed fields straight away and skip the signature check. Whether the pass-through string is byte-exact is not stated in Make's docs, so test it once.
3. **Subscribe the URL** with either key. Make answers `200` “Accepted” at once, inside the `5`-second window Atlas Labs allows.
   - Method: `POST`
   - URL: `https://automationatlas.io/labs/api/v1/webhooks`
   - Headers: `Authorization: Bearer lab_off_YOUR_KEY`; `Content-Type: application/json`
   - Body: `{"url": "https://hook.<region>.make.com/…", "events": ["office.sales_order.accepted"]}`
4. **Send the test ping** (`POST /webhooks/{id}/test`) and, if Make asks, click **Re-determine data structure**. Activate the scenario (scheduling ON; a webhook scenario runs instantly).
5. **Signature.** Make has no Standard Webhooks module. For a fictional sandbox you may accept unverified deliveries; otherwise compute the HMAC yourself (we have not confirmed which Make module or function can produce an HMAC-SHA256) or pass the raw string and headers to an external verifier (the algorithm is on the [Webhooks page](https://automationatlas.io/labs/docs/webhooks/)).

## How do I call the Atlas Labs API from Make?

1. **Add module → HTTP → Make a request.** Set URL and Method, for example `GET https://automationatlas.io/labs/api/v1/office/sales-orders/<id>` to read the accepted order's `quantity` and `due_sim_day`.
2. **Authentication type: API key → Credentials → Create a keychain.** Name it “Atlas Labs Head Office”; Key `Bearer lab_off_YOUR_KEY` (type the word Bearer yourself); API key placement **Header**; API key parameter name `Authorization`. Make a second keychain, “Atlas Labs Factory”, for `lab_fac_YOUR_KEY`.
   - Authentication type: API key
   - Keychain name: Atlas Labs Factory
   - Key: `Bearer lab_fac_YOUR_KEY`
   - API key placement: Header
   - Parameter name: `Authorization`
3. **For a write**, set Body type **Raw**, Content type **JSON (application/json)** and paste the JSON into Request content. Add a Headers item `Idempotency-Key` mapped to the `webhook-id` header from the Custom webhook, or to the parsed body's `id`; both are the event id.
   - Method: `POST`
   - URL: `https://automationatlas.io/labs/api/v1/factory/work-orders`
   - Headers: `Idempotency-Key` = the `webhook-id` header
   - Request content: `{"sales_order_id": "<sales_order_id from the parsed body>", "quantity": <from the order>, "due_date": <due_sim_day from the order>}`
   **Preset matters.** Pick a preset with a manual bridge (Standard or Full) or this write returns `409 already_bridged`, because Starter bridges automatically.
4. **Turn on “Return error if HTTP request fails”** so `4xx` and `5xx` stop the scenario and reach your error handlers.
5. **Add a Router** after the request: one route for `201` or `409` with `error.code` = `already_bridged` (success), a fallback route for everything else.

## Idempotency and retries

- The HTTP module has no retry setting. In Scenario settings turn on **Store incomplete executions**, then attach the **Retry** error handler (earlier called Break) with your attempts and interval; Make's example is “try `3` more times, every `15` minutes”.
- Make reruns `ConnectionError` and `RateLimitError` automatically once incomplete executions are on; an instant scenario reruns the incomplete execution with exponential backoff. For a `429` from Atlas Labs the wait in `Retry-After` is usually one or two seconds.
- Calls made in parallel share one key's budget, for example when scenario runs overlap, so keep calls to Atlas Labs to one or two at a time: more at once only collect more `429`s, and enough of them put the key into a short cooldown.
- Because the `Idempotency-Key` is the event id (the `webhook-id` header), a rerun returns the original response (`Idempotency-Replayed: true`) rather than a second work order.

## Common errors

*Reference table — Atlas Labs error codes as seen from Make, not part of the fictional simulation.*

| You see | Why, and the fix |
| --- | --- |
| `401 unauthorized` | The keychain Key is the bare key. It must read `Bearer lab_off_…`, prefix included. |
| `403 wrong_system` | The wrong keychain on the module. `/factory/*` wants the Factory keychain, `/office/*` the Head Office one. |
| `415 unsupported_media_type` | Body type was not Raw with Content type JSON (application/json). |
| `422 webhook_url_rejected` | Paste the whole Make URL including `https://`; `details.reason` names the failing rule. |
| Make returns `400` “Queue is full” | Make's own webhook queue; Atlas Labs retries after `10 s`, `60 s` and `300 s`. |
| Make returns `410` Gone | A webhook left unattached to a scenario for more than `5` days is deactivated by Make. Atlas Labs disables the subscription after `5` consecutive failures; create a new one. |

## Gotchas

- **Keychain, not Headers.** Make's own guidance is to define authentication in the Credentials field rather than the Headers field, for security and key rotation. Earlier Atlas Labs docs said “set the header”; this page is the correction.
- **Pass-through hides fields.** With JSON pass-through on, nothing in the body is mappable until you parse the string; with it off, Make parses for you but the exact bytes for the signature are gone.
- **Plan gating is not stated** on Make's HTTP or Custom webhook pages (a third-party post claims all plans; unverified).
- **Webhook rate.** Make accepts up to `300` requests per `10 s` per webhook before answering `429`; Atlas Labs sends at most `60` deliveries per minute per sandbox, so this is not a practical limit.
- **Blueprints carry no secrets.** The downloadable blueprint uses placeholder references; store the keys as scenario variables or in keychains after import, and create the webhook yourself because Make assigns the URL.
- **Module versions shift.** Treat the blueprint's module `version` numbers and mapper names as a starting point to check in the editor.

## Download the blueprint

- [bridge-accepted-sales-order-to-work-order.blueprint.json](https://automationatlas.io/labs/downloads/templates/make/bridge-accepted-sales-order-to-work-order.blueprint.json) — Custom webhook → HTTP (GET the order) → HTTP (`POST /factory/work-orders`, the `webhook-id` header as `Idempotency-Key`) → Router on `201` / `409 already_bridged`. Needs a manual-bridge preset (Standard or Full). (Structurally validated only, not imported into a Make account)

## Questions people ask

**Which Make modules do I use?** Webhooks → Custom webhook to receive, HTTP → Make a request to call. Nothing else is needed; a Router sorts the responses.

**Which Make webhook hosts does Atlas Labs accept?** Any public HTTPS URL on port `443`, and `hook.<region>.make.com` is on the list of shared platform hosts with a higher delivery allowance.

**How do I treat a duplicate delivery?** As success. Deliveries are at-least-once; with the event `id` as `Idempotency-Key` a second delivery gets the original response, and a bridge that already happened returns `409 already_bridged`.

**Does Make verify the Standard Webhooks signature?** Not out of the box. Turn on Get request headers and JSON pass-through, then compute the HMAC yourself or skip verification for this fictional sandbox.

**Why do I get `401` although the key is in the keychain?** The Key field must contain `Bearer ` followed by the key; Make sends the Key value verbatim as the header value.

**Can Make import the Atlas Labs OpenAPI file?** No official import exists for HTTP calls; a Make community thread confirms it. The HTTP module takes under a minute to fill in.

Sources (checked `15 Oct 2026`): apps.make.com/http, apps.make.com/api-key-authentication-type, apps.make.com/gateway (Custom webhook), help.make.com/webhooks, help.make.com/fix-rate-limit-errors, help.make.com/retry-error-handler. Atlas Labs facts from the API source, observed live.

[n8n](https://automationatlas.io/labs/docs/tools/n8n/) · [Power Automate](https://automationatlas.io/labs/docs/tools/power-automate/)