---
title: "HubSpot and Make integration: what syncs, and what it needs"
description: "HubSpot and Make: what moves, in which direction, which plan carries it, and the limits that bite. Verified October 2026."
url: https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-make-integration
format: markdown twin of the page above, generated at build time
---

New Unlimited plans are here. Fetch, search and enrich without counting credits. [See plans →](https://www.reversecontact.com/integrations-hub//pricing#plans)

Reverse Contact

### Products

Data

People Data

Company Data

Our Data Quality Standard

Delivery methods

API

Webhooks

CSV Enrichment

MCP

CLI

Integrations

### Use cases

[Sales Product](https://www.reversecontact.com/integrations-hub//use-case/sales-products)[Recruiting Product](https://www.reversecontact.com/integrations-hub//use-case/recruiting-products)[Internal Data Teams](https://www.reversecontact.com/integrations-hub//use-case/internal-data-teams)[AI Products](https://www.reversecontact.com/integrations-hub//use-case/data-for-ai)[CRM Enrichment](https://www.reversecontact.com/integrations-hub//use-case/crm-enrichment)

### Features

[Email Finder API](https://www.reversecontact.com/integrations-hub//feature/email-finder-api)[Phone Number Enrichment](https://www.reversecontact.com/integrations-hub//feature/phone-number-enrichment)[People Search API](https://www.reversecontact.com/integrations-hub//feature/people-search-api)[Agentic Search API](https://www.reversecontact.com/integrations-hub//feature/agentic-search-api)[People Lookalike API](https://www.reversecontact.com/integrations-hub//feature/people-lookalike-api)[Company Search API](https://www.reversecontact.com/integrations-hub//feature/company-search-api)[Person Enrichment API](https://www.reversecontact.com/integrations-hub//feature/person-enrichment-api)[Company Enrichment API](https://www.reversecontact.com/integrations-hub//feature/company-enrichment-api)[Person Social Data API](https://www.reversecontact.com/integrations-hub//feature/social-person-api)[Company Social Data API](https://www.reversecontact.com/integrations-hub//feature/social-company-api)

Security

Pricing

Docs

[Log in](https://app.reversecontact.com/auth/login) [Book a demo](https://www.reversecontact.com/contact?utm_source=integrations-directory&utm_medium=referral&utm_campaign=tool-integrations&utm_content=site-header) [Start for free](https://app.reversecontact.com/auth/signup?utm_source=integrations-directory&utm_medium=referral&utm_campaign=tool-integrations&utm_content=site-header)

# HubSpot and Make

A Super Admin has to approve it, and a scope added to a connection can never be removed.

Checked by **Reverse Contact** · Verified 2026-10-11 · No paid placement

## 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, two-way sync.

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 actually syncs

Object by object, with the direction each one moves in. This is the table to read before the feature list, because a capability that only moves one way is a different product from the one you think you are buying.

| What | Direction | What that means in practice |
| --- | --- | --- |
| Contacts, companies and deals | Both ways | Create, read, update, search and watch, plus the generic CRM object modules that cover anything with a HubSpot object type. |
| Custom objects | Both ways | Full record modules, which is more than several native connectors in this directory manage at all. |
| Engagements and activity | Both ways | Calls, notes, emails, meetings and communications as first-class modules rather than as a generic write. |
| Commerce objects | Both ways | 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. |

Four of those six rows move in both directions. The two that do not are Record changes into Make and Timeline events, and those are the rows that decide how you design around this rather than the ones in the brochure.

## 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

Worth knowing before you write a report against it, because the wording below is what you will be filtering and searching on rather than anything you choose.

| 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

Three things are worth knowing before you plan around this mapping, because each one is a decision somebody has to own rather than a setting to find.

- 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.

Every row above travels as a file: eight field mappings, six action rows and three documented exclusions, each one's note, and the two vendor documents behind them. The CSV opens in a spreadsheet, the JSON is the shape an agent wants, and the Markdown is the table to paste into a ticket.

Read the second table as a two-places rule: every webhook subscription needs its scope on the HubSpot custom app and again on the Make connection, with different names for the same thing. That duplication is where most Watch Notifications setups fail, and it fails silently because a module with half its scopes simply never fires.

## What a module needs before it will connect

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. Pick one on each side and the grid marks the answer.

| 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.

## How to connect HubSpot to Make

Every step below is from the two vendors' own setup documentation, in the order they document it. Two of them cost you an afternoon if taken late, so the order is the useful part rather than the clicks.

- **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 it takes** — Five minutes for a normal connection. An hour the first time you need an instant module.

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.

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.

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.

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.

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.

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.

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.

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](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-n8n-integration) hits a near-identical wall from the other direction.

Hand it to an agent instead

The same sequence, the sync table, the documented limits and the error list ship as one agent skill. Point Claude Code, Cursor or anything that reads a file at [this pair as a skill](https://www.reversecontact.com/integrations-hub/skills/hubspot-make.md) and it has the whole pair without reading two sets of vendor docs first.

curl -o .claude/skills/hubspot-make/SKILL.md https://www.reversecontact.com/integrations-hub/skills/hubspot-make.md

## What breaks, and what nobody tells you

Every limit below is documented by one of the two vendors. They are here because they change decisions, not because they are flaws.

- **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.

Each of those is documented behaviour rather than a fault, so none of them is going to be fixed by a support ticket. The ones that produce a symptom you would misread are below.

## The 8 failures people actually hit

Each one below is a symptom somebody reports, the documented reason behind it, and the fix. Most are configuration rather than faults, which is why they survive a support ticket.

### A scope needs removing and there is no way to do it

WhyMake 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

WhyThe 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

WhyMake 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

WhyEach 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

WhyThe 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

WhyMake 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

WhyMake 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

WhyHubSpot'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.

If none of those is it, the next thing to check is the thing most pairs fail on: whether the plan you are on carries the feature at all, which the grid above answers. The [same symptom on another pair](https://www.reversecontact.com/integrations-hub/errors) is often the same cause, so the directory indexes all of them by the message rather than by the integration.

## When this is the right integration

### Set it up when

- The logic is visual and somebody non-technical will maintain it
- Quotes, line items or invoices are part of the workflow
- You need a custom activity written onto a HubSpot record

### Do not bother when

- No Super Admin will be available when scopes change
- The requirement is one trigger and one action at low volume
- Nobody wants to register a HubSpot developer account

The right-hand column is the one worth being honest about, because every item in it is a reason to spend the budget somewhere else in the stack rather than a reason to configure harder.

## What practitioners say about it

Searched for the problem this pair solves rather than for the pair itself, because the pair by name returns almost nothing. 14 threads from 2024 to 2026 were read in full on 11 October 2026, and the 5 below are the ones that carry a point. Each is one person's experience rather than a measurement, and the vendors' own documentation is what the rest of this page rests on.

### The in-CRM answer, from the people who prefer it

> If you're serious about HubSpot automations, I'd narrow your focus to Workflows and Custom Code Actions first. Workflows are the backbone of almost everything in HubSpot automation, and custom code is what lets you go beyond the out-of-the-box limits

[r/hubspot](https://www.reddit.com/r/hubspot/comments/1qmqukh/zapier_vs_make_vs_n8n_longterm_specialization/) · January 2026 · 6 points

The highest-scoring comment in a thread explicitly comparing Zapier, Make and n8n for HubSpot work, and it declines the question. It is correct for anybody who owns Data Hub Professional, which is what custom code actions need, and it does not mention that gate.

### Consolidating onto HubSpot is a real motivation, not just marketing

> Many people migrate to HubSpot due to the fact that they no longer want to rely on Zap, Make, N8N, etc., for a lot of their automation, resulting in a ton of crossed wires, and silos within their tech stack.

[r/hubspot](https://www.reddit.com/r/hubspot/comments/1qmqukh/zapier_vs_make_vs_n8n_longterm_specialization/) · January 2026 · 3 points

A fair description of the failure mode this pair can produce. The counter is the scope behaviour above: a Make connection whose permissions only grow is exactly the crossed wire being described, and it is avoidable by treating connections as single-purpose.

### Make sits in the middle on purpose, and people use it that way

> Make sits nicely in the middle and is very practical for SMBs.

[r/hubspot](https://www.reddit.com/r/hubspot/comments/1qmqukh/zapier_vs_make_vs_n8n_longterm_specialization/) · January 2026 · 2 points

From a longer comment recommending n8n as a core specialisation with Zapier or Make for client-facing work. The positioning matches the module list: broader HubSpot coverage than most, including commerce objects, without the hosting that n8n asks for.

### Understanding the API matters more than the tool

> I would suggest to do the postman api course and start to poke around in the Hubspot Public API Workspace. Everything you can do is documented there, you can grab it and build custom solutions with it but it really helps you to understand how stuff works. \[...\] I started with zapier, used make and now use n8n and I prefer the latter BUT it doesnt really matter, I you understand how the api works.

[r/hubspot](https://www.reddit.com/r/hubspot/comments/1qmqukh/zapier_vs_make_vs_n8n_longterm_specialization/) · January 2026 · 2 points

From somebody who has used all three in sequence. It is the best argument for the Make an API Call module, which is also the one place Make hands you the scope decision because it cannot infer what you are about to call.

### The speed argument for a no-code tool is about who does the work

> I prefer Zapier because as a digital marketer, I would like to spend time more on "doing with the things" rather than working with developers on N8n and going through a long process, testing, deployment, bug fixes etc technical work.

[r/hubspot](https://www.reddit.com/r/hubspot/comments/1qmqukh/zapier_vs_make_vs_n8n_longterm_specialization/) · January 2026 · 2 points

About Zapier, and it transfers to Make directly. Worth setting against the webhook path on this page: the ordinary connection genuinely is a five-minute job for a marketer, and the instant modules are a developer account and a custom app, which is not.

What the threads add up to

The threads about this pair are the same argument that runs through every orchestration tool against HubSpot: whether to build the automation inside the CRM or outside it. In r/hubspot the answer is to learn workflows and custom code actions, and in the automation subreddits it is to pick a tool and keep the logic portable. Both are right for different licences, which is the fact neither side mentions.

All five come from one thread, which is what a job search finds when a pair is discussed only as an option among others. They are useful for the decision rather than the configuration, and the irreversible settings above are the part no thread mentions because nobody writes a post about a scope they cannot remove.

## The longer answer

Make and the other orchestration tools in this directory differ less in what they can reach than in who can maintain them, and that is the right axis to choose on. Make's scenario canvas is the most approachable of the three for somebody who does not write code, which means a revenue operations lead can own it. [n8n](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-n8n-integration) gives you a workflow in version control on a host you run, which means an engineer owns it. [Zapier](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-zapier-integration) is the quickest to stand up and the most expensive per task at volume, and all three read and write the same free HubSpot API.

What is specific to this pair is the number of decisions that cannot be revisited.

- Scopes on a connection are permanent.
- Webhook subscription types are fixed at creation.
- A custom app carries one webhook URL.

None of those is a limitation in daily use and all of them punish a setup done in a hurry, so spend twenty minutes listing the objects and events the scenario will ever need before you click through the connection flow. The alternative is a second custom app and a migration.

The Super Admin dependency deserves a named owner rather than a note. The first approval is predictable and the second is not: it happens when Make adds scopes, on Make's schedule, and it looks like a broken scenario rather than a pending approval. Write down who in HubSpot can approve the app and make sure it is not one person who might be on leave, which is the same discipline the [CRM layer](https://www.reversecontact.com/integrations-hub/stack/crm) needs for every integration user it depends on.

## If this is not the one

The integrations people compare this against, or set up alongside it.

Split a stack into layers and this pair sits on two of them: the [CRM layer](https://www.reversecontact.com/integrations-hub/stack/crm), which 33 of the 68 integrations here touch, and the [orchestration layer](https://www.reversecontact.com/integrations-hub/stack/orchestration), which 23 do.

[**HubSpot and LinkedIn**Two-way, genuinely useful, and only on the Sales Navigator edition nobody quotes you first. Two-way sync](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-linkedin-integration)[**HubSpot and ZoomInfo**Enrichment the moment a record is created, with the two-way half sold one edition up. One way, in](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-zoominfo-integration)[**HubSpot and Reverse Contact**A whole record from an email or a domain, by four routes, and only the in-CRM one needs Data Hub. One way, in](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-reverse-contact-integration)

## [Reverse Contact](https://www.reversecontact.com)

We sell B2B people and company data, and we publish this directory. Every tier requirement, sync direction and limit on this page was read from a vendor's own knowledge base, developer documentation or pricing page on the date below. Nothing on it is restated from a press release or a third-party listing.

Where a vendor publishes no public figure, this page says so rather than estimating, which is why no page here prints a cost per enriched record. Reverse Contact appears in this directory as a data provider and publishes it. No other vendor pays for placement, and every link out of a listing or a citation carries nofollow, including the ones that point at Reverse Contact. The only followed links on this page are the two calls to action and the reviewer.

Tier requirements, sync behaviour and documented limits change without notice. Confirm against your own contract before you budget. [What has changed since](https://www.reversecontact.com/integrations-hub/changes) · [How we checked](https://www.reversecontact.com/integrations-hub/methodology), and what we will not claim

[Eugene Suslov](https://www.linkedin.com/in/eysuslov/)

Researched and wrote every page in this directory, and checked every tier requirement, sync direction and documented limit against the vendor's own knowledge base, developer documentation or pricing page.

- **Verified** — 2026-10-11
- **Sources** — 2 vendor documents
- **Paid placement** — None

### Read from

- [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)

## HubSpot and Make, asked and answered

### What do I need before building a Make scenario on HubSpot?

A HubSpot Super Admin has to pre-approve the Make app before anyone can create a connection, and the same is true again later if Make adds new scopes: a Super Admin has to approve those before the connection can be reauthorised. That makes this a two-person job in most companies and the usual reason a scenario that was going to take an afternoon takes a week.

### Which modules need a developer account?

Three: Watch Notifications, Create a Timeline Event and List Timeline Event Templates. Each needs a HubSpot developer account and a connection set up through Make's advanced settings, which means creating a custom HubSpot app with Make's redirect URL and supplying its client id and secret along with your developer API key and user id. Everything else runs on the ordinary connection.

### Can I remove a scope I no longer need?

No. Make documents that once you add scopes to a connection you cannot remove them, and the only way to hold fewer is to create a new connection. That turns scope selection into a decision rather than a setting, which matters in an org where somebody will eventually ask what this integration can reach.

### Why can my scenario only watch one kind of event?

Because each custom HubSpot application supports a single webhook URL, so one app watches one Make webhook. The practical consequence is that you add every subscription type you need during setup, since Make also documents that webhook subscription types cannot be changed afterwards. Getting this wrong means a new custom app rather than an edit.

Tier requirements, sync behaviour and limits read from each vendor's own documentation in September, October and November 2026. Vendors change these without notice.

Reverse Contact appears in this directory as a data provider and publishes it. Every other tool is here on merit and nobody pays for placement.

Ask an assistant
