@elitedcs/ghl-mcp 3.65.3 → 3.66.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 3.66.0 — webhooks work now
+
+The five webhook tools have never worked for anyone. They called an address
+GoHighLevel does not have, so every call returned "not found" no matter what you
+asked for. They are rebuilt, and this time each step was proven against a real
+account before it was written down.
+
+GoHighLevel does not offer a way to manage webhooks directly. What it does offer
+is a workflow step that sends data out, so that is what these tools now build.
+A webhook is a small workflow in the client's own account, which turns out to be
+better than the thing that was missing:
+
+- **It can fire on almost anything**, not just a new contact. A tag added, a
+  pipeline stage changed, an appointment no showed, a call missed.
+- **The client can see it.** It sits in their Automation list where they can read
+  it, pause it, and edit it, instead of being invisible plumbing.
+- **You can add your own fields and your own headers**, and merge fields fill in,
+  so the contact's first name arrives already filled. All of that works on every
+  plan.
+
+**Two things worth knowing before you point one at production**, both measured
+live rather than assumed:
+
+- **`tags` arrives as one line of comma separated text, not a list.** Code that
+  checks whether it contains "vip" will also match a contact tagged
+  "vip-waitlist". This is in every one of the tool descriptions now.
+- **If the receiving app is down, GoHighLevel keeps retrying**, about five
+  minutes later and then about ten. Nothing is thrown away. But the contact waits
+  at that step, and so does every step after it. If the send is not critical, put
+  it at the end of a workflow or give it a workflow of its own.
+
+Deleting a webhook refuses to run if that workflow also does other things, so
+"delete the webhook" can never quietly take a client's nurture sequence with it.
+
+New guide: **Send GHL data to another app.** Guide coverage is now 39 of 50.
+
 ## 3.65.3 — the guide now covers most of what you are paying for
 
 The library had guides for 20 of the 50 areas the product touches. Six shipped

package/dist/index.js

@@ -2854,7 +2854,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@elitedcs/ghl-mcp",
-      version: "3.65.3",
+      version: "3.66.0",
       mcpName: "io.github.drjerryrelth/ghl-command",
       description: "GoHighLevel MCP Server for Claude. 238 tools \u2014 full CRM, automation, marketing control, account-wide workflow audit, live funnel-capture verification, and the only programmatic GHL workflow builder, now multi-tenant across client accounts.",
       main: "dist/index.js",
@@ -5757,6 +5757,41 @@ function validateActionChain(actions, existingIds) {
       case "remove_from_workflow":
         if (!attr.workflowId || !Array.isArray(attr.workflow_id)) throw new Error(`Remove from workflow action "${action.name}" needs BOTH 'workflowId' string AND 'workflow_id' array.`);
         break;
+      case "webhook": {
+        if (typeof attr.url !== "string" || !attr.url.trim()) {
+          throw new Error(`Webhook action "${action.name}" needs a 'url' in attributes.`);
+        }
+        if (!/^https?:\/\//i.test(attr.url.trim())) {
+          throw new Error(
+            `Webhook action "${action.name}" has a url that does not start with http:// or https:// ("${attr.url}"). GHL saves it and then never fires it.`
+          );
+        }
+        if (typeof attr.method !== "string" || !attr.method.trim()) {
+          throw new Error(`Webhook action "${action.name}" needs a 'method' in attributes (POST, GET or PUT).`);
+        }
+        if (!["POST", "GET", "PUT"].includes(attr.method.trim().toUpperCase())) {
+          throw new Error(
+            `Webhook action "${action.name}" has method "${attr.method}". GHL's builder only offers POST, GET and PUT.`
+          );
+        }
+        for (const field of ["customData", "headers"]) {
+          const entries = attr[field];
+          if (entries === void 0) continue;
+          if (!Array.isArray(entries)) {
+            throw new Error(`Webhook action "${action.name}" needs '${field}' to be an array of {key, value} pairs.`);
+          }
+          for (const entry of entries) {
+            const key = isRecord(entry) ? entry.key : void 0;
+            const value = isRecord(entry) ? entry.value : void 0;
+            if (typeof key !== "string" || !key.trim() || value === void 0 || value === null) {
+              throw new Error(
+                `Webhook action "${action.name}" has an empty '${field}' pair. Every entry needs a non-empty key and a value.`
+              );
+            }
+          }
+        }
+        break;
+      }
     }
   }
   for (const action of actions) {
@@ -10041,93 +10076,300 @@ function registerCouponTools(server2, client) {
 
 // src/tools/webhooks.ts
 var import_zod34 = require("zod");
-function registerWebhookTools(server2, client) {
-  safeTool(
-    server2,
+var WEBHOOK_PAYLOAD_NOTE = "PAYLOAD GHL SENDS (captured live, not from docs): contact_id, first_name, last_name, full_name, email, phone, tags, country, date_created, contact_source, full_address, contact_type, plus a `location` object, a `workflow` object ({id, name}), `triggerData`, and your `customData`. Sent as application/json. WATCH OUT: `tags` arrives as a COMMA-SEPARATED STRING (\"vip,newsletter\"), NOT an array \u2014 splitting is on you, and a substring check like tags.includes('vip') matches 'vip-waitlist' too. `triggerData` was empty for a contact_tag trigger.";
+var WEBHOOK_FAILURE_NOTE = "IF YOUR ENDPOINT IS DOWN (measured live against an HTTP 500, with a control run on the same workflow; GHL documents none of this): GHL does NOT silently drop the call. It retries, with a doubling gap of roughly 5 minutes then roughly 10. How many times it retries before giving up is UNKNOWN \u2014 the test ended first. The finding that matters more: the contact STOPS at that step and never reaches the rest of the workflow. In the controlled pair, the contact whose webhook returned 200 completed every later step; the contact whose webhook returned 500 never reached the next step at all. So a dead receiver does not lose data, it halts the workflow for every contact flowing through it. If the webhook is not critical, put it at the END of a workflow, or give it a workflow of its own, so an outage cannot hold up the steps that matter.";
+var ALLOWED_METHODS = ["POST", "GET", "PUT"];
+var KeyValueSchema = import_zod34.z.object({
+  key: import_zod34.z.string().describe("Key name. Cannot be empty."),
+  value: import_zod34.z.string().describe("Value. Merge fields such as {{contact.first_name}} resolve at send time.")
+});
+var EventSchema = import_zod34.z.union([
+  import_zod34.z.string().describe("A GHL trigger type, e.g. 'contact_created'. Fires with no filter."),
+  import_zod34.z.object({
+    type: import_zod34.z.string().describe("A GHL trigger type, e.g. 'contact_tag' or 'pipeline_stage_updated'."),
+    conditions: import_zod34.z.array(import_zod34.z.record(import_zod34.z.unknown())).optional().describe(
+      "Filter conditions, exactly as update_workflow_actions takes them. Use get_trigger_registry to find the valid fields for a trigger type. Omit to fire on every event of that type."
+    )
+  })
+]);
+function buildWebhookAction(input) {
+  const url = (input.url ?? "").trim();
+  if (!url) throw new Error("A webhook needs a 'url'.");
+  if (!/^https?:\/\//i.test(url)) {
+    throw new Error(
+      `Webhook url must start with http:// or https:// (got "${url}"). GHL saves any string here and then never fires.`
+    );
+  }
+  const method = (input.method ?? "POST").toUpperCase();
+  if (!ALLOWED_METHODS.some((m) => m === method)) {
+    throw new Error(`Webhook method must be one of POST, GET, PUT (got "${input.method}").`);
+  }
+  const pairs = (entries, field) => {
+    const list = entries ?? [];
+    for (const entry of list) {
+      if (!entry || typeof entry.key !== "string" || !entry.key.trim()) {
+        throw new Error(`Every ${field} entry needs a non-empty key. GHL only warns about this, then delivers nothing.`);
+      }
+      if (entry.value === void 0 || entry.value === null) {
+        throw new Error(`${field} entry "${entry.key}" needs a value.`);
+      }
+    }
+    return list;
+  };
+  const action = {
+    name: input.name?.trim() || "Webhook",
+    type: "webhook",
+    cat: "actions",
+    attributes: {
+      method,
+      url,
+      customData: pairs(input.customData, "customData"),
+      headers: pairs(input.headers, "headers")
+    }
+  };
+  return input.id ? { ...action, id: input.id } : action;
+}
+function buildWebhookTriggers(events) {
+  if (!events?.length) {
+    throw new Error("A webhook needs at least one event \u2014 a workflow with no trigger never fires.");
+  }
+  return events.map((event) => {
+    const type = typeof event === "string" ? event : event.type;
+    if (!type?.trim()) throw new Error("Each event needs a trigger 'type'.");
+    const conditions = typeof event === "string" ? [] : event.conditions ?? [];
+    return WorkflowTriggerSchema.parse({ name: type, type, conditions });
+  });
+}
+var KeyValueListSchema = import_zod34.z.array(KeyValueSchema).catch([]);
+function readKeyValues(value) {
+  const LooseEntry = import_zod34.z.object({ key: import_zod34.z.unknown(), value: import_zod34.z.unknown() }).transform((entry) => ({ key: String(entry.key ?? ""), value: String(entry.value ?? "") }));
+  return KeyValueListSchema.parse(import_zod34.z.array(LooseEntry).catch([]).parse(value));
+}
+function replaceWebhookAttributes(templates, target, attributes) {
+  return templates.map((action) => {
+    if (!action.id || action.id !== target.id) return action;
+    if (action.type !== "webhook") return action;
+    return { ...action, attributes };
+  });
+}
+function readId(workflow) {
+  const record = workflow;
+  const id = workflow._id ?? record.id;
+  return typeof id === "string" ? id : "";
+}
+function summarizeWebhookWorkflow(workflow) {
+  const templates = workflow.workflowData?.templates ?? [];
+  const webhookActions = templates.filter((action) => action.type === "webhook");
+  if (!webhookActions.length) return null;
+  const actions = webhookActions.map((action) => {
+    const attributes = action.attributes ?? {};
+    return {
+      actionId: action.id,
+      name: action.name,
+      url: typeof attributes.url === "string" ? attributes.url : "",
+      method: typeof attributes.method === "string" ? attributes.method : "",
+      customData: readKeyValues(attributes.customData),
+      headers: readKeyValues(attributes.headers)
+    };
+  });
+  return {
+    webhookId: readId(workflow),
+    name: workflow.name,
+    status: workflow.status,
+    events: (workflow.triggers ?? []).map((trigger) => trigger.type),
+    actions,
+    hasOtherActions: templates.length > webhookActions.length
+  };
+}
+var WorkflowListSchema = import_zod34.z.object({ rows: import_zod34.z.array(import_zod34.z.object({ _id: import_zod34.z.string().optional(), id: import_zod34.z.string().optional() }).passthrough()).optional() }).passthrough();
+function registerWebhookTools(server2, builderClient) {
+  const requireClient = () => {
+    if (!builderClient) {
+      throw new Error(
+        "Webhooks run on GHL's workflow builder, which needs Firebase credentials. Run enable_workflow_builder (or health_check) to set them up."
+      );
+    }
+    return builderClient;
+  };
+  const loadWebhooks = async (client, limit) => {
+    const listed = WorkflowListSchema.parse(await client.listWorkflows(limit, 0));
+    const rows = listed.rows ?? [];
+    const webhooks = [];
+    for (const row of rows) {
+      const id = row._id ?? row.id;
+      if (!id) continue;
+      const summary = summarizeWebhookWorkflow(await client.getWorkflow(id));
+      if (summary) webhooks.push(summary);
+    }
+    return { webhooks, scanned: rows.length };
+  };
+  server2.tool(
     "list_webhooks",
-    "List all webhooks configured in a GHL location.",
+    "List every webhook in the current sub-account. A webhook here is a workflow that fires a `webhook` action, so this also finds ones built by hand in the GHL UI. Returns the URL, HTTP method and triggering events for each. NOTE: GoHighLevel has no webhook REST API (it is Marketplace-OAuth only) \u2014 webhooks live on the workflow layer, which is why each one has a workflow ID and shows up in the client's Automation list. " + WEBHOOK_PAYLOAD_NOTE,
     {
-      locationId: import_zod34.z.string().optional().describe("GHL Location ID. Optional if GHL_LOCATION_ID is set in env.")
+      limit: import_zod34.z.number().int().positive().max(200).optional().describe(
+        "How many workflows to scan. Defaults to 50, capped at 200. Each one is opened individually, so a large scan takes a while \u2014 the response says how many were covered and whether more remain."
+      )
     },
-    async ({ locationId: locationId2 }) => {
-      const resolvedLocationId = client.resolveLocationId(locationId2);
-      return client.get(`/webhooks/`, {
-        params: { locationId: resolvedLocationId }
-      });
+    async ({ limit }) => {
+      try {
+        const client = requireClient();
+        const { webhooks, scanned } = await loadWebhooks(client, limit ?? 50);
+        return jsonResponse({
+          webhooks,
+          _scan: {
+            workflowsScanned: scanned,
+            note: scanned >= (limit ?? 50) ? `Scanned the first ${scanned} workflows \u2014 there may be more. Raise 'limit' to cover them.` : `Scanned all ${scanned} workflows in this sub-account.`
+          }
+        });
+      } catch (error) {
+        return errorResponse(error);
+      }
     }
   );
-  safeTool(
-    server2,
+  server2.tool(
     "get_webhook",
-    "Retrieve a single webhook by its ID.",
+    "Get one webhook by ID (the ID is its workflow ID, as returned by list_webhooks or create_webhook). Shows the destination URL, method, custom data, custom headers and triggering events. " + WEBHOOK_PAYLOAD_NOTE + " " + WEBHOOK_FAILURE_NOTE,
     {
-      webhookId: import_zod34.z.string().describe("The webhook ID to retrieve."),
-      locationId: import_zod34.z.string().optional().describe("GHL Location ID. Optional if GHL_LOCATION_ID is set in env.")
+      webhookId: import_zod34.z.string().describe("The webhook ID \u2014 the workflow ID that carries the webhook action.")
     },
-    async ({ webhookId, locationId: locationId2 }) => {
-      const resolvedLocationId = client.resolveLocationId(locationId2);
-      return client.get(`/webhooks/${webhookId}`, {
-        params: { locationId: resolvedLocationId }
-      });
+    async ({ webhookId }) => {
+      try {
+        const client = requireClient();
+        const summary = summarizeWebhookWorkflow(await client.getWorkflow(webhookId));
+        if (!summary) {
+          return jsonResponse({
+            error: `Workflow ${webhookId} exists but fires no webhook action. Use list_webhooks to see the ones that do.`
+          });
+        }
+        return jsonResponse(summary);
+      } catch (error) {
+        return errorResponse(error);
+      }
     }
   );
-  safeTool(
-    server2,
+  server2.tool(
     "create_webhook",
-    "Create a new webhook subscription for GHL events.",
+    "Create a webhook: GHL POSTs to your URL whenever the events you name happen. Builds a real workflow with a `webhook` action, so the client can see and edit it in Automation. Because it rides the workflow layer, it can fire on ANY of GHL's 57 native triggers, not just the short list GHL's documented webhook API covers. Use `customData` to add your own key/value pairs to the body (merge fields like {{contact.first_name}} resolve), and `headers` for auth headers or signatures. Both work on every plan \u2014 GHL's separate 'Custom Webhook' action is a paid add-on and is only needed to replace GHL's contact body wholesale. " + WEBHOOK_PAYLOAD_NOTE + " " + WEBHOOK_FAILURE_NOTE,
     {
-      locationId: import_zod34.z.string().optional().describe("GHL Location ID. Optional if GHL_LOCATION_ID is set in env."),
-      name: import_zod34.z.string().describe("Webhook name."),
-      url: import_zod34.z.string().describe("The URL to POST events to."),
-      events: import_zod34.z.array(import_zod34.z.string()).describe(
-        "List of event types to subscribe to (e.g. 'ContactCreate', 'AppointmentCreate', 'OpportunityStatusUpdate')."
-      )
+      url: import_zod34.z.string().describe("Destination URL. Must start with http:// or https://."),
+      events: import_zod34.z.array(EventSchema).describe(
+        "Which GHL events fire this webhook. Either a trigger type string ('contact_created') or {type, conditions} for a filtered trigger. Use get_trigger_registry for the 57 types and their fields."
+      ),
+      name: import_zod34.z.string().optional().describe("Name shown in the client's workflow list. Defaults to 'Webhook \u2192 <host>'."),
+      method: import_zod34.z.string().optional().describe("POST (default), GET or PUT."),
+      customData: import_zod34.z.array(KeyValueSchema).optional().describe("Extra key/value pairs added to the body under `customData`."),
+      headers: import_zod34.z.array(KeyValueSchema).optional().describe("Extra HTTP headers sent with the request."),
+      publish: import_zod34.z.boolean().optional().describe("Publish immediately so it starts firing. Defaults to true. False leaves it as a draft.")
     },
-    async ({ locationId: locationId2, name, url, events }) => {
-      const resolvedLocationId = client.resolveLocationId(locationId2);
-      return client.post(`/webhooks/`, {
-        body: {
-          locationId: resolvedLocationId,
-          name,
-          url,
-          events
+    async ({ url, events, name, method, customData, headers, publish }) => {
+      try {
+        const client = requireClient();
+        const action = buildWebhookAction({ url, method, customData, headers });
+        const triggers = buildWebhookTriggers(events);
+        let host = url;
+        try {
+          host = new URL(url).host;
+        } catch {
         }
-      });
+        const workflowName = name?.trim() || `Webhook \u2192 ${host}`;
+        const created = await client.createWorkflow(workflowName);
+        const webhookId = readId(created);
+        await client.updateWorkflow(webhookId, {
+          actions: [action],
+          triggers,
+          status: publish === false ? "draft" : "published"
+        });
+        const summary = summarizeWebhookWorkflow(await client.getWorkflow(webhookId));
+        return jsonResponse({
+          created: summary,
+          note: publish === false ? "Created as a DRAFT \u2014 it will not fire until you publish it." : "Published and live. Fire a test event to confirm it reaches your endpoint."
+        });
+      } catch (error) {
+        return errorResponse(error);
+      }
     }
   );
-  safeTool(
-    server2,
+  server2.tool(
     "update_webhook",
-    "Update an existing webhook (name, URL, or subscribed events).",
+    "Change a webhook's URL, method, custom data, headers, name, events, or published status. Edits the existing action in place rather than replacing it, so the workflow's history and any other steps around it survive. Only the fields you pass change; everything else is left alone.",
     {
-      webhookId: import_zod34.z.string().describe("The webhook ID to update."),
-      locationId: import_zod34.z.string().optional().describe("GHL Location ID. Optional if GHL_LOCATION_ID is set in env."),
-      name: import_zod34.z.string().optional().describe("Updated webhook name."),
-      url: import_zod34.z.string().optional().describe("Updated webhook URL."),
-      events: import_zod34.z.array(import_zod34.z.string()).optional().describe("Updated list of event types.")
+      webhookId: import_zod34.z.string().describe("The webhook ID (its workflow ID)."),
+      url: import_zod34.z.string().optional().describe("New destination URL."),
+      method: import_zod34.z.string().optional().describe("POST, GET or PUT."),
+      customData: import_zod34.z.array(KeyValueSchema).optional().describe("Replaces the existing custom data entirely."),
+      headers: import_zod34.z.array(KeyValueSchema).optional().describe("Replaces the existing headers entirely."),
+      name: import_zod34.z.string().optional().describe("New name for the workflow."),
+      events: import_zod34.z.array(EventSchema).optional().describe("Replaces the triggering events entirely."),
+      status: import_zod34.z.enum(["draft", "published"]).optional().describe("Publish it or take it back to draft (stops it firing)."),
+      actionId: import_zod34.z.string().optional().describe("Required only when the workflow carries more than one webhook action \u2014 which one to edit.")
     },
-    async ({ webhookId, locationId: locationId2, name, url, events }) => {
-      const resolvedLocationId = client.resolveLocationId(locationId2);
-      const body = { locationId: resolvedLocationId };
-      if (name !== void 0) body.name = name;
-      if (url !== void 0) body.url = url;
-      if (events !== void 0) body.events = events;
-      return client.put(`/webhooks/${webhookId}`, { body });
+    async ({ webhookId, url, method, customData, headers, name, events, status, actionId }) => {
+      try {
+        const client = requireClient();
+        const current = await client.getWorkflow(webhookId);
+        const templates = current.workflowData?.templates ?? [];
+        const webhookActions = templates.filter((a) => a.type === "webhook");
+        if (!webhookActions.length) {
+          throw new Error(`Workflow ${webhookId} fires no webhook action. Use list_webhooks to find one that does.`);
+        }
+        if (webhookActions.length > 1 && !actionId) {
+          throw new Error(
+            `Workflow ${webhookId} has ${webhookActions.length} webhook actions (${webhookActions.map((a) => `${a.id}: ${a.name}`).join(", ")}). Pass 'actionId' to say which one to change.`
+          );
+        }
+        const target = actionId ? webhookActions.find((a) => a.id === actionId) : webhookActions[0];
+        if (!target) throw new Error(`No webhook action with id ${actionId} on workflow ${webhookId}.`);
+        const attributes = target.attributes ?? {};
+        const validated = buildWebhookAction({
+          id: target.id,
+          name: target.name,
+          url: url ?? (typeof attributes.url === "string" ? attributes.url : ""),
+          method: method ?? (typeof attributes.method === "string" ? attributes.method : "POST"),
+          customData: customData ?? readKeyValues(attributes.customData),
+          headers: headers ?? readKeyValues(attributes.headers)
+        });
+        const nextActions = replaceWebhookAttributes(templates, target, validated.attributes);
+        await client.updateWorkflow(webhookId, {
+          actions: nextActions,
+          ...events ? { triggers: buildWebhookTriggers(events) } : {},
+          ...name ? { name } : {},
+          ...status ? { status } : {}
+        });
+        return jsonResponse({ updated: summarizeWebhookWorkflow(await client.getWorkflow(webhookId)) });
+      } catch (error) {
+        return errorResponse(error);
+      }
     }
   );
-  safeTool(
-    server2,
+  server2.tool(
     "delete_webhook",
-    "Delete a webhook subscription by ID.",
+    "Delete a webhook. This deletes the whole workflow that carries it, so it refuses when that workflow also does other things (sends an SMS, moves an opportunity) unless you pass force. IRREVERSIBLE. To stop a webhook firing without destroying it, use update_webhook with status 'draft'.",
     {
-      webhookId: import_zod34.z.string().describe("The webhook ID to delete."),
-      locationId: import_zod34.z.string().optional().describe("GHL Location ID. Optional if GHL_LOCATION_ID is set in env.")
+      webhookId: import_zod34.z.string().describe("The webhook ID (its workflow ID)."),
+      confirm: import_zod34.z.literal("DELETE").describe("Must be 'DELETE' to confirm this destructive action."),
+      force: import_zod34.z.boolean().optional().describe("Delete even when the workflow contains other actions that would go with it.")
     },
-    async ({ webhookId, locationId: locationId2 }) => {
-      const resolvedLocationId = client.resolveLocationId(locationId2);
-      return client.delete(`/webhooks/${webhookId}`, {
-        params: { locationId: resolvedLocationId }
-      });
+    async ({ webhookId, confirm, force }) => {
+      try {
+        const client = requireClient();
+        if (confirm !== "DELETE") throw new Error("Pass confirm: 'DELETE' to delete a webhook.");
+        const summary = summarizeWebhookWorkflow(await client.getWorkflow(webhookId));
+        if (!summary) {
+          throw new Error(
+            `Workflow ${webhookId} fires no webhook action, so this tool will not delete it. Use delete_workflow_full if you really mean to delete that workflow.`
+          );
+        }
+        if (summary.hasOtherActions && !force) {
+          throw new Error(
+            `Workflow "${summary.name}" does more than fire a webhook \u2014 deleting it would delete those steps too. Pass force: true if that is what you want, or use update_webhook with status 'draft' to just stop it firing.`
+          );
+        }
+        await client.deleteWorkflow(webhookId);
+        return jsonResponse({ deleted: true, webhookId, name: summary.name });
+      } catch (error) {
+        return errorResponse(error);
+      }
     }
   );
 }
@@ -19096,7 +19338,6 @@ var publicApiTools = [
   [registerAssociationTools, "associations"],
   [registerEstimateTools, "estimates"],
   [registerCouponTools, "coupons"],
-  [registerWebhookTools, "webhooks"],
   [registerDocumentTools, "documents"],
   [registerBulkOperationTools, "bulk-operations"],
   [registerTemplateDeployerTools, "template-deployer"],
@@ -19108,6 +19349,12 @@ var internalApiTools = [
   [registerFunnelBuilderTools, "funnel-builder"],
   [registerPipelineBuilderTools, "pipeline-builder"],
   [registerWorkflowClonerTools, "workflow-cloner"],
+  // Webhooks moved here in v3.66.0. GHL has no webhook REST resource — the
+  // old public-API calls 404'd for every customer since 2026-03-23 — so they
+  // are now built on the workflow builder, which needs Firebase auth. The
+  // module registers unconditionally (the tools explain the missing
+  // credentials rather than vanishing), so the advertised tool count holds.
+  [registerWebhookTools, "webhooks"],
   [registerSmartListTools, "smart-lists"],
   [registerReputationTools, "reputation"],
   [registerEmailCampaignTools, "email-campaigns"],

package/guide/guide.html

@@ -4,7 +4,7 @@
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>GHL Command — User Guide</title>
-<!-- guides-hash: b69654ea29507200 -->
+<!-- guides-hash: a156991f1141b0d5 -->
 <style>
 /* Deliberately light in every environment, including a dark-mode OS. This is a
    reference document people read at length, print, and save to PDF, and a page
@@ -226,7 +226,7 @@ body.app.reading #indexview{display:none}
   <p class="eyebrow">GHL Command</p>
   <h1>What do you want to get done?</h1>
   <p class="sub">Every guide is a job, in plain English: open one, copy a prompt, paste it to Claude. A job is not a button, so one guide usually puts a dozen of GHL Command's tools to work at once. Every prompt marked "Proven live" was run against a real GoHighLevel account before it shipped.</p>
-  <div class="badges"><span class="badge on">27 guides</span><span class="badge">10 categories</span><span class="badge">Updates with the product</span></div>
+  <div class="badges"><span class="badge on">28 guides</span><span class="badge">10 categories</span><span class="badge">Updates with the product</span></div>
 </div></section>
 <div class="shell">
 <main>
@@ -241,7 +241,8 @@ body.app.reading #indexview{display:none}
 <a class="card pub" href="#g-ai-bots-and-custom-values" data-k="conversation ai ai bot knowledge base bot goals custom values merge fields voice ai agency name snapshot template personality prompt"><h3>What your AI bot knows, and where to put it</h3><p>Three places a bot reads from, one of which silently ignores your custom values.</p><div class="meta"><span class="pill free">Free plan</span><span class="time">~5 minutes</span><span class="open">Open guide &#8594;</span></div></a>
 <a class="card pub" href="#g-audit-your-workflows" data-k="audit workflows broken silent failure check review existing validate not sending nothing happens"><h3>Audit your workflows</h3><p>Find silent failures and dead ends in existing workflows before your client does.</p><div class="meta"><span class="pill free">Free plan</span><span class="time">~2 minutes</span><span class="open">Open guide &#8594;</span></div></a>
 <a class="card pub" href="#g-branch-on-tags-and-fields" data-k="if else branch condition vip tag field split two paths different message"><h3>Branch on tags and fields</h3><p>If they are a VIP, send this. Otherwise, send that. Built correctly the first time.</p><div class="meta"><span class="pill full">Full license</span><span class="time">~5 minutes</span><span class="open">Open guide &#8594;</span></div></a>
-<a class="card pub" href="#g-build-nurture-sequence" data-k="nurture sequence drip texts emails follow up workflow build quiet hours sending window contact hours"><h3>Build a nurture sequence</h3><p>A follow-up machine that texts, emails, waits, and stops the second someone replies.</p><div class="meta"><span class="pill full">Full license</span><span class="time">~15 minutes</span><span class="open">Open guide &#8594;</span></div></a></div></div>
+<a class="card pub" href="#g-build-nurture-sequence" data-k="nurture sequence drip texts emails follow up workflow build quiet hours sending window contact hours"><h3>Build a nurture sequence</h3><p>A follow-up machine that texts, emails, waits, and stops the second someone replies.</p><div class="meta"><span class="pill full">Full license</span><span class="time">~15 minutes</span><span class="open">Open guide &#8594;</span></div></a>
+<a class="card pub" href="#g-send-data-to-other-apps" data-k="webhook zapier make integromat slack google sheets api send data integration notify push connect n8n other app"><h3>Send GHL data to another app</h3><p>Push contacts into Slack, Sheets, Zapier, Make or your own software the moment something happens in GHL.</p><div class="meta"><span class="pill full">Full license</span><span class="time">~2 minutes</span><span class="open">Open guide &#8594;</span></div></a></div></div>
 <div class="catsec" id="cat-pipelines-and-sales"><h2>Pipelines and sales</h2><div class="cards"><a class="card pub" href="#g-documents-and-contracts" data-k="documents contracts proposals signature send sign agreement esign template"><h3>Documents and contracts</h3><p>Proposals and contracts sent for signature and tracked from Claude.</p><div class="meta"><span class="pill full">Full license</span><span class="time">~5 minutes</span><span class="open">Open guide &#8594;</span></div></a>
 <a class="card pub" href="#g-invoices-and-payments" data-k="invoice bill billing payment paid product price coupon promo code discount transactions orders revenue estimate"><h3>Bill a client and see what you were paid</h3><p>Products, invoices, coupons, and the money reads, without opening the billing screen.</p><div class="meta"><span class="pill full">Full license</span><span class="time">~5 minutes</span><span class="open">Open guide &#8594;</span></div></a>
 <a class="card pub" href="#g-stand-up-a-pipeline" data-k="pipeline stages create new client setup opportunity sales process deal stages"><h3>Stand up a pipeline</h3><p>Stages, fields, and tags for a new client in one conversation.</p><div class="meta"><span class="pill full">Full license</span><span class="time">~10 minutes</span><span class="open">Open guide &#8594;</span></div></a>
@@ -1316,6 +1317,64 @@ Do not reply to anyone. This is a read.</p></div>
   </main></div>
 </section>
 
+<section class="gpage" id="g-send-data-to-other-apps">
+  <div class="hero"><div class="hero-in">
+    <p class="eyebrow">GHL Command User Guide</p>
+    <h1>Send GHL data to another app</h1>
+    <p class="sub">Push contacts into Slack, Sheets, Zapier, Make or your own software the moment something happens in GHL.</p>
+    <div class="badges"><span class="badge on">Full license</span><span class="badge">~2 minutes</span><span class="badge">Automations</span></div>
+  </div></div>
+  <div class="shell"><main class="gview">
+  <a class="back" href="#top">&#8592; All guides</a>
+  <div class="gsec"><h2>What you'll get</h2>
+<ul>
+<li>A live connection that pushes contact details out of GHL into any app that can receive a web request, the moment the thing you care about happens.</li>
+<li>It can fire on almost anything GHL knows about, not just a new contact: a tag added, a pipeline stage changed, an appointment no showed, a call missed, a form submitted.</li>
+<li>It shows up in the client's own Automation list, so they can see it, pause it, and edit it without you.</li>
+</ul>
+</div>
+<div class="gsec"><h2>Say this</h2>
+<div class="prompt"><q>Send every new contact to my Slack channel.</q><button class="copy" type="button">Copy</button></div>
+<div class="prompt"><q>When a contact moves to Consultation Booked, post them to this address: https://hooks.zapier.com/...</q><button class="copy" type="button">Copy</button></div>
+<div class="prompt"><q>Show me every webhook in this account and where each one is sending data.</q><button class="copy" type="button">Copy</button></div>
+</div>
+<div class="gsec"><h2>The pro prompt</h2>
+<div class="pro"><div class="pro-head"><b>The exact ask we run on real client accounts</b><span class="pill full">Proven live</span><button class="copy" type="button">Copy</button></div><p class="pro-body">Set up a webhook in my [Radiance Med Spa] account.
+Fire it whenever a contact gets the tag [hot-lead], and send it to [https://example.com/my-receiver].
+Add my own fields to what it sends: [clinic] set to [Radiance Med Spa], and [greeting] set to the contact's first name.
+Then show me exactly what will land at the other end, and tell me what happens if my receiver is down.</p></div>
+<p class="gpara">Everything in [brackets] is yours to change. Ask for the last part every time. What GHL sends is not what most people expect.</p>
+</div>
+<div class="gsec"><h2>What happens when you ask</h2>
+<ol class="steps">
+<li>Claude builds a small workflow in the account: your chosen trigger, and one step that sends the data out.</li>
+<li>It publishes it, so it starts working immediately, and hands you back its ID.</li>
+<li>Ask it to fire a test, and it will tag a throwaway contact so you can watch the request land before you trust it with real leads.</li>
+</ol>
+</div>
+<div class="gsec"><h2>Good to know</h2>
+<ul>
+<li><b>What arrives is a fixed set of contact fields</b>, plus the sub-account details, plus which workflow sent it, plus any custom fields you asked for. Your own fields can include merge fields, so &quot;the contact's first name&quot; arrives already filled in.</li>
+<li><b><code>tags</code> arrives as one comma separated line of text, not a list.</b> This catches people out constantly. If the receiving app checks whether tags contains &quot;vip&quot;, it will also match a contact tagged &quot;vip-waitlist&quot;. Split on the comma first.</li>
+<li><b>If the receiving app is down, GHL keeps trying</b>, roughly five minutes later, then ten minutes after that. Nothing is thrown away.</li>
+<li><b>But the contact stops there while it retries, and so does everything after it in that workflow.</b> If the send is not critical, put it at the end of the workflow, or give it a workflow of its own, so an outage at the other end cannot hold up your follow up.</li>
+<li>GHL has a paid &quot;Custom Webhook&quot; step that lets you replace the whole message with your own format. You almost never need it. Adding your own fields, your own headers, and choosing POST, GET or PUT all work on every plan.</li>
+</ul>
+</div>
+<div class="gsec"><h2>Where people go wrong</h2>
+<div style="overflow-x:auto"><table class="wrongtbl"><tr><th>What happened</th><th>The fix</th></tr><tr><td>&quot;I deleted the webhook and it deleted my whole nurture.&quot;</td><td>It will refuse to do that. A webhook here is a workflow, so if that workflow does other things too, Claude stops and tells you instead of deleting it. To just switch a webhook off, ask to set it back to draft.</td></tr><tr><td>&quot;My receiver only got some of the leads.&quot;</td><td>Something earlier in the workflow is holding contacts up, or the send is behind a step that failed. Ask Claude to audit that workflow.</td></tr><tr><td>&quot;My code crashed on <code>tags.map</code>.&quot;</td><td><code>tags</code> is text, not a list. Split it on commas first.</td></tr><tr><td>&quot;I pointed it at a test address and forgot.&quot;</td><td>Ask for every webhook in the account and where each one sends. Old test addresses are the most common thing this turns up.</td></tr></table></div>
+</div>
+<div class="gsec"><h2>Related guides</h2>
+<ul>
+<li>audit-your-workflows</li>
+<li>build-nurture-sequence</li>
+<li>branch-on-tags-and-fields</li>
+</ul>
+</div>
+  <p class="gfoot">Works in Claude Desktop and Claude Code. Stuck? Email support@ghlcommand.com and a human answers.</p>
+  </main></div>
+</section>
+
 <section class="gpage" id="g-send-texts-and-emails">
   <div class="hero"><div class="hero-in">
     <p class="eyebrow">GHL Command User Guide</p>

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@elitedcs/ghl-mcp",
-  "version": "3.65.3",
+  "version": "3.66.0",
   "mcpName": "io.github.drjerryrelth/ghl-command",
-  "description": "GoHighLevel MCP Server for Claude. 238 tools — full CRM, automation, marketing control, account-wide workflow audit, live funnel-capture verification, and the only programmatic GHL workflow builder, now multi-tenant across client accounts.",
+  "description": "GoHighLevel MCP Server for Claude. 238 tools \u2014 full CRM, automation, marketing control, account-wide workflow audit, live funnel-capture verification, and the only programmatic GHL workflow builder, now multi-tenant across client accounts.",
   "main": "dist/index.js",
   "bin": {
     "ghl-mcp": "dist/index.js"