Connect Crisphive to Make

Last updated October 4, 2026

By the end of this guide your Make scenarios will book and confirm jobs in Crisphive, start the instant a job or customer changes, and read jobs back safely — with every module field filled in correctly.

Make (formerly Integromat) is a visual automation tool: a scenario is a chain of modules, each one a step in an app, run from left to right. Crisphive is a field operations platform: constraint-based scheduling on a deterministic solver that books each job and assigns the right technician automatically — and it is manageable from Claude or ChatGPT too. The Crisphive app for Make gives you five modules.

To add the Crisphive app to your Make organization, email support@crisphive.com and we’ll send you the link.

What you can do

Group	Module	Type	What it does
Events	Watch events	Instant trigger	Starts the scenario the moment a selected event happens in Crisphive — a job is created, confirmed, assigned, completed or rescheduled, or a customer or technician is created, updated or deleted.
Jobs	Get a job	Action (read)	Returns the full job by its ID: status, schedule, customer, address and assigned technician.
Jobs	Book and confirm a job	Action (create)	Creates a job and schedules it at the time you choose in one step. A technician is assigned automatically.
Customers	Search customers	Search	Finds customers by an exact phone number, for example before booking.
Other	Make an API call	Universal	Calls any other endpoint of the Crisphive API with your connection — no authorization header to set up.

“Instant” means Crisphive pushes each event to Make the moment it happens; nothing polls. Under the hood Watch events uses a webhook: a web address Make gives Crisphive, to which Crisphive sends a message on each event. Make creates it in Crisphive when you save the trigger and deletes it when you delete the webhook.

Before you start

A Make account. The Crisphive app was tested on a Make Free plan; your plan only limits how many operations your scenarios may run per month.
A Crisphive account with a business. You sign in with your email and a one-time code; there is no password.
The right Crisphive role. The connection acts as you and can do only what your role allows. Watch events needs Developer access (developer_manage_api_keys), which by default only the business Owner has. Book and confirm a job needs job_create and job_manage; Search customers needs customers_view; Get a job needs job_view and job_manage. Simplest: the Owner creates the connection.
The link that installs the Crisphive app in your Make organization (see the note above).
A default duration on every job type you will book (Crisphive → Settings → Job Types). The default type, “General”, already has 60 minutes.
Working hours, technicians and service areas set up in Crisphive, so a technician can be found for the address and time.
About 15 minutes for the connection and a first scenario.

Test in Rehearsal first. Rehearsal is your business’s sandbox: isolated test data where no real customer or technician is ever texted or emailed. The Make connection works in the environment your Crisphive dashboard is in at the moment you click Approve. Before you connect, click Rehearsal in the Rehearsal | Live switch in the dashboard’s left sidebar and confirm with Switch. New businesses start in Rehearsal until they go live.

Step 1 — Install the Crisphive app

Open the link

Open the link from Crisphive while signed in to Make, click Install, choose the Make organization to install into, and click Install again.

Find the app in a scenario

Open Scenarios → Create a new scenario, click the large + and search for Crisphive. The five modules appear in four groups: Events, Jobs, Customers, Other.

Step 2 — Create the connection (OAuth)

Make connects with OAuth: you sign in to Crisphive in a pop-up and click Approve; Make never sees a password or an API key. You create the connection once and reuse it in every Crisphive module.

Step 1 of 4Add any Crisphive module to the scenario. In its settings, next to Connection, click Add (or Create a connection).

All steps

Add any Crisphive module to the scenario. In its settings, next to Connection, click Add (or Create a connection).
Type a Connection name that says which environment it is, for example Crisphive sandbox.
Optional: turn on Show advanced settings to see Additional scopes. Leave it empty — the connection then has the same access as your role. Type permission codes separated by spaces only to give it less, for example customers_view job_create job_manage.
Click Save. A Crisphive window opens. Allow pop-ups for make.com if nothing appears.

Step 1 of 4If you are not signed in to Crisphive in this browser, type your email and click Send Verification. Crisphive emails you a 6-digit code and a sign-in link.

All steps

If you are not signed in to Crisphive in this browser, type your email and click Send Verification. Crisphive emails you a 6-digit code and a sign-in link.
Type the 6-digit code from the email in Enter your code (or click the link in the email). You return to the authorization screen.
The screen reads “Authorize Make — Make wants to access your Crisphive business” and lists what the connection may do. Click Approve.
Wait while Crisphive shows “Taking you back to Make…”, the window closes and the module’s Connection field now shows Crisphive sandbox.

Pick the environment

In the Crisphive dashboard (crisphive.com/app), use the Rehearsal | Live switch in the left sidebar: Rehearsal to test, Live for real work. The connection is locked to the environment you are in when you click Approve.

Add the connection in Make

In any Crisphive module click Add next to Connection, name it (for example Crisphive sandbox) and click Save. Leave Additional scopes empty.

Sign in to Crisphive with your email and one-time code, then click Approve on Authorize Make. Make checks the connection by reading your job types and labels it with your business ID.

Then set the connection to last a year. A new connection lasts 90 days. So that Make does not stop on that day, the Owner sets it to 365 days right after connecting. Settings → Developer → MCP connections (crisphive.com/app/settings/developer/mcp-servers) lists every app connected by signing in to Crisphive, not only AI apps, so Make appears there.

Open MCP connections

In the Crisphive dashboard go to Settings → Developer → MCP connections and find the Make row.

Set lifetime

Click Set lifetime, enter 365 in Lifetime (days) and click Save. The days count from when Make was first authorized, not from today.

What the connection is allowed to do

Exactly what your role can do, re-checked on every request. If your role shrinks, the connection shrinks; if you are removed or suspended, it stops at once.
Additional scopes only narrow it. A code your role does not hold is refused at approval (OAUTH_SCOPE_NOT_GRANTED).
One business, one environment — the business and the sandbox/live environment you were in when you approved.
It expires. A connection lasts 90 days from approval by default (1–365 days with Set lifetime under Settings → Developer → MCP connections) and stops after 30 days without use. The Owner and Administrators are emailed 14 days before the limit. Make refreshes the short-lived access token by itself; to renew the connection, reauthorize it in Make (Credentials → Connections → Reauthorize).

Module: Watch events (instant trigger)

Watch events uses a dedicated webhook: each Watch events module has its own webhook, tied to one event. Creating the webhook subscribes it in Crisphive (with a signing secret valid for 365 days); deleting it unsubscribes.

Field (webhook dialog)	Required	What to enter
Webhook name	Yes	Any name you will recognise, for example `Crisphive · job completed`.
Connection	Yes	Your Crisphive connection. Its environment decides whether you receive sandbox or live events.
Event	Yes	The event that starts the scenario. The list is read live from Crisphive, so new events appear without an app update.

Step 1 of 4Click the + on an empty scenario, search for Crisphive and choose Watch events. In the module settings, click Create a webhook.

All steps

Click the + on an empty scenario, search for Crisphive and choose Watch events. In the module settings, click Create a webhook.
Type a Webhook name and choose your Crisphive connection.
Open the Event dropdown and choose the event, for example job_request.completed.
Click Save. Crisphive registers the webhook and sends a verification ping, which the app answers; the module now shows the webhook, and Make waits for the first event.

Event	Fires when	Permission needed (besides Developer access)
`job_request.created`	A job is booked, from any channel.	`job_view` + `job_manage`
`job_request.confirmed`	A time is confirmed.	`job_view` + `job_manage`
`job_request.assigned`	A technician or crew is assigned or reassigned.	`job_view` + `job_manage`
`job_request.rescheduled`	A job moves to a new time.	`job_view` + `job_manage`
`job_request.priority_changed`	A job’s priority changes.	`job_view` + `job_manage`
`job_request.status_changed`	Any other workflow step (on the way, arrived, …).	`job_view` + `job_manage`
`job_request.completed`	A job is completed.	`job_view` + `job_manage`
`job_request.archived`	A job is archived or cancelled.	`job_view` + `job_manage`
`customer.created` / `.updated` / `.deleted`	A customer record changes.	`customers_view`
`technician.created` / `.updated` / `.deleted`	A team member is added, edited (incl. suspended) or removed.	`team_view`

Output	Example	Meaning
Event ID	`evt_0be0f7f0-…`	Unique per event. A delivery can repeat; use this to ignore duplicates if it matters.
Event type	`job_request.completed`	The event.
Created at	`2026-09-30T15:30:00Z`	When it happened (UTC).
Object	`{ id, short_code, status }`	What the event is about. For job events: the job ID, short code and status. For customer events: the customer. Map Object → id into Get a job.

Make cannot verify webhook signatures — read the job back. Crisphive signs every delivery (Crisphive-Signature, an HMAC of the exact bytes sent), but Make hands the app a body it has already parsed, so the signature cannot be checked inside Make. The webhook address Make issues is unguessable, and the safe pattern closes the rest: treat Object as a pointer and put Get a job right after Watch events, then decide on the data Get a job returns (for example a filter on its status). A forged delivery can then at most start a run that reads real data.

Module: Get a job

Field	Required	What to enter
Job ID	Yes	The job’s ID: Object → id from Watch events, or Job ID from Book and confirm a job.

Output	Meaning
Job ID, Short code	The ID and the human reference (`REQ-CA-8K2M4Q7X`).
Job type ID, Job type, Workflow	What kind of job and which workflow it follows.
Status → Status key / Status name	For example `completed` / `Completed`. Filter on the key; it does not change with language.
Status version	A counter that goes up on every change.
Priority	`p0` (emergency) to `p3`.
Description	What needs doing.
Customer → Customer ID / Name / Phone / Email	Phone is in international (E.164) format.
Address → Address line / line 2 / City / State or province / Postal code / Country / Formatted address / Latitude / Longitude	Where the job is.
Schedule → Start time / Duration / End time / Business time zone / Customer time zone	Start and end are UTC dates; Make shows them in your Make time zone.
Assignment → Technician ID / Assigned at / Service area ID / Vehicle ID	Who does it and with which vehicle.
Customer link	The link the customer uses to see and manage this job.
Completed at, Created at, Updated at	Dates.

Step 1 of 3Add Crisphive › Get a job after Watch events and choose your Crisphive connection.

All steps

Add Crisphive › Get a job after Watch events and choose your Crisphive connection.
Click into Job ID, open the Object item of module 1 in the mapping panel and click id.
Click OK. Run the scenario once to see the full job in the output bubble.

Module: Search customers

Field	Required	What to enter
Phone	Yes	Phone number in international format: a plus sign, the country code and the number, for example `+16135550177`. Only an exact match is returned. A number without the country code is refused (`PHONE_INVALID`).
Limit	No (default 10)	Maximum number of customers to return and work with in one run. Usually one customer has a given number, so the default is fine.

Each customer found becomes one bundle with: Customer ID, External reference (your own ID, for example from a CRM), Full name, Tier, Status, Job count, Last job at, SMS consent, Updated at and Deleted at. Phone and email are not repeated in the result.

No match means no bundle. If nobody has that number, Search customers outputs nothing and the modules after it do not run for that item. For a “find or create” booking you usually do not need this module at all: Book and confirm a job matches an existing customer by phone or email by itself.

Step 1 of 2Add Crisphive › Search customers and choose your connection.

All steps

Add Crisphive › Search customers and choose your connection.
In Phone, type or map the number in +1… format, for example +16135550177. Keep Limit at 10, then click OK.

Module: Book and confirm a job

This module calls POST /v1/job-requests/book-and-confirm: it creates the job, sizes it (the job type’s default duration, or the Duration you give), confirms it at the start time and lets Crisphive’s solver assign a technician. Send the customer and the job address in the customer fields and leave Customer ID empty: Crisphive matches an existing customer by phone or email and never creates a duplicate. Empty fields are left out of the request, so you can leave any optional field blank.

Field	Required	What to enter	Example
Customer ID	No	Leave empty (recommended). The customer is then matched by phone or email — never duplicated — or created, and the job is booked at the address you send. Fill it only with the ID of a customer whose address on file is the job address: with a Customer ID the customer and address fields are ignored, and a customer with no stored address is refused (`JOB_REQUEST_ADDRESS_REQUIRED`).	`3f6c8e21-…`
Customer name	When Customer ID is empty	The customer’s name.	`Alex Martin`
Phone	Phone or Email, when Customer ID is empty	International format, plus sign and country code.	`+16135550177`
Email	Phone or Email, when Customer ID is empty		`alex.martin@example.com`
SMS consent	No	Select Yes only if the customer explicitly agreed to receive text messages about this job.	`No`
Address line	When Customer ID is empty	Street address of the job.	`145 Laurier Avenue West`
City	City or Postal code, when Customer ID is empty	Crisphive needs one of the two to find a technician who covers the area.	`Ottawa`
State or province	No	Two-letter code.	`ON`
Postal code	City or Postal code, when Customer ID is empty		`K1P 5J3`
Country	No	Two-letter code.	`CA`
Job type	No	Dropdown of your active job types. Empty = the business’s default job type.	`AC Repair`
Start time	Yes	Start of the job on the business’s own clock, without a time zone: `YYYY-MM-DDTHH:MM:SS`. Must be in the future and should be inside working hours. It is a text field on purpose — a Make date would be converted to UTC and book the wrong hour.	`2026-10-13T10:00:00`
Duration	No	Length of the job in minutes. Empty = the job type’s default duration.	`90`
Description	No	What needs doing; technicians see it.	`No cooling upstairs`

Step 1 of 6Add Crisphive › Book and confirm a job and choose your connection. Leave Customer ID empty for a new or returning caller identified by phone or email.

All steps

Add Crisphive › Book and confirm a job and choose your connection. Leave Customer ID empty for a new or returning caller identified by phone or email.
Fill Customer name, Phone (international format) and Email.
Set SMS consent to Yes only if the customer agreed to texts. Leave it on No otherwise.
Fill the address. Address line plus City or Postal code are needed when Customer ID is empty.
Choose the Job type (or leave it empty for the default), and type the Start time on the business clock: 2026-10-13T10:00:00.
Leave Duration empty to use the job type’s default. Click OK.

Output	Meaning
Job ID, Short code	The new job.
Customer ID	The matched or created customer.
Customer link	The link the customer uses to see and manage this job.
Confirmed	`true`: scheduled and assigned. `false`: saved but not scheduled yet — see Refusal.
Start time	The confirmed start (a date; UTC underneath).
Technician ID	Who was assigned.
Refusal → Stage / Error code / Message / Details	Only when Confirmed is false: why no technician could take that time, for example `JOB_REQUEST_NO_TECHNICIAN_AVAILABLE`.

“Confirmed: false” is not an error — and do not run the module again. The job is saved and waits in your coordinator queue. This module does not send an idempotency key, so re-running it books a second job. Add a Router with a filter on Confirmed = true for the happy path and another route for the queue case. Do not give this module an error handler that retries it, and remember that a scenario with incomplete executions stored can re-run a module after a connection error; if you need safe retries, use Make an API call with an Idempotency-Key header (example below).

Module: Make an API call

For anything the other modules do not cover — creating a customer, listing technicians, reading booking windows — call the Crisphive API directly. The connection adds the authorization for you.

Field	Required	What to enter
URL	Yes	The path after `https://api.crisphive.com/`, starting with `v1` and without a leading slash, for example `v1/job-types`. The module joins it to `https://api.crisphive.com/` itself, so `/v1/job-types` would produce a double slash, which the API answers with 404. The host is fixed: the module cannot call another site.
Method	Yes (default GET)	`GET`, `POST`, `PUT`, `PATCH` or `DELETE`.
Headers	No	Pre-filled with `Content-Type: application/json`. Do not add Authorization. Add `Idempotency-Key` on create calls.
Query string	No	Key / value pairs, for example `phone` = `+16135550177`.
Body	No	The JSON body for POST/PUT/PATCH.

Output: Body (the API answer {error_code, message, data} — error_code 0 means success), Headers and Status code.

Step 1 of 3Add Crisphive › Make an API call. Type the URL v1/customers (no leading slash) and choose Method POST.

All steps

Add Crisphive › Make an API call. Type the URL v1/customers (no leading slash) and choose Method POST.
Keep the Content-Type header and add a second header: Key Idempotency-Key, Value something unique to this record, for example the form response ID.
In Body, paste the JSON for the customer and click OK.

Book and confirm with a safe retry (Make an API call)

URL:     v1/job-requests/book-and-confirm      (no leading slash)
Method:  POST
Headers: Content-Type = application/json
         Idempotency-Key = make-{{1.id}}        (unique per source record)
Body:
{
  "customer": { "full_name": "Alex Martin", "phone": "+16135550177",
                "email": "alex.martin@example.com", "sms_opt_in": false },
  "address":  { "line": "145 Laurier Avenue West", "city": "Ottawa",
                "state": "ON", "postal_code": "K1P 5J3", "country": "CA" },
  "scheduled_at": "2026-10-13T10:00:00",
  "description": "No cooling upstairs"
}

Other useful calls (URL without the leading slash; put ?key=value pairs in Query string)
GET v1/customers       phone = +16135550177    find a customer (exact match)
GET v1/job-types       status = active         your job types and their default durations
GET v1/technicians                             your team
GET v1/job-requests/booking-windows            bookable days and periods

Field mapping tips

Start time from a date: wrap the date in formatDate with your business time zone so the hour is not shifted: {{formatDate(1.date; "YYYY-MM-DD[T]HH:mm:ss"; "America/Toronto")}}. Replace America/Toronto with the time zone in Crisphive → Settings.
Never send an offset that disagrees with your business clock (for example a value ending in Z for a Toronto business). Crisphive refuses it with JOB_REQUEST_INVALID_INPUT instead of guessing the hour.
Dates coming out of Crisphive (Start time, Completed at) are real dates; show them to a customer with {{formatDate(3.schedule.scheduled_at; "dddd, MMMM D [at] h:mm A"; "America/Toronto")}}.
Phone numbers to E.164: for North American numbers typed as 613-555-0177, strip everything but digits and add +1: +1{{replace(1.phone; "/[^0-9]/g"; "")}}. Only do this when the form never contains a country code; otherwise ask for the international format on the form.
Booleans: map SMS consent from a checkbox; an empty value is left out (no consent).
Job type from a form answer: use Make’s switch() function or a Router to map the answer to a job type ID, or leave Job type empty.

Worked scenarios

Five scenarios to start with. Module numbers in mappings ({{1.…}}, {{2.…}}) follow the order you add the modules.

Scenario 1 — Website form → booked and confirmed job

Trigger: your form app (Google Forms, Typeform, Jotform, Webflow) — watch responses

The form collects name, phone, email, street, city or postal code, date and time, service, and an unticked SMS consent box.

Crisphive › Book and confirm a job

Customer ID empty. Customer name, Phone (+1{{replace(…)}}), Email, SMS consent, Address line, City, Postal code from the form; State or province ON, Country CA; Start time {{formatDate(…; "YYYY-MM-DD[T]HH:mm:ss"; "")}}; Description from the form.

Router

Route 1 filter: Confirmed = true → email the customer the time and the Customer link. Route 2 filter: Confirmed = false → email the office “job Short code waits in the queue”.

Scenario 2 — Job completed → review request

Crisphive › Watch events

Event job_request.completed.

Crisphive › Get a job

Job ID = Object → id from module 1.

Filter

Between Get a job and the next module: Status → Status key equals completed. This is the read-back that protects you from a forged delivery.

Gmail / Microsoft 365 Email › Send an email

To = Customer → Email. Subject: “Thanks, ” + Customer → Name. Body: your Google review link and the Short code. Add a Tools › Sleep module before it if you want a short delay (Make limits how long one run may wait).

Scenario 3 — New customer → CRM or spreadsheet

Crisphive › Watch events

Event customer.created. Object carries the customer: id, full_name, phone, email, address.

Google Sheets › Add a row (or HubSpot › Create a contact)

Map Object → full_name, phone, email, and store Object → id so later scenarios can find the same customer.

Scenario 4 — Job assigned → team channel

Crisphive › Watch events

Event job_request.assigned.

Crisphive › Get a job

Job ID = Object → id.

Slack › Send a Message

Text: Short code · Customer → Name · Address → Formatted address · {{formatDate(2.schedule.scheduled_at; "ddd MMM D, h:mm A"; "America/Toronto")}} · Job type.

Scenario 5 — Job completed → invoice

Watch events → Get a job → Filter

As in scenario 2.

QuickBooks / Xero › Create an invoice

Customer from Customer → Name and Email, reference = Short code, line item = Job type. Crisphive stores no prices, so set the amount in this module (a switch() on the job type works well).

Test it with “Run once”

Use a Rehearsal connection

Make sure the connection was approved with the Crisphive dashboard in Rehearsal. Nobody is contacted from Rehearsal, and 555-01xx numbers and @example.com addresses are never messaged anyway.

Build a one-module test

New scenario with only Crisphive › Book and confirm a job: Customer name Alex Martin, Phone +16135550177, Email alex.martin@example.com, SMS consent No, Address line 145 Laurier Avenue West, City Ottawa, State or province ON, Postal code K1P 5J3, Country CA, Start time 2026-10-13T10:00:00 (any future weekday time inside working hours), Description Make test.

Click Run once

Success: a green bubble on the module; open it and the output shows Confirmed = true, a Short code REQ-CA-… and a Technician ID.

Check Crisphive

In the dashboard (in Rehearsal) the job is on the board at 10:00 with status Confirmed (opened, its window is titled Booking Confirmed) and a technician, and Alex Martin is under Customers. Change only Start time and run again: a second job for the same customer, and no duplicate customer.

Test the trigger

New scenario: Watch events (event customer.created). Click Run once — Make waits for data. Create a customer in the dashboard (in Rehearsal); within seconds the bubble shows the event with that customer in Object.

Test an error

Run Get a job with Job ID 00000000-0000-0000-0000-000000000000. It fails with a 404 and the message JOB_REQUEST_NOT_FOUND — this is how errors look in Make.

Turn it on

Switch the scenario ON. Instant triggers run as soon as an event arrives. Archive the test job in Crisphive.

Troubleshooting

Crisphive errors appear in Make as [status] ERROR_CODE: message, for example [400] PHONE_INVALID: Phone number is not valid.

Symptom	Cause	Fix
Saving the Watch events webhook fails with `[403] FORBIDDEN`	The connected person lacks Developer access.	Have the Owner create the connection, or ask the Owner to grant the Developer module to your group in Settings → Permissions.
`[403] WEBHOOK_EVENT_NOT_PERMITTED`	Your role cannot read the data that event carries (for example `customer.*` needs `customers_view`).	Ask the Owner for the permission, or connect as someone who has it.
`[409] WEBHOOK_LIMIT_REACHED`	The business has 25 active webhook endpoints in this environment.	Delete webhooks you no longer use in Make (this unsubscribes them), or in Crisphive → Settings → Developer → Webhooks.
Watch events never fires	The event happened in the other environment, the scenario is off, or the subscription stopped (connection disconnected, connecting member removed or suspended, 5 failed deliveries in a row).	Make the event in the connection’s environment; turn the scenario on; recreate the webhook.
Jobs are booked but you cannot see them	The connection was approved while the dashboard was in the other environment.	Switch the dashboard; for live work, create a live connection.
The connection fails with `OAUTH_GRANT_EXPIRED` or asks to reauthorize	It reached 90 days, was unused for 30 days, or was disconnected in Crisphive.	In Make open Credentials in the left sidebar, switch to Connections, click Reauthorize on the Crisphive connection, sign in and Approve.
`[400] PHONE_INVALID`	The phone has no country code or is not a real number.	Send `+16135550177` format (see Field mapping tips).
`[400] JOB_REQUEST_INVALID_INPUT`	Start time missing, malformed, in the past or with a disagreeing offset; or Customer ID empty with no name, no address line, or neither phone nor email; or an inactive job type.	Fix the field the message names; check Start time against the business clock.
`[400] JOB_REQUEST_ADDRESS_REQUIRED`	A new customer without City or Postal code, or a Customer ID whose customer has no stored address.	Fill City or Postal code; for returning customers leave Customer ID empty and send the address.
`[400] JOB_REQUEST_QUOTE_INVALID`	The job type has no default duration and Duration is empty, or Duration is 0.	Set a default duration in Settings → Job Types, or fill Duration.
`[400] INVALID_REQUEST_BODY`	A field has the wrong type, or Make an API call sent malformed JSON.	Check Duration is a whole number; validate the JSON body.
Confirmed: false with Refusal `JOB_REQUEST_NO_TECHNICIAN_AVAILABLE`	No technician who covers the address and has the skills is free then.	The job waits in the coordinator queue — schedule it in the dashboard. Do not re-run.
Two jobs for one form response	The module was re-run or retried; it sends no idempotency key.	Archive the duplicate. Remove any error handler that retries this module, or use Make an API call with an Idempotency-Key.
Modules after Search customers did not run	No customer has that exact number, so the search returned no bundle.	Book with the customer fields instead (they match existing customers), or use a Router fallback.
The job is booked hours off	A Make date was mapped into Start time without `formatDate` and the business time zone.	Use `formatDate(…; "YYYY-MM-DD[T]HH:mm:ss"; "<business zone>")`.
`[429] TOO_MANY_REQUESTS`	More than about 240 requests per minute on one connection.	Slow the scenario down (Tools › Sleep, smaller batches).

Go live

Make does not use API keys, so there is no chsk_test_ → chsk_live_ swap. Going live means a new connection created while the dashboard is in Live.

Switch Crisphive to Live

Switch the dashboard from Rehearsal to Live (confirm go-live first if your business has not yet).

Create a live connection

In a Crisphive module click Add, name it Crisphive live, Save, sign in and Approve.

Switch each module

Select the live connection in every Crisphive module, and re-pick Job type (sandbox and live have separate job types).

Recreate the webhook

The webhook belongs to a connection: in Watch events create a new webhook on the live connection, then delete the sandbox webhook in Webhooks to free its slot.

Set a reminder

The connection lasts 90 days from approval (Owner and Administrators are emailed 14 days before) and stops after 30 days unused. The webhook’s signing secret lasts 365 days; recreate the webhook before then.

Removing access

In Make: delete the Watch events webhooks (this unsubscribes them in Crisphive), then delete the connection under Credentials → Connections.
In Crisphive: the Owner can disconnect Make for everyone under Settings → Developer → MCP connections (/app/settings/developer/mcp-servers). Its tokens stop and the webhooks it created are disabled.
Automatically: removing or suspending the member who connected Make stops the connection and its triggers.

Automation platforms overview — what every automation integration shares
Zapier — book jobs from any Zap; instant job and customer triggers
n8n — the Crisphive node for self-hosted n8n, plus n8n AI Agents
Pipedream — HTTP and Node.js steps against the API
Webhooks reference — events, signatures and retries
Book and confirm a job — the API call behind every booking step

FAQ

Is the Crisphive app for Make free?

Yes, the app costs nothing extra. Make counts operations against your Make plan; it was tested on a Make Free plan. On the Crisphive side, use any plan with the features you need.

How do I add Crisphive to my Make organization?

Email support@crisphive.com and we’ll send you the link. Open it while signed in to Make, choose the organization and confirm the installation.

Do I need an API key to use Crisphive in Make?

No. Make connects with OAuth: you sign in to Crisphive and click Approve. API keys (chsk_…) are for n8n, Pipedream, voice agents and your own code.

Why can’t Make verify the webhook signature?

Crisphive signs the exact bytes it sends, but Make gives the app an already-parsed body, so the signature cannot be recomputed. Put Get a job right after Watch events and act on the data it returns, not on the event alone.

Why did my job not confirm?

The module answered Confirmed: false because no technician who covers that address was free at that time — often a time outside working hours. The job is saved in your coordinator queue; do not run the module again.

Why is Start time a text field and not a date?

Crisphive needs the time on your business’s own clock. A Make date is converted to UTC and would book the job at the wrong hour for any business outside UTC. Use formatDate with your business time zone.

How do I test without contacting real customers?

Switch the Crisphive dashboard to Rehearsal before approving the connection. Rehearsal is the isolated sandbox and never texts or emails anyone.

Who can turn on Watch events?

Someone with Developer access in Crisphive — by default only the Owner. The other modules work with a normal role that has the needed job and customer permissions.

How do I remove Make’s access?

Delete the webhooks and the connection in Make, or disconnect Make in Crisphive under Settings → Developer → MCP connections. Removing the member who connected it also stops it.

‹ PreviousZapier

Next ›n8n

Connect Crisphive to Make

What you can do

Before you start

Step 1 — Install the Crisphive app

Step 2 — Create the connection (OAuth)

What the connection is allowed to do

Module: Watch events (instant trigger)

Module: Get a job

Module: Search customers

Module: Book and confirm a job

Module: Make an API call

Field mapping tips

Worked scenarios

Scenario 1 — Website form → booked and confirmed job

Scenario 2 — Job completed → review request

Scenario 3 — New customer → CRM or spreadsheet

Scenario 4 — Job assigned → team channel

Scenario 5 — Job completed → invoice

Test it with “Run once”

Troubleshooting

Go live

Removing access

Related guides and reference

FAQ