---
name: crisphive-n8n-setup
description: "Walks a Crisphive customer step by step through connecting Crisphive to n8n. Install the verified Crisphive node in n8n, start a workflow on each confirmed job and email your office from Gmail within seconds. Use when the user wants to set up, test or troubleshoot Crisphive with n8n."
---

# Connect Crisphive to n8n

## How to use this file (instructions for the AI assistant)

You are helping a Crisphive customer connect Crisphive to **n8n**. The person you are talking to may not be technical and has probably not read the guide. Everything you need is in the guide below — follow it, do not improvise.

1. **Start by asking two things:** whether they already have a Crisphive account they can sign in to, and how far they have got (nothing yet, or which step). Skip the steps they have already done.
2. **Give ONE step at a time.** Name the exact page, button and field from the guide, and the exact value to type. Wait for them to say it is done (or to send a screenshot) before the next step.
3. **Ask for a screenshot when they are stuck** or when what they see does not match the guide. Screens change; if a label in the guide is not on their screen, say so plainly, describe what the step is trying to achieve, and help them find the closest equivalent. Never invent a button name.
4. **Secrets never go in this chat.** API keys (`chsk_…`), webhook signing secrets (`whsec_…`) and OAuth client secrets are pasted only into the platform field the guide names. If the user pastes one here, tell them to revoke it in Crisphive and create a new one.
5. **Start in Rehearsal (the sandbox).** Recommend test keys (`chsk_test_…`) and Rehearsal mode until the test at the end of the guide works. Only then explain how to switch to Live.
6. **Finish with the guide’s test.** The setup is done only when the test in the guide succeeds (for example a job appears in the Crisphive dashboard). If it fails, use the Troubleshooting and FAQ sections below.
7. **Stay inside this guide.** For anything it does not cover, point the user to the full page or to support@crisphive.com instead of guessing.

Source page: https://docs.crisphive.com/docs/n8n (last updated 2026-10-30). If the user asks, this file is generated from that page and is always in step with it.

---

# The guide

By the end of this guide, each time a job is confirmed in Crisphive, n8n sends one email from your Gmail to your office within a few seconds — with the customer, the visit time in your local time, the technician, the address, the job type and the job code. The second half of the page covers the Crisphive actions (book and confirm a job, find a caller) and n8n AI Agents.

**n8n** is a workflow automation tool: you connect boxes (called *nodes*) so that something happening in one app does something in another. **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 node for n8n is free and open source (`n8n-nodes-crisphive` on npm, MIT licence).

> **Where to install it.** On **n8n Cloud** the Crisphive node is a **Verified** node: you install it with one click from the workflow editor ([Step 3](https://docs.crisphive.com/docs/n8n#install)) — no invite and no community-node setup. On a **self-hosted** n8n you install the package `n8n-nodes-crisphive` from **Settings → Community Nodes** instead ([see below](https://docs.crisphive.com/docs/n8n#self-hosted)).

## What you will have at the end

One email per confirmed job, sent from your Gmail. It looks like this:

```
Subject: Job confirmed: REQ-CA-E4QYDBXH

Customer: Sam Tremblay
Phone: +16135550188
When: Thursday, October 15, 2026 11:00 AM
Technician: Alex Morin
Address: 300 Bank Street, Ottawa
Job type: General
Job: REQ-CA-E4QYDBXH
```

The workflow has two nodes, left to right. It takes about **15 minutes** to build.

```
Crisphive Trigger (On new Crisphive event)  →  Gmail — Send a message
```

> **No “read the job back” step.** With **Fetch Full Job** on (the default), the trigger itself hands n8n the whole job — customer, schedule, address, technician. Turned off, a job event carries only the job’s ID, short code and status.

## Before you start

| You need | Notes |
| --- | --- |
| A Crisphive login as **Owner** | Turning on an event trigger needs the Owner role, or a role the Owner gave the Developer module in **Settings → Permissions**. |
| An **n8n account** | A new **n8n Cloud** account starts a 14-day trial (*0/1000 Executions*). Each confirmed job is one execution. |
| A **Gmail** (or Google Workspace) account | The email is sent from this mailbox. |

> **Test in Rehearsal first.** Rehearsal is Crisphive’s sandbox: isolated test data, and no real customer or technician is ever texted or emailed. A key created in Rehearsal starts with `chsk_test_` and n8n then sees only test data. You switch to a live key at the end ([Go live](https://docs.crisphive.com/docs/n8n#go-live)).

## Step 1 — Create an n8n Cloud account

Skip this step if you already have an n8n account.

1. **Register** — Open [app.n8n.cloud/register](https://app.n8n.cloud/register), type your **Company email** and click **Continue** (this accepts n8n’s terms).
2. **Answer the short survey** — n8n greets you with *Nice to meet you, <name>* and asks a few questions, such as *Which of these do you feel comfortable doing without AI?* and *What best describes your work?*. Answer them and click **Submit**.
3. **Skip the invites** — On **Invite team members to your instance**, click **Skip**.
4. **Start automating** — **Your instance is ready!** — click **Start automating**. Your instance has an address like `https://<name>.app.n8n.cloud`.

## Step 2 — Create a Crisphive API key

The n8n node signs in to Crisphive with an **API key** — a long password that lets a program act for your business. (Zapier and Make sign in and click Approve instead; n8n does not.)

1. **Open API Keys** — In Crisphive, go to **Settings → Developer → API Keys** ([crisphive.com/app/settings/developer/api-keys](https://crisphive.com/app/settings/developer/api-keys)). Creating keys needs Developer access, which by default only the Owner has.
2. **Make sure you are in Rehearsal** — The page may open in **Live**. Click **Rehearsal** at the top left, then **Switch** in the *Switch environment?* box. The page reloads.
3. **Choose Secret and name the key** — Click **Create new API key**. Key type: **Secret** (never **Publishable** — a publishable `chpk_` key is only for the booking widget on your website). Name: `n8n bookings`.
4. **Choose how long it lasts** — In **Expires in (days)** keep **30 days** for a test key. Keys always expire: 30 days by default, anything from 1 to 365 days chosen when you create the key. The Owner and Administrators are emailed 7 days before a key expires.
5. **Restrict it** — Under **Scopes** choose **Restricted** and tick **View jobs**, **Create jobs**, **Manage jobs**, **View customers**, **Manage customers**, **View developer settings** and **Manage API keys**. The dialog shows *7 selected*. The last two let the trigger subscribe a webhook in Crisphive; without them the actions still work, but the trigger cannot be turned on.
6. **Create and copy** — Click **Create API key**. The box reads **API key created**. Copy the key (it starts with `chsk_test_` and is shown only once), then click **Done**.

Screen in Crisphive: **Create new API key** (`crisphive.com/app/settings/developer/api-keys`)

1. In Settings → Developer → API Keys (in Rehearsal), click Create new API key. Keep Key type on Secret and type the name n8n bookings. — **Name**: `n8n bookings`
2. Keep Expires in (days) on 30 days for a test key. — **Expires in (days)**: `30 days`
3. Under Scopes choose Restricted and tick the seven scopes. The dialog shows 7 selected. — **Manage API keys**: on
4. Click Create API key, copy the key from API key created (it starts with chsk_test_ and is never shown again), then click Done. — click **Done**

## Step 3 — Install the Crisphive node and add the trigger

1. **Start a workflow** — In n8n, create a new workflow and click **Add first step…**. A panel opens: **What triggers this workflow?**
2. **Find Crisphive** — Search for `Crisphive`. The result **Crisphive** carries a verified badge and reads *Starts the workflow when a Crisphive job or customer event happens*. Click it.
3. **Install the node** — **Node details** shows **Verified**, **Triggers (1)** with **On new Crisphive event**, and **Actions (5)**. Click the orange **Install node** button. A toast says **Package installed**, and the panel shows **Installed** and **Package version 0.1.3 (Latest)**.
4. **Add the trigger** — Click **On new Crisphive event**. A node named **Crisphive Trigger** opens with **Credential** (a **Connect to Crisphive** button), **Event Names or IDs**, a **Fetch Full Job** switch (on by default) and a collapsible **Webhook URLs** section.

> On n8n Cloud, **Settings → Community nodes** lists only verified packages and has no **Install** button. Install the Crisphive node from the workflow editor as above.

## Step 4 — Connect your Crisphive key

A *credential* is where n8n stores your API key, so every Crisphive node can use it without you pasting the key again.

Screen in n8n: **Crisphive account** (`your-name.app.n8n.cloud/workflow/new`)

1. In the Crisphive Trigger node, click Connect to Crisphive. A Crisphive account box opens (subtitle Crisphive API). — click **Connect to Crisphive**
2. Paste the chsk_test_… key into API Key. Leave Base URL as https://api.crisphive.com and Allowed HTTP Request Domains on All. Click Save. — **API Key**: paste your own key (never share it in this chat)

1. **Open the credential box** — Click **Connect to Crisphive**. A **Crisphive account** box opens (subtitle *Crisphive API*).
2. **Paste the key** — **API Key**: paste the `chsk_test_…` key from Step 2. **Base URL**: leave `https://api.crisphive.com`. **Allowed HTTP Request Domains**: leave **All**.
3. **Save** — Click **Save**. **Credential** now shows **Crisphive account**.

## Step 5 — Choose the event and catch a real one

Screen in n8n: **Crisphive Trigger** (`your-name.app.n8n.cloud/workflow/new`)

1. Event Names or IDs starts with Job Completed already chosen. Remove it. — **Event Names or IDs**: `Job Completed`
2. Choose Job Confirmed. Leave Fetch Full Job on so the event arrives with the whole job. — **Event Names or IDs**: `Job Confirmed`
3. Click Test this trigger (it changes to Stop Listening), then confirm a job in Crisphive. The event shows up in the output within seconds. — click **Test this trigger**

1. **Pick Job Confirmed** — **Event Names or IDs** starts with **Job Completed** already chosen. Remove it and choose **Job Confirmed**. The list is read live from Crisphive and has 14 events: Customer Created, Customer Deleted, Customer Updated, Job Archived, Job Assigned, Job Completed, Job Confirmed, Job Created, Job Priority Changed, Job Rescheduled, Job Status Changed, Technician Created, Technician Deleted and Technician Updated.
2. **Keep Fetch Full Job on** — With it on, the trigger reads the whole job before the workflow continues.
3. **Listen** — Click **Test this trigger**. The button changes to **Stop Listening**.
4. **Confirm a job in Crisphive** — Confirm a job (in Rehearsal while testing). A job booked with **Book and confirm** fires straight away.
5. **Read the output** — Within a few seconds the trigger shows one item with `event_id` (`evt_…`), `type` `job_request.confirmed` and `object` — the whole job.

The fields this guide uses from `object`:

| Field | Example |
| --- | --- |
| `object.short_code` | `REQ-CA-E4QYDBXH` |
| `object.customer.name` / `.phone` | `Sam Tremblay` / `+16135550188` |
| `object.address.line` / `.city` | `300 Bank Street` / `Ottawa` |
| `object.schedule.scheduled_at` | `2026-10-15T15:00:00Z` (always UTC) |
| `object.schedule.business_timezone` | `America/Toronto` |
| `object.assignment.technician.full_name` | `Alex Morin` |
| `object.job_type_name` | `General` |
| Also there | `object.description`, `object.crew[].technician_name`, `object.assigned_vehicle.name` |

> **Keep `customer_url` private.** `object` also contains `customer_url`, which includes the customer’s private booking link. Do not put it in emails to anyone but the customer, or send it to third-party tools.

## Step 6 — Send the email (Gmail)

1. **Add Gmail** — Click the **+** after the trigger. A panel opens: **What happens next?** Search for `Gmail`, click **Gmail**, then the action **Send a message**. The node is named **Send a message** (*send: message*).
2. **Connect Gmail** — Under **Credential**, click **Sign in with Google** (or *setup manually*). Choose the Google account that will send the email (*to continue to n8n.cloud*). On Google’s permission screen, **tick every box**, then continue. **Credential** shows **Gmail account**.
3. **Fill the fields** — Use the table and the Message block below.
4. **Send a test** — Click **Execute step**. The email is sent: the output has an `id`, a `threadId` and `labelIds` `UNREAD`, `SENT`, `INBOX`. Check the inbox.

| Field | What to put |
| --- | --- |
| **Resource** | Leave **Message**. |
| **Operation** | Leave **Send**. |
| **To** | Your office email address. |
| **Subject** | `Job confirmed: {{ $json.object.short_code }}` — the preview under the field reads e.g. *Job confirmed: REQ-CA-E4QYDBXH*. |
| **Email Type** | Leave **HTML**. |
| **Message** | The block below. |

Copy all of this and paste it into **Message** in one go; n8n turns each `{{ … }}` into an expression and shows a preview under the field:

```
Customer: {{ $json.object.customer.name }}<br>Phone: {{ $json.object.customer.phone }}<br>When: {{ DateTime.fromISO($json.object.schedule.scheduled_at).setZone($json.object.schedule.business_timezone).toFormat("cccc, LLLL d, yyyy h:mm a") }}<br>Technician: {{ $json.object.assignment.technician.full_name }}<br>Address: {{ $json.object.address.line }}, {{ $json.object.address.city }}<br>Job type: {{ $json.object.job_type_name }}<br>Job: {{ $json.object.short_code }}
```

The **When** line turns the UTC start time into your business’s local time: `2026-10-15T15:00:00Z` becomes *Thursday, October 15, 2026 11:00 AM* for a business in America/Toronto.

Screen in n8n: **Gmail — Send a message** (`your-name.app.n8n.cloud/workflow/new`)

1. Fill To with your office address and Subject with Job confirmed: followed by the short code expression. — **To**: `office@yourbusiness.com`
2. Leave Email Type on HTML, paste the whole Message block in one go, then click Execute step. — **Message**: `Customer: {{ $json.object.customer.name }}<br>Phone: {{ $json.object.customer.phone }}<br>When: {{ DateTime.fromISO(…) }}`

## Step 7 — Test, then turn it on

1. **Name the workflow** — Click the workflow name at the top and type, for example, `Crisphive: email the office when a job is confirmed`.
2. **Publish** — Click **Publish**. A **Publish workflow** box opens with **Version name** (prefilled, e.g. *Version 9bc65f91*) and *Describe changes (optional)*. Click **Publish**. The status reads **Published**, and a notice says *Workflow published — Your workflow will now listen for events from Crisphive and trigger executions…*. Click **Got it**.
3. **Check a live run** — Confirm one more job in Crisphive. The workflow’s **Executions** tab shows a run such as *Succeeded in 704ms*.

On the Crisphive side, **Settings → Developer → Webhooks** ([crisphive.com/app/settings/developer/webhooks](https://crisphive.com/app/settings/developer/webhooks)) lists an endpoint on `<name>.app.n8n.cloud/webhook/…` named **n8n trigger**, **1 event**, status **Active**, with a secret that expires one year after it was created.

## Templates

Ready-made automations you import instead of building. Each card says what the template does, what is inside and why it is safe before you take it.

### Template: Website form → confirmed job

- **What it is:** An n8n workflow you import instead of building: a booking form on your website books and confirms the visit in Crisphive, then tells the visitor the result.
- **Why use it:** It is the automation business owners ask for most, already built and tested end to end. You pick your Crisphive credential and publish — no nodes to wire up.
- **What is inside:** **Website form** — the form your visitors fill in: name, phone, email, address, preferred date and time, and what they need; **Book and confirm in Crisphive** — books the visit and asks Crisphive to confirm that time; **Confirmed?** — checks whether a technician could take the time; **Booked** and **Needs a time** — the two answers the visitor sees
- **Is it safe:** Yes. It is a plain JSON text file that only describes the five nodes and their settings — no program code and no API key. You choose your own Crisphive credential after importing.
- **File:** https://docs.crisphive.com/templates/n8n/website-form-to-confirmed-job.json (saved as `crisphive-n8n-website-form-to-confirmed-job.json`)

Full template — give it to the reader when they ask for it:

```json
{
  "name": "Crisphive — website form to confirmed job",
  "nodes": [
    {
      "parameters": {
        "formTitle": "Book a service visit",
        "formDescription": "Tell us what you need and when. We confirm the visit right away when a technician is free.",
        "formFields": {
          "values": [
            {
              "fieldLabel": "Full name",
              "requiredField": true
            },
            {
              "fieldLabel": "Phone",
              "placeholder": "+16135550142",
              "requiredField": true
            },
            {
              "fieldLabel": "Email",
              "fieldType": "email"
            },
            {
              "fieldLabel": "Street address",
              "requiredField": true
            },
            {
              "fieldLabel": "City",
              "requiredField": true
            },
            {
              "fieldLabel": "Postal code",
              "requiredField": true
            },
            {
              "fieldLabel": "Preferred date",
              "fieldType": "date",
              "requiredField": true
            },
            {
              "fieldLabel": "Preferred time",
              "fieldType": "dropdown",
              "fieldOptions": {
                "values": [
                  {
                    "option": "09:00"
                  },
                  {
                    "option": "11:00"
                  },
                  {
                    "option": "13:00"
                  },
                  {
                    "option": "15:00"
                  }
                ]
              },
              "requiredField": true
            },
            {
              "fieldLabel": "What do you need?",
              "fieldType": "textarea",
              "requiredField": true
            }
          ]
        },
        "options": {}
      },
      "id": "6f2f8c1e-1a8d-4c55-9a51-7d1b9a0c0001",
      "name": "Website form",
      "type": "n8n-nodes-base.formTrigger",
      "typeVersion": 2.2,
      "position": [
        0,
        0
      ],
      "webhookId": "crisphive-book-a-visit"
    },
    {
      "parameters": {
        "operation": "bookAndConfirm",
        "customerMode": "new",
        "fullName": "={{ $json[\"Full name\"] }}",
        "addressLine": "={{ $json[\"Street address\"] }}",
        "scheduledAt": "={{ $json[\"Preferred date\"] }}T{{ $json[\"Preferred time\"] }}:00",
        "additionalFields": {
          "phone": "={{ $json[\"Phone\"] }}",
          "email": "={{ $json[\"Email\"] }}",
          "city": "={{ $json[\"City\"] }}",
          "postalCode": "={{ $json[\"Postal code\"] }}",
          "country": "CA",
          "description": "={{ $json[\"What do you need?\"] }}"
        }
      },
      "id": "6f2f8c1e-1a8d-4c55-9a51-7d1b9a0c0002",
      "name": "Book and confirm in Crisphive",
      "type": "n8n-nodes-crisphive.crisphive",
      "typeVersion": 1,
      "position": [
        240,
        0
      ]
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "loose",
            "version": 2
          },
          "conditions": [
            {
              "id": "6f2f8c1e-1a8d-4c55-9a51-7d1b9a0c0010",
              "leftValue": "={{ $json.confirmed }}",
              "rightValue": "",
              "operator": {
                "type": "boolean",
                "operation": "true",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "id": "6f2f8c1e-1a8d-4c55-9a51-7d1b9a0c0003",
      "name": "Confirmed?",
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        480,
        0
      ]
    },
    {
      "parameters": {
        "operation": "completion",
        "respondWith": "text",
        "completionTitle": "Your visit is booked",
        "completionMessage": "=Thank you, {{ $('Website form').item.json[\"Full name\"] }}. Your booking reference is {{ $json.short_code }}. We will see you on {{ $('Website form').item.json[\"Preferred date\"] }} at {{ $('Website form').item.json[\"Preferred time\"] }}.",
        "options": {}
      },
      "id": "6f2f8c1e-1a8d-4c55-9a51-7d1b9a0c0004",
      "name": "Booked",
      "type": "n8n-nodes-base.form",
      "typeVersion": 1,
      "position": [
        720,
        -100
      ],
      "webhookId": "6f2f8c1e-1a8d-4c55-9a51-7d1b9a0c0004"
    },
    {
      "parameters": {
        "operation": "completion",
        "respondWith": "text",
        "completionTitle": "Thanks, we have your request",
        "completionMessage": "=Your request reference is {{ $json.short_code }}. That time is not available, so our team will call you to agree on a time.",
        "options": {}
      },
      "id": "6f2f8c1e-1a8d-4c55-9a51-7d1b9a0c0005",
      "name": "Needs a time",
      "type": "n8n-nodes-base.form",
      "typeVersion": 1,
      "position": [
        720,
        100
      ],
      "webhookId": "6f2f8c1e-1a8d-4c55-9a51-7d1b9a0c0005"
    }
  ],
  "connections": {
    "Website form": {
      "main": [
        [
          {
            "node": "Book and confirm in Crisphive",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Book and confirm in Crisphive": {
      "main": [
        [
          {
            "node": "Confirmed?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Confirmed?": {
      "main": [
        [
          {
            "node": "Booked",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Needs a time",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1"
  },
  "pinData": {}
}
```

To use it:

1. **Open a new workflow** — In n8n, create a new, empty workflow.
2. **Import it from the link** — Click the **…** menu next to the workflow name, then **Import** → **From URL**, and paste `https://docs.crisphive.com/templates/n8n/website-form-to-confirmed-job.json`. (If you used Download, choose **From file** and pick the downloaded file.) If n8n asks **Importing this from an AI tool?**, click **Skip**.
3. **Pick your Crisphive credential** — Open the **Book and confirm in Crisphive** node and choose the Crisphive credential you created in [Step 4](https://docs.crisphive.com/docs/n8n#credential). The file contains no key. If your business is not in Canada, change **Country** under Additional Fields.
4. **Publish and test** — Click **Publish**, open the form’s production URL and book a test visit. The visitor sees **Your visit is booked** with the booking reference, or **Thanks, we have your request** when no technician can take that time — the job is still saved for your team to confirm.

To build it by hand instead: n8n Form Trigger (or your form tool’s webhook) → Crisphive **Book and Confirm Job** → **If** `confirmed` is true → email the customer; otherwise → post to your team channel. The values below use n8n expressions (`{{ … }}`); type them in the field’s **Expression** mode.

```
Crisphive node — Operation: Book and Confirm Job
Customer:                     New or Returning Caller
Full Name:                    {{ $json["Full name"] }}
Address Line:                 {{ $json["Street address"] }}
Start (Business Local Time):  {{ $json["Preferred date"] }}T09:00:00
Additional Fields:
  Phone (E.164):              {{ $json["Phone"] }}
  Email:                      {{ $json["Email"] }}
  City:                       {{ $json["City"] }}
  Postal Code:                {{ $json["Postal code"] }}
  Country:                    CA
  Description:                {{ $json["What do you need?"] }}

If node — condition:  {{ $json.confirmed }}  is true
  true  → "Booked: {{ $json.short_code }}"
  false → "Needs a time: {{ $json.short_code }} ({{ $json.refusal.error_code }})"
```

**More templates.** Two more workflows business owners ask for. Their values use n8n expressions too.

**Job completed → review request.** Crisphive Trigger (Job Completed, Fetch Full Job on) → Send Email / Gmail.

```
To:       {{ $json.object.customer.email }}
Subject:  Thanks for choosing us — job {{ $json.object.short_code }}
Body:     Hi {{ $json.object.customer.name }}, your visit is complete.
          Would you leave us a quick review? [your review link]
```

**New customer → spreadsheet or CRM.** Crisphive Trigger (Customer Created) → Google Sheets “Append row” with `{{ $json.object.full_name }}`, `{{ $json.object.phone }}`, `{{ $json.object.email }}` and `{{ $json.event_id }}` (keep the event ID: Crisphive delivers at least once, so a repeat delivery has the same ID and can be skipped).

## What the app can do

| Kind | Name in n8n | What it does |
| --- | --- | --- |
| Trigger | **On new Crisphive event** (the **Crisphive Trigger** node) | Starts a workflow the moment a Crisphive event happens (job confirmed, job completed, customer created, …). Instant, signed webhooks. Used in this guide. |
| Action | **Book and Confirm Job** | Creates the job, sizes it from the job type’s default duration and confirms it at the time you choose, with Crisphive picking the technician — in one step. |
| Action | **Find Customer by Phone** | Looks a caller up by their exact phone number (E.164, for example `+16135550177`). |
| Action | **Create Customer** | Adds a customer with a name and a phone or email. |
| Action | **Get Job** | Reads one job: status, schedule, technician, customer, address. |
| Action | **List Job Types** | Lists your active job types and their default durations, so you can copy a Job Type ID. |
| AI tool | **Crisphive** (as a tool) | Attach the Crisphive node to an n8n AI Agent so the agent can book and look up jobs itself. |
| AI tool | **MCP Client Tool** + `https://api.crisphive.com/mcp/crm` | Give an AI Agent the Crisphive customer and booking tools through n8n’s built-in MCP Client Tool. |

The next sections are reference for the five Crisphive **actions**, the trigger and n8n AI Agents. They use the same **Crisphive account** credential as the trigger. Every job type you book needs a default duration (Crisphive → **Settings → Job Types**); the built-in “General” type already has one (60 minutes) and is used when you do not choose a type.

## Book and Confirm Job

This is the operation most workflows need. Add a **Crisphive** node, choose your **Crisphive account** credential and set **Operation** to **Book and Confirm Job**. The **Customer** field decides which other fields appear.

| Field | Required | What to put in it |
| --- | --- | --- |
| **Customer** | Yes | **New or Returning Caller** (recommended): you send the person and the service address; Crisphive matches an existing customer by phone or email and creates one only when there is no match — never a duplicate. **Existing Customer ID**: you already know the customer’s Crisphive ID and want to use the address stored on their record. |
| **Full Name** | Yes (New or Returning Caller) | The customer’s full name, e.g. `Alex Martin`. |
| **Address Line** | Yes (New or Returning Caller) | Street address where the work happens, e.g. `145 Laurier Avenue West`. Add **City** or **Postal Code** under Additional Fields so Crisphive can place it on the map. |
| **Customer ID** | Yes (Existing Customer ID) | The customer’s UUID from Crisphive (for example from Find Customer by Phone → `customers[0].id`). The customer must have an address on file. |
| **Start (Business Local Time)** | Yes | When the visit starts, on your business’s own clock, with **no timezone offset**: `2026-10-06T10:00:00`. Do not add `Z` or `-04:00`. |
| Additional Fields → **Phone (E.164)** | Phone or Email (new caller) | International format with the leading `+`: `+16135550177`. Spaces and dashes are allowed; a number without the country code is refused. |
| Additional Fields → **Email** | Phone or Email (new caller) | `alex.martin@example.com`. |
| Additional Fields → **City** | Recommended | `Ottawa`. |
| Additional Fields → **State / Province** | Optional | `ON`. |
| Additional Fields → **Postal Code** | Recommended | `K1P 5J3`. |
| Additional Fields → **Country** | Optional | Two-letter code, `CA` or `US`. |
| Additional Fields → **Job Type ID** | Optional | Empty = your business’s default job type (“General”). Copy an ID from **List Job Types** to book a specific type. |
| Additional Fields → **Duration (Minutes)** | Optional | Empty or 0 = the job type’s default duration. Set it only when you know better, e.g. `90`. |
| Additional Fields → **Description** | Optional | The problem in the customer’s words, e.g. `Furnace stopped heating` (up to 2,000 characters). |
| Additional Fields → **SMS Consent** | Optional | Turn on **only** if the customer explicitly agreed to receive text messages. Otherwise leave it off; they still get email updates. |

Screen in n8n: **Crisphive — Book and Confirm Job** (`your-n8n.example.com/workflow/new`)

1. Choose your Crisphive account credential and set Operation to Book and Confirm Job. — **Operation**: `Book and Confirm Job`
2. Set Customer to New or Returning Caller, so the visit uses the address you send. — **Customer**: `New or Returning Caller`
3. Fill Full Name, Address Line and Start (Business Local Time) — no timezone offset. — **Start (Business Local Time)**: `2026-10-06T10:00:00`
4. Click Add Field under Additional Fields and add Phone (E.164), Email, City, State / Province, Postal Code and Country. — **Phone (E.164)**: `+16135550177`
5. Add a Description of the problem. Leave Job Type ID and Duration empty to use the default type and its duration. — **Description**: `Furnace stopped heating`
6. Click Execute step. The output shows confirmed: true and a short_code such as REQ-CA-… — click **Execute step**

A successful run returns one item like this:

```json
{
  "job_id": "7b2f0c1e-3a44-4d1b-9a5e-0e6f1c2d3b4a",
  "short_code": "REQ-CA-YCNFQUUV",
  "customer_id": "c4d1a9e2-8f3b-4c6d-a1e2-5f7b9c0d1e2f",
  "customer_url": "https://crisphive.com/…",
  "confirmed": true,
  "scheduled_at": "2026-10-06T14:00:00Z",
  "assigned_technician_id": "1e9d7c5b-3a2f-4e1d-8c7b-6a5f4e3d2c1b"
}
```

- `scheduled_at` in the answer is in UTC (`Z`). 14:00 UTC is 10:00 in Ottawa in October — the same moment you asked for.
- `short_code` is the human-friendly job reference to send to the customer or a team channel.
- When `confirmed` is `false`, the job **was saved** but no technician can take it at that time. The answer carries a `refusal` object (for example `"error_code": "JOB_REQUEST_NO_TECHNICIAN_AVAILABLE"`) and the job waits in the coordinator’s queue in the dashboard. Route it to a person — do not run the booking again.

> **Prefer New or Returning Caller even for known customers.** Crisphive matches them by phone or email, and the visit then uses the address you just sent. With **Existing Customer ID**, Crisphive uses the address stored on the customer; a customer with no stored address is refused with `JOB_REQUEST_ADDRESS_REQUIRED`.

## Find Customer by Phone

| Field | Required | Value |
| --- | --- | --- |
| **Phone (E.164)** | Yes | An international number with the leading `+`, e.g. `+16135550177`. The node checks the format before calling Crisphive and stops with “Phone must be E.164 with the leading +” otherwise. |

The match is **exact** on the stored number. The node returns one item with a `customers` list (up to 5) and a `meta` object. Use `{{ $json.customers.length }}` in an **If** node: `1` means you found the caller, `0` means a new caller. Each customer carries `id`, `full_name`, `tier`, `status`, `request_count` and `last_request_at` — the list does not repeat the phone and email.

## Create Customer

| Field | Required | Value |
| --- | --- | --- |
| **Full Name** | Yes | `Alex Martin` |
| Additional Fields → **Phone (E.164)** | Phone or Email | `+16135550177` |
| Additional Fields → **Email** | Phone or Email | `alex.martin@example.com` |
| Additional Fields → **SMS Consent** | Optional | Only if the customer explicitly agreed to texts. |

If you add neither a phone nor an email, the node stops with “Add a Phone or an Email under Additional Fields” before calling Crisphive. The output is `{ "customer_id": "…" }`. A customer created this way has no address yet, so book them with **New or Returning Caller** (which sends the address), not with their ID.

## Get Job and List Job Types

- **Get Job** — one required field, **Job ID**: the job’s UUID (`job_id` from Book and Confirm Job, or `object.id` from the trigger). Returns the full job: `short_code`, `current_status`, `schedule`, `assignment`, `customer` (name, phone, email), `address`, `job_type_name`, `description`.
- **List Job Types** — no fields. Returns your active job types with their IDs and default durations. Copy an `id` into Book and Confirm Job → Additional Fields → **Job Type ID**.

## Crisphive Trigger reference

The **Crisphive Trigger** node is instant: when you publish the workflow, n8n registers a webhook in Crisphive (it appears under Settings → Developer → Webhooks as **n8n trigger**). Crisphive then calls n8n within seconds of each event. Steps 3 to 7 above show it end to end; these are the rules behind it.

- **The key needs the trigger scopes.** Subscribing and removing the webhook needs `developer_manage_api_keys` (**Manage API keys**), and listing the events needs `developer_view` (**View developer settings**) — together `developer_view` and `developer_manage_api_keys`. A restricted key without them is refused when the trigger subscribes (`API_KEY_SCOPE_INSUFFICIENT`); it can still run the Crisphive actions. Creating such a key in the dashboard needs Developer access, which by default only the Owner has.
- **Permissions decide the events.** `customer.*` needs `customers_view`, `job_request.*` needs `job_view`, `technician.*` needs `team_view`. An event the key cannot read is refused with `WEBHOOK_EVENT_NOT_PERMITTED`, naming the missing permission.
- **Event Names or IDs** starts with **Job Completed** chosen; you can choose several events in one trigger. The list is read live from Crisphive, so new events appear without updating the node.
- **Fetch Full Job** (on by default): a job event itself carries only the job’s ID, short code and status; with this on, the node reads the whole job before your workflow continues.
- **Self-hosted only: public HTTPS address.** Crisphive must be able to reach n8n. On a server, set `WEBHOOK_URL` to your public n8n address (for example `https://n8n.yourcompany.com/`) and, behind a reverse proxy, `N8N_PROXY_HOPS=1`. On a laptop, run a tunnel and set `WEBHOOK_URL` to the tunnel address — and open n8n **on that address**, not on `localhost`. n8n Cloud needs none of this.
- **Up to 25 active webhooks per environment** per business. Every published trigger uses one.

Each event becomes one item:

```json
{
  "event_id": "evt_…",
  "type": "job_request.completed",
  "object": {
    "id": "7b2f0c1e-3a44-4d1b-9a5e-0e6f1c2d3b4a",
    "short_code": "REQ-CA-YCNFQUUV",
    "current_status": { "key": "completed", "display_name": "Completed" },
    "customer": { "name": "Alex Martin", "phone": "+16135550177", "email": "alex.martin@example.com" },
    "address": { "line": "145 Laurier Avenue West", "…": "…" },
    "schedule": { "scheduled_at": "2026-10-06T14:00:00Z", "…": "…" }
  }
}
```

| Event (as listed in n8n) | ID | Fires when |
| --- | --- | --- |
| Job Created | `job_request.created` | A job is booked from any channel. |
| Job Confirmed | `job_request.confirmed` | A job gets a confirmed time. |
| Job Assigned | `job_request.assigned` | A technician or crew is assigned. |
| Job Rescheduled | `job_request.rescheduled` | A confirmed job moves to another time. |
| Job Held | `job_request.held` | An online booking is given an unconfirmed time slot (booking hold). |
| Job Hold Released | `job_request.hold_released` | A booking hold ends without a booking. |
| Job Completed | `job_request.completed` | The job reaches Completed. |
| Job Archived | `job_request.archived` | The job is archived or cancelled. |
| Job Status Changed | `job_request.status_changed` | The job moves to another workflow status (for example On the way, Arrived). |
| Job Priority Changed | `job_request.priority_changed` | The job’s priority changes. |
| Customer Created / Updated / Deleted | `customer.*` | A customer record changes. |
| Technician Created / Updated / Deleted | `technician.*` | Your team roster changes (needs `team_view`). |

- **Security.** Every delivery carries a `Crisphive-Signature` header (HMAC-SHA256 of the exact request body with the subscription’s secret). The node checks it, refuses anything unsigned or older than 5 minutes with `401`, and never starts the workflow for a forged call. Crisphive’s first message, a `ping`, is answered and ignored.
- **Lifetime.** The node asks for the maximum secret lifetime, **365 days**. After that Crisphive disables the webhook and emails the Owner; unpublish the workflow and publish it again to subscribe again. Put the date in your calendar.
- **A subscription stops by itself** when the API key that created it is revoked. If you replace the key, unpublish and publish again every workflow that has a Crisphive Trigger.

## Use Crisphive from an n8n AI Agent

There are two ways. Choose option A to use the Crisphive node you installed (on n8n Cloud or self-hosted). Choose option B if you want the agent to pick from the Crisphive MCP tools itself.

**Option A — the Crisphive node as a tool.**

1. **Add an AI Agent** — Add an **AI Agent** node with a chat model (any model n8n supports; one that is good at multi-step tool calling works best).
2. **Attach Crisphive** — Under the agent’s **Tool** connector click **+**, search **Crisphive** and add it. Pick the credential and an **Operation**. Add the node once per operation you want the agent to have — for a booking agent: Find Customer by Phone, List Job Types and Book and Confirm Job.
3. **Let the model fill the fields** — For each field the agent should decide (Full Name, Address Line, Start, Phone…), use n8n’s “let the model define this parameter” option instead of a fixed value.
4. **Give it instructions** — Paste the system prompt below into the agent’s system message, then chat with it from the workflow’s chat panel.

**Option B — the MCP Client Tool (no installation).**

1. **Create a Header Auth credential** — New credential → **Header Auth**. Name: `Authorization`. Value: `Bearer chsk_test_…` — the word Bearer, one space, then your key.
2. **Attach an MCP Client Tool** — On the AI Agent’s **Tool** connector add **MCP Client Tool**.
3. **Point it at Crisphive** — **Endpoint**: `https://api.crisphive.com/mcp/crm` — customers and their bookings, all covered by the five booking scopes. For a phone-style agent use `https://api.crisphive.com/mcp/voice` instead. **Server Transport**: **HTTP Streamable** — Crisphive has no SSE stream, so the SSE setting cannot connect. **Authentication**: **Header Auth** with the credential above. **Tools to Include**: All.
4. **Pick the profile that fits the agent** — `/mcp/crm` holds customers and their bookings, `/mcp/voice` caller lookup and one-call booking, `/mcp/dispatch` the coordinator’s board. The full `/mcp` address offers every Crisphive tool and needs a key with wider scopes than the five booking ones.

Screen in n8n: **MCP Client Tool** (`your-n8n.example.com/workflow/new`)

1. Set Endpoint to https://api.crisphive.com/mcp/crm (or /mcp/voice for a phone-style agent). — **Endpoint**: `https://api.crisphive.com/mcp/crm`
2. Choose HTTP Streamable as the Server Transport. — **Server Transport**: `HTTP Streamable`
3. Set Authentication to Header Auth and pick the credential whose value is “Bearer chsk_test_…”. — **Authentication**: `Header Auth`
4. Leave Tools to Include on All, then close the node and chat with the agent. — **Tools to Include**: `All`

System prompt for a booking agent (replace the bracketed parts):

```
You book service visits for [Business name], a [trade] company in [city].
Times are in [Business timezone, e.g. America/Toronto].

1. Ask for the customer's phone number and look them up with "Find Customer
   by Phone" (E.164, e.g. +16135550177). If one customer comes back, greet
   them by name. Never guess between several matches.
2. Always ask for and confirm the service address for THIS visit (street,
   city, postal code), and spell the customer's name back before booking.
3. Ask what the problem is; it becomes the job description.
4. Agree a start time. Send it as the business's local time with no offset,
   e.g. 2026-10-06T10:00:00.
5. Book once with "Book and Confirm Job", Customer = New or Returning Caller,
   with the name, phone (or email) and the address. Do not retry.
6. Only if confirmed is true, read back the date, time and short_code. If it
   is false, say the office will call back to confirm a time.

Rules: never quote a price. Only turn on SMS Consent if the customer
explicitly agrees to text messages.
```

## Retries never book twice

Every write the node makes carries an **Idempotency-Key** — a label that tells Crisphive “this is the same request as before”. The node builds it from the n8n execution ID and the item number. So:

- If a Crisphive step fails on a network blip and n8n retries it inside the same execution (the node’s **Retry On Fail** setting), Crisphive replays the first answer instead of booking a second job.
- Each item in one execution gets its own key, so ten form rows book ten jobs.
- A **new** execution — a new trigger event, or running the workflow again by hand — is a new booking. That is why you must not re-run a booking whose answer was `confirmed: false`: the job already exists in the queue.
- Writes are Book and Confirm Job and Create Customer. Reads (Find Customer, Get Job, List Job Types) are always safe to repeat.

## Test the actions

Use these fictional details. The 555-01xx range and `example.com` are reserved for fiction, and Crisphive never texts or emails them.

1. **Create the test customer** — Run **Create Customer** with Full Name `Alex Martin`, Phone `+16135550177`, Email `alex.martin@example.com`. Success: the output has a `customer_id`.
2. **Find them** — Run **Find Customer by Phone** with `+16135550177`. Success: `customers` holds one entry named Alex Martin.
3. **Book a visit** — Run **Book and Confirm Job** as in the walkthrough: New or Returning Caller, `Alex Martin`, `145 Laurier Avenue West`, City `Ottawa`, State `ON`, Postal Code `K1P 5J3`, Country `CA`, Phone `+16135550177`, Description `Furnace stopped heating`, Start = a weekday morning within your working hours, e.g. `2026-10-06T10:00:00`. Success: `confirmed: true`, a `short_code`, and the same `customer_id` as step 1 (matched, not duplicated).
4. **Check Crisphive** — Switch the dashboard to **Rehearsal**. The job appears on the board with status **Confirmed** (opened, its window is titled **Booking Confirmed**), a technician assigned, the Laurier Avenue address and the time you chose.
5. **Fire the trigger** — With a Crisphive Trigger set to **Job Completed** and listening (**Test this trigger**), complete that Rehearsal job on the dashboard. Success: within seconds the trigger outputs `type: "job_request.completed"` with `object.short_code` matching.

## Self-hosted n8n: install from Community Nodes

On a self-hosted n8n (Docker, npm, your own server), install the package yourself. You need to be the n8n owner or an admin.

1. **Open Community Nodes** — In n8n, open **Settings** (bottom-left menu) → **Community Nodes**.
2. **Install the package** — Click **Install**, type `n8n-nodes-crisphive` as the npm package name, tick the box confirming you understand the risk of installing community code, and click **Install**.
3. **Check the version** — The package appears in the list. It should be **0.1.3** or later — use **Update** if offered. Then follow Steps 2 to 7 above.

> No **Community Nodes** entry? Your n8n has community packages switched off: start it with `N8N_COMMUNITY_PACKAGES_ENABLED=true`. In queue mode with separate workers, install the package on every worker too, as described in n8n’s community-node documentation. For the trigger, Crisphive must reach your n8n over public HTTPS: set `WEBHOOK_URL` to your public n8n address (and `N8N_PROXY_HOPS=1` behind a reverse proxy).

## Good to know

- **The customer’s email is in the job only if the customer has one.** Customers created from a phone call often have only a phone number.
- **The webhook lasts one year.** Crisphive gives it a 365-day signing secret. The Owner and Administrators get an email 7 days before it ends.
- **The key lasts the days you chose** (30 in Step 2). A key cannot be extended: before it expires, create a new key, paste it into the **Crisphive account** credential, and revoke the old one.
- **Each confirmed job is one n8n execution.** The n8n Cloud trial counts them (*0/1000 Executions*).

## Troubleshooting

| Symptom | Cause | Fix |
| --- | --- | --- |
| Credential test fails, or a node says `Crisphive API_KEY_INVALID` | Key mistyped, revoked, or a publishable `chpk_` key. | Paste a secret `chsk_test_…` / `chsk_live_…` key again, with no spaces. |
| `API_KEY_EXPIRED` | The key reached the end of its lifetime. | Create a new key, paste it into the **Crisphive account** credential, revoke the old one, and publish again the workflows that use the Crisphive Trigger. |
| `API_KEY_SCOPE_INSUFFICIENT` (403) | The key is restricted and lacks a permission; the error names it. | Create a key that also has that permission: the five booking scopes for actions, plus `developer_view` and `developer_manage_api_keys` for the Crisphive Trigger (and `team_view` for technician events). If the error names `developer_manage_api_keys`, the key lacks the trigger scope. |
| Turning the trigger on fails with `WEBHOOK_EVENT_NOT_PERMITTED` | The key cannot read that event type (the message ends with “needs permission: …”). | Create a key that also has the listed permission — `team_view` for technician events. |
| The trigger only catches **Job Completed** events | **Event Names or IDs** starts with Job Completed already chosen. | Remove Job Completed and choose the event you want, for example **Job Confirmed**. |
| The email’s **When** shows the wrong hour | Crisphive sends times in UTC. | Use `setZone($json.object.schedule.business_timezone)` as in the Message block, not a fixed time zone. |
| Trigger never fires after publishing | The workflow is not **Published**, the event is not the one chosen — or, on self-hosted n8n, Crisphive cannot reach it (`WEBHOOK_URL` is `localhost` or a private address). | Check the workflow shows **Published** and look at its **Executions** tab. In Crisphive, **Settings → Developer → Webhooks** should list an **Active** endpoint named **n8n trigger**. Self-hosted: set `WEBHOOK_URL` to a public HTTPS address, restart n8n, then publish the workflow again. |
| `WEBHOOK_LIMIT_REACHED` | 25 webhooks are already active in this environment. | Unpublish workflows you no longer need, or delete stale endpoints under Settings → Developer → Webhooks. |
| “Phone must be E.164 with the leading +”, or `PHONE_INVALID` | The number has no country code, e.g. `6135550177`. | Send `+16135550177`. In an expression: `{{ "+1" + $json.phone.replace(/\D/g, "") }}` for North American numbers. |
| “A new caller needs a Phone or an Email under Additional Fields” | New or Returning Caller without any contact detail. | Add Phone (E.164) or Email under Additional Fields. |
| `JOB_REQUEST_ADDRESS_REQUIRED` | Existing Customer ID was used for a customer with no address on file, or the address has neither city nor postal code. | Switch Customer to New or Returning Caller and send the address with City or Postal Code. |
| `confirmed: false` with a `refusal` | The job was saved, but no technician can take it then (outside working hours, no one covering that area or skill, everyone busy). | Do not rerun. Pick the job up in the dashboard queue, or branch on `confirmed` and notify a person. |
| `JOB_REQUEST_INVALID_INPUT` about the time, or `data.means_locally` | Start carried a timezone offset (`Z`, `-04:00`) or is in the past. | Send the business’s local wall clock with no offset, in the future: `2026-10-06T10:00:00`. |
| `JOB_REQUEST_QUOTE_INVALID`, reason `job_type_has_no_default_duration` | The chosen job type has no default duration. | Set one in Settings → Job Types, fill Duration (Minutes), or leave Job Type ID empty. |
| `IDEMPOTENCY_KEY_REUSE` (422) | The same key was sent with a different body — for example a corrected request resent after an error, because Crisphive stores the first answer (even a refusal) under its key. | Reuse a key only to resend the exact same request after a timeout or no answer; when anything in the request changes, run a fresh execution so it gets a new key. |
| `429` / `TOO_MANY_REQUESTS` | More than 240 requests per minute on one key. | Add a Wait node or batch your items; respect `Retry-After`. |
| Crisphive Trigger answers `401 invalid signature` in n8n’s logs | Something other than Crisphive called the webhook URL, or n8n lost the stored secret. | Nothing to do for stray calls. If real events are refused, unpublish the workflow and publish it again to subscribe again. |
| No **Install** button under Settings → Community nodes on n8n Cloud | On n8n Cloud that page lists only verified packages; installing happens in the workflow editor. | Click **Add first step…** (or **+**), search `Crisphive`, open it and click **Install node** — see [Step 3](https://docs.crisphive.com/docs/n8n#install). |
| Self-hosted: **Community Nodes** is missing | Community packages are switched off. | Start n8n with `N8N_COMMUNITY_PACKAGES_ENABLED=true`, then install `n8n-nodes-crisphive` — see [Self-hosted n8n](https://docs.crisphive.com/docs/n8n#self-hosted). |

## Go live

1. **Create a live key** — Switch the Crisphive dashboard to **Live** (confirm with **Switch**), then repeat [Step 2](https://docs.crisphive.com/docs/n8n#api-key): the new key starts with `chsk_live_`. Choose a lifetime up to 365 days and put the expiry date in your calendar; the Owner and Administrators are also emailed 7 days before.
2. **Add a second credential** — In the Crisphive Trigger’s **Credential**, create another Crisphive credential with the live key (give it a name that says Live), and switch each Crisphive node and trigger to it.
3. **Publish again** — Publish every workflow with a Crisphive Trigger again so it subscribes with the live key. Rehearsal triggers only ever receive Rehearsal events.
4. **Understand what changes** — With a live key, jobs land on your real board, real technicians are assigned, and real customers receive confirmations by email (and by text only when SMS Consent was given).
5. **Renew or revoke** — A key cannot be extended. To renew, create a new live key, put it in the credential, check a run succeeds, then click **Revoke access** on the old key in Settings → Developer → API Keys. Revoking a key stops every workflow and trigger that uses it immediately.

## Related guides and reference

- [Automation platforms overview](https://docs.crisphive.com/docs/automation-platforms) — what every automation integration shares
- [Zapier](https://docs.crisphive.com/docs/zapier) — book jobs from any Zap; instant job and customer triggers
- [Make](https://docs.crisphive.com/docs/make) — the same booking and triggers in Make scenarios
- [MCP server reference](https://docs.crisphive.com/mcp) — every tool, the tool profiles and client setup
- [Webhooks reference](https://docs.crisphive.com/webhooks) — events, signatures and retries
- [Book and confirm a job](https://docs.crisphive.com/technical-reference/book-and-confirm-job-request) — the API call behind every booking step

## FAQ

**Is the Crisphive n8n node free?**

Yes. `n8n-nodes-crisphive` is open source under the MIT licence. You need a Crisphive account; self-hosted n8n Community Edition is free to run, and n8n Cloud has its own plans (a new account starts with a 14-day trial).

**How do I use Crisphive on n8n Cloud?**

The Crisphive node is a Verified node on n8n Cloud. In a workflow, click **Add first step…** (or **+**), search `Crisphive`, open it and click **Install node**. Then add **On new Crisphive event** or one of the five actions and connect your API key.

**How do I install the Crisphive node on self-hosted n8n?**

Open **Settings → Community Nodes**, click **Install** and enter `n8n-nodes-crisphive`. Community packages must be enabled (`N8N_COMMUNITY_PACKAGES_ENABLED=true`).

**Does n8n book a duplicate job if a step is retried?**

No. Each write carries an Idempotency-Key built from the execution and item, so a retry inside the same execution replays the first answer. A new execution is a new booking.

**Why did my job not confirm?**

The answer had `confirmed: false`: the job is saved, but no technician could take it at that time — outside working hours, nobody covering that address or skill, or everyone busy. The `refusal.error_code` says which. Pick it up from the coordinator queue; do not rerun.

**Who in my company can turn on a Crisphive Trigger?**

Someone with Developer access, which by default is only the Owner. The Owner can grant the Developer module to another group in Settings → Permissions. Actions work with any key that has the right permissions.

**What is the difference between a chsk_test_ and a chsk_live_ key?**

`chsk_test_` works on an isolated sandbox copy of your business — no real customer is ever contacted. `chsk_live_` works on your real jobs and customers. Build with the test key, switch when it works.

**What can the API key do, and how do I limit it?**

Exactly what its permissions allow. Restrict it to `customers_view`, `customers_manage`, `job_view`, `job_create` and `job_manage` for the actions, plus `developer_view` and `developer_manage_api_keys` for the trigger (the seven scopes in Step 2). It cannot change your team, settings or billing with those.

**How do I remove n8n’s access to Crisphive?**

In Crisphive, open Settings → Developer → API Keys and click **Revoke access** on the key. Every node and trigger using it stops at once, and its webhooks are disabled.

**How long does a Crisphive Trigger keep working?**

Its signing secret lasts 365 days. Crisphive then disables the webhook and emails the Owner; unpublish the workflow and publish it again to subscribe again. It also stops when the key that created it is revoked.