---
name: hubspot-make-integration
description: Connect HubSpot and Make: what syncs, which editions carry it, the setup order, and the failures to expect. Covers contacts, companies, deals, custom objects. Use when the user wants to set up, audit or troubleshoot HubSpot and Make together, or asks why data is not moving between them.
---

# HubSpot and Make

> Generated from https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-make-integration
> Every tier requirement, sync direction and limit below was read from the vendors' own documentation on 2026-10-11.
> Vendors change these without notice. Re-check anything load-bearing before you rely on it.

**What you have to buy first:** A HubSpot Super Admin to approve the app, and a developer account for webhook modules

**What moves:** contacts, companies, deals, custom objects, both ways.
**How it is built:** zapier, make or n8n. **Effort:** hours.

## The short version

Make reaches further into HubSpot than most orchestration tools: CRM objects and custom objects, contacts, deals, companies, tickets and tasks, engagements, calls, notes, emails and meetings, products, line items, orders, quotes and invoices, workflows, subscriptions and associations. The cost is a setup with three one-way doors: a Super Admin must approve the app and must approve again if Make adds scopes, a scope added to a connection can never be removed, and webhook subscription types are fixed at creation, on a custom app that supports exactly one webhook URL. None of that is hard; all of it is expensive to undo.

## What a module needs before it will connect

Rows: The kind of module you are adding. Columns: What you need before it works. Neither side gates this by edition. What decides the work is the kind of module you pick, and Make splits them into two groups whose setup requirements are not remotely comparable.

| The kind of module you are adding | An OAuth connection | Scopes chosen by hand | A HubSpot developer account and custom app |
|---|---|---|---|
| An ordinary action or search | Required | Not required | Not required |
| Make an API Call | Required | Required | Not required |
| An instant module, such as Watch Notifications | Required | Required | Required |

- **Required.** Make requests a module's scopes automatically on an ordinary connection. Make an API Call is the exception, where you choose scopes under Connection, Custom Scopes. An instant module additionally needs a developer account, a custom application, a developer API key and a webhook URL.
- **Not required.** Nothing to arrange. The top row is the version of this integration most people have, and it is a genuine five-minute setup.

Counted off that grid, of nine pairings: six give you required, three give you not required.

The staircase is the useful shape: each row needs everything the row above needed plus one more thing. Knowing which row your scenario sits on before you build it is the difference between a five-minute connection and an afternoon in a developer account you did not know you needed.

## What actually syncs

Direction is written from HubSpot's point of view: out means out of HubSpot, in means into it.

| What | Direction | What that means in practice |
|---|---|---|
| Contacts, companies and deals | Two-way sync | Create, read, update, search and watch, plus the generic CRM object modules that cover anything with a HubSpot object type. |
| Custom objects | Two-way sync | Full record modules, which is more than several native connectors in this directory manage at all. |
| Engagements and activity | Two-way sync | Calls, notes, emails, meetings and communications as first-class modules rather than as a generic write. |
| Commerce objects | Two-way sync | Products, line items, orders, quotes and invoices, which is the part teams doing revenue operations actually come for. |
| Record changes into Make | One way, out | Watch Notifications, on a webhook. Needs a HubSpot developer account and a connection built through advanced settings. |
| Timeline events | One way, in | Create a timeline event and list templates, same developer-account requirement, which is how Make writes a custom activity onto a record. |

## Which field lands where

There is no field mapping here; Make exposes HubSpot as a long list of modules grouped by object. What is worth knowing is which of them are instant, because that group carries every one of the irreversible decisions on this page.

| In HubSpot | In Make | What to know about the match |
|---|---|---|
| CRM Objects, Records, Custom Objects | Create, read, update, search | The generic object modules, which is where custom objects are reached. Broader than the n8n node, which has no custom object support at all. |
| Contacts, Companies | Their own dedicated module groups | Separate from the generic record modules, which is why the picker lists what look like two ways to do the same thing. |
| Engagements, Meetings, Communications | Activity on the timeline | Three separate groups. Worth checking which one holds the activity type you mean before building around it. |
| Tickets | Service Hub objects | Present, and the reason some teams run this pair with no sales use case at all. |
| Products, Line Items, Invoices | The commerce objects | Not in most orchestration tools' HubSpot coverage. If quoting or invoicing is the workflow, this is the differentiator. |
| Workflows, Associations, Subscriptions | Structural modules | Associations are how a contact gets linked to its company, and subscription modules cover email subscription state. |
| Events and Notifications | The instant modules | Where Watch Notifications lives, and the only group that needs a developer account, a custom app and a webhook URL. |
| Make an API Call | Anything HubSpot exposes | The escape hatch, and the one module where you pick the scopes yourself under Connection, Custom Scopes, because Make cannot infer them. |

### Scopes a webhook subscription needs, in both places

| The action | How it reads on the record |
|---|---|
| Company created, deleted, or a property changed | crm.objects.companies Read on the app, CRM Companies Read on the connection |
| Contact created, deleted, or a property changed | crm.objects.contacts Read on the app, CRM Contacts Read on the connection |
| Contact deleted for privacy compliance reasons | The same contacts scopes, and a separate subscription type |
| Anything else | HubSpot's own webhook subscriptions documentation, which Make defers to |
| A scope added after the fact | Possible on the app, and not on the subscription list, which cannot be updated later |
| A scope you no longer want | Not removable. A new connection is the only route |

**What does not cross:**

- Removing a scope from a connection. Make states it outright, so a connection's permissions only ever grow and the only correction is a replacement.
- Adding a subscription to a webhook module after it is built. Make warns the field cannot be updated later, so the list is decided once.
- A second webhook URL on the same HubSpot custom application. One app carries one URL, which makes the app allowance on your HubSpot subscription the real ceiling.

## Connect it, in this order

**Who has to do it:** Whoever builds the scenario, plus a HubSpot Super Admin to approve the app, twice if you need a webhook.
**How long:** Five minutes for a normal connection. An hour the first time you need an instant module.

### 1. Work out whether any module you need is instant

*Where:* Make: the module picker

A module tagged instant needs a webhook, and a webhook needs the advanced path: a HubSpot developer account, a custom application and a developer API key. Everything else is one OAuth connection. This is the fork, and taking it late means redoing the connection.

### 2. Create the connection and let Make request the scopes

*Where:* Make: add a HubSpot CRM module, Create a connection

Make automatically requests whatever scopes the module needs. The exception is Make an API Call, where you choose the scopes yourself under Connection, Custom Scopes, because Make cannot know what endpoint you are about to call.

### 3. Add every scope you will ever need on this connection

*Where:* The same screen

Make states it plainly: once you add scopes to a connection, you cannot remove them, and needing fewer means creating a new connection. Scopes only ever accumulate, so a connection used for experiments becomes a connection nobody should keep.

### 4. Create the HubSpot custom app if you need the webhook

*Where:* HubSpot developer account: Apps, Create an app

Leave the Install URL blank and set the Redirect URL to https://www.integromat.com/oauth/cb/hubspotcrm, which is still the pre-rename domain. Add scopes here only if you are using Watch Notifications; otherwise the section can stay empty.

### 5. Copy the developer API key and user ID

*Where:* HubSpot developer account: Apps

Click Show key on an existing key, or Create key and store it somewhere safe. The advanced connection asks for the key alongside the app's client details, which is a different set of credentials from the ordinary OAuth path.

### 6. Add every subscription now, because you cannot add one later

*Where:* Make: the Watch Notifications module, Subscriptions

Make warns that this field cannot be updated at a later time. Add all the subscription types you intend to watch in one go, with their matching scopes in both the custom app and the connection.

### 7. Accept one webhook URL per custom application

*Where:* HubSpot: the custom app

Make documents the constraint: each HubSpot custom application can be associated with only one webhook URL. Watching several events means several subscriptions on that one webhook, not several webhooks.

### 8. Check how many custom apps your HubSpot subscription allows

*Where:* HubSpot: your subscription

Make defers to HubSpot on this rather than stating a number, and since one app carries one webhook URL, the app allowance is effectively the ceiling on how many separate Make webhook scenarios you can run.

Three of those eight steps are decisions that cannot be reversed in place: the scopes on a connection, the subscriptions on a webhook module, and which webhook URL belongs to which app. Everything else is ordinary scenario building, and the [HubSpot and n8n pairing](pair:hubspot+n8n) hits a near-identical wall from the other direction.

## How to check it worked

- Run one simple module before building anything. A connection that works proves the OAuth path, and nothing about the webhook path.
- Try to remove a scope you added. You cannot, and discovering that on a test connection is better than discovering it on the one your scenarios depend on.
- Activate the Watch Notifications module and change a record in HubSpot. If nothing fires, check the scopes exist in both places, the custom app and the connection custom scopes, because the module needs them in both.
- Count the custom applications you already have against what your HubSpot subscription allows, before you design a second webhook scenario.

## When it goes wrong

Each row is a symptom somebody reports, the documented reason, and the fix. Work down it before escalating to either vendor, because most of these are configuration.

| Symptom | Why it happens | What to do |
|---|---|---|
| A scope needs removing and there is no way to do it | Make states that once scopes are added to a connection they cannot be removed. | Create a new connection with only the scopes you want and repoint the scenarios at it. Treat an experimental connection as disposable from the start. |
| Watch Notifications never fires | The scopes are needed in two places with two different names: on the HubSpot custom app and again as connection custom scopes in Make. | Check both against Make's subscription table. A module missing one of the pair does not error, it simply never triggers, which is why this is hard to spot. |
| A subscription needs adding to an existing webhook module | Make warns that the Subscriptions field cannot be updated at a later time. | Rebuild the module with the full list. This is the one setting on this pair worth over-specifying at the start. |
| A second webhook will not attach to the custom app | Each HubSpot custom application can be associated with only one webhook URL. | Add more subscriptions to the existing webhook rather than creating a second one, or create a separate custom app if your HubSpot subscription allows another. |
| The OAuth redirect fails on the advanced connection | The Redirect URL has to be exactly https://www.integromat.com/oauth/cb/hubspotcrm, which is the pre-rename domain and looks wrong to anybody who knows Make by its current name. | Use it as documented, and leave the Install URL blank. Typing the make.com equivalent is the obvious mistake here. |
| Make an API Call returns a permissions error | Make cannot infer the scopes for an arbitrary endpoint, so this is the one module where you select them yourself. | Add them under Connection, Custom Scopes in the module settings, remembering that they then cannot be removed from that connection. |
| A contact cannot be subscribed to an email address | Make documents it as a plain constraint: you cannot subscribe a contact to an email address that is already subscribed. | Check the subscription state first and branch, rather than treating the error as a failure to handle. |
| Somebody else's HubSpot integration started hitting limits | HubSpot's daily API cap is shared across every app in the account, and a Make scenario looping record by record spends from the same pool. | Batch where the modules allow it, and check API call usage in HubSpot under Development, Monitoring. The burst limit is per app; the daily one is everybody's. |

## What breaks, from the vendors' own docs

- **Scopes are permanent on a connection.** Make states that once scopes are added to a connection they cannot be removed, and that holding fewer means creating a new connection. Add the minimum you need rather than everything that looks useful, because the audit question later is what this integration can reach and the honest answer will be whatever was ticked on the first day.
- **Two Super Admin approvals, not one.** A HubSpot Super Admin has to pre-approve the Make app before a connection can be created, and has to approve again if Make adds new scopes before the connection can be reauthorised. The second one arrives without warning, on somebody else's release schedule, and presents as a scenario that has stopped working.
- **One webhook URL per custom app, fixed at setup.** Each custom HubSpot application supports one webhook URL, and the subscription types on a webhook module cannot be changed after it is created. So every event type you will ever want has to be added during setup, and discovering a missing one means building another custom app rather than editing the first.
- **Deprecated modules are still in the picker.** Make's contact-list modules carry a deprecation date and several of its integration pages list modules that are no longer current. A scenario built on one works until it does not. Check the app's own documentation page rather than the integration marketing pages, which Make itself notes are partly outdated.

## The APIs, if you are building around it instead

### HubSpot

- **Base:** `https://api.hubapi.com`
- **Auth:** `Authorization: Bearer <private-app-token>` for a private app, or OAuth for a marketplace app. Full CRM API access is on every tier including Free.

| Call | Request | What it does |
|---|---|---|
| `PATCH /crm/v3/objects/contacts/{contactId}` | `{ "properties": { "rc_title": "VP Sales" } }` | Update a contact. Send only the properties you own. |
| `POST /crm/v3/objects/contacts/search` | `{ "filterGroups": [...], "properties": [...] }` | Find records by property. Use this to pull the slice that is missing a field. |
| `POST /crm/v3/objects/contacts/batch/update` | `{ "inputs": [ { "id": "...", "properties": {...} } ] }` | Batch of up to 100. Prefer this over per-record PATCH at volume: it is one request against the rate limit. |

**Rules that will cost you time if you skip them:**

- **Rate limits.** A private app gets 190 requests per 10 seconds on Professional and Enterprise, 100 on Free and Starter. Daily caps are 250,000 / 625,000 / 1,000,000 calls **per account, shared across every app**. A public OAuth marketplace app is capped at 110 per 10 seconds per installing account.
- **Calling an external API from a workflow needs Data Hub Professional or Enterprise.** Both the webhook action and the custom code action live in that hub, not in Sales Hub. Check this before designing an in-HubSpot build.
- **Custom code actions get 20 seconds and 128 MB.** Combined length of all workflow secrets is capped at 1,000 characters. Secrets are read with `process.env.NAME`.
- **Workflows:** up to 50 simple on Starter, up to 300 fully customisable on Professional.
- **Never write to a property a human maintains.** Use prefixed properties (`rc_*`) and promote with a separate workflow only where the human field is empty.

**HubSpot custom code action (Node 20):**

```javascript
// Input field: email   Output fields: rc_status, rc_title, rc_company, rc_headcount
// Secret: RC_API_KEY
const axios = require('axios');

exports.main = async (event, callback) => {
  const email = event.inputFields['email'];
  const res = await axios.post(
    'https://api.reversecontact.com/v2/enrich/persons',
    { email },
    { headers: { Authorization: `Bearer ${process.env.RC_API_KEY}` } }
  );

  const person = res.data?.data?.person;
  const company = res.data?.data?.company;

  // null means "not found", not "try harder". Write nothing and flag it.
  if (!person) return callback({ outputFields: { rc_status: 'no_match' } });

  callback({ outputFields: {
    rc_status:    'matched',
    rc_title:     person.currentPosition?.title || '',
    rc_company:   company?.name || '',
    rc_headcount: company?.employeeCount || 0
  }});
};
```

Docs: https://developers.hubspot.com/docs/api/overview

## Filling the record this integration moves

The integration above moves a record between two systems. Neither of them creates what is in it, so a sync that works perfectly still carries whatever gaps the record arrived with. Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record through one API, and returns null with a confidence score rather than a guess.

### Reverse Contact

- **Base:** `https://api.reversecontact.com/v2`
- **Auth:** `Authorization: Bearer rc_your_api_key`. Keys are created in Workspace > API Keys.

| Call | Request | What it does |
|---|---|---|
| `POST /v2/enrich/persons` | `{ "email": "j.okafor@northwind.io" }` | Resolve a person from an email, a name plus company, or a profile URL. Cached resolution, returns in the response. |
| `POST /v2/enrich/companies` | `{ "domain": "northwind.io" }` | Resolve a company from a domain or a name. |
| `POST /v2/fetch/persons` | `{ "linkedInUrl": "..." }` | Standard profile lookup from the database. |
| `POST /v2/fetch/persons/live` | `{ "linkedInUrl": "..." }` | Live on-demand resolution. ASYNCHRONOUS: returns a webhookId to poll, not a record. |
| `POST /v2/search/people` | `{ "filters": { "currentCompanyDomain": "northwind.io" } }` | Filtered people search. 1 credit a profile delivered, and /v2/search/people/count is free. It replaced /v2/search/persons, which returns 410 Gone since 13 October 2026. |
| `POST /v2/search/organizations` | `{ "filters": { "companyDomain": "northwind.io" } }` | Filtered company search. A domain can also go straight to a company through POST /v2/enrich/companies, or through the enrich_company MCP tool since November 2026. |
| `POST /v2/contact/email` | `{ "linkedInUrl": "..." }` | Find an email. ASYNCHRONOUS: returns a taskId to poll. 3 credits for a professional address, 5 for a personal one, 8 for both, refunded when neither is found. |
| `GET /v2/webhooks/:webhookId` | - | Poll an async job until status is "succeeded". Polling is free and does not count against the rate limit. |

Response shape:

```json
{
  "success": true,
  "data": {
    "person": {
      "fullName": "Jane Okafor",
      "headline": "VP Sales at Northwind",
      "location": "London, United Kingdom",
      "linkedInUrl": "https://linkedin.com/in/...",
      "currentPosition": { "title": "VP Sales", "companyName": "Northwind", "startDate": "2023-04" },
      "emails": [], "experience": [], "education": [], "skills": []
    },
    "company": { "name": "Northwind", "domain": "northwind.io",
                 "industry": "Software Development", "employeeCount": 220 }
  },
  "error": null,
  "metadata": { "requestId": "req_...", "executionTimeMs": 480, "updatedAt": "2026-09-01T..." },
  "quotas": { "creditsConsumed": 1, "workspace": { "credits": { "total": 10000, "used": 4521, "left": 5479 } } }
}
```

**Rules that will cost you time if you skip them:**

- A miss returns **null**, not a best guess. Every response carries a confidence score, and you can raise the precision threshold on the request. Branch on it: do not treat a low-confidence answer as a match.
- Use the cached endpoints anywhere that must answer inside one HTTP request. The `/live` endpoints return a task and need polling.
- `quotas.workspace.credits.left` is on every response. Log it, or you will find out about the balance from a 402.
- Credit costs per call are published and a dollar rate per lookup is not: 2 credits for a reverse lookup from an email, 1 for a cached profile lookup, 2 for a live refresh, 3 for a business email and 20 for a direct phone number, with the last two charged only when one is found. Checks and the search count endpoint are free. Credit packs expire after 3 months. Do not hard-code a dollar cost assumption.

**MCP server:** `https://api.reversecontact.com/mcp`

- Auth: OAuth 2.1 where the client supports it, otherwise `Authorization: Bearer rc_your_api_key`.
- Tools: `enrich_person`, `enrich_person_live`, `enrich_company`, `enrich_company_live`, `search_persons`, `search_companies`, `check_usage`, `check_task`
- Streamable HTTP, JSON-RPC 2.0. The `_live` tools return a task id that `check_task` polls.

Docs: https://docs.reversecontact.com/getting-started

## Sources

- Make: HubSpot CRM app documentation: https://apps.make.com/hubspotcrm
- HubSpot developers: API usage guidelines and limits: https://developers.hubspot.com/docs/developer-tooling/platform/usage-guidelines
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-make-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-make-integration

---

*Published by Reverse Contact, which appears in this directory as a data provider.
No other vendor pays for placement. Where a vendor publishes no public figure, this file says so
rather than estimating. Reverse Contact costs are stated in credits, which it publishes; no dollar
rate per lookup appears here, because none is published and dividing a pack price is not their number.*
