HubSpot CRM Make integrationAutomate HubSpot CRM with Make.

One search covering contacts, companies, deals, tickets, products and line items, either by a property you name or by a plain query.

Drops the records you hand it into a list you choose, which is how a scenario passes work back to the people who live inside HubSpot.

Takes records back out of a list. The name says delete, the effect is narrower: the record stays in the CRM, it simply leaves that list.

Reads the definition of a property from its internal name: how the field itself is set up, not what a given record holds in it.

Writes a record of one of your custom object types and returns a copy with its ID, so the rest of the chain can keep working on it.

Pulls one custom object record by its ID and puts its current values into the scenario.

Changes the properties of a custom object record identified by its ID, and returns what it wrote.

Sends a custom object record to the recycling bin, out of the views your team works in every day.

Looks at the email you pass it. No contact with that address, one gets created. A contact already there, its properties get updated.

The previous generation of list writing, still visible in the app documentation and carrying no description of its own.

The old way of pulling a batch of contacts out of the portal, also marked deprecated and also without an official description.

Adds a contact with the properties you map and returns a copy including the ID for the modules that follow.

Rewrites the properties of the contact you point at with its ID, and returns what it changed.

Fetches one contact and drops its current values into the scenario.

Runs a query against the contacts of your portal and returns what matches, as zero, one or several bundles that the following modules handle one at a time.

Folds two contact records into one, the only clean answer to the duplicate that two imports quietly created.

Moves a contact to the recycling bin, where it stops appearing in the lists and the reports your team reads.

Opens a deal with the properties you map and returns it with its ID, ready to be associated or updated further down the chain.

Changes the properties of one deal identified by its ID, and returns the updated values.

Reads a single deal and makes its properties available to the rest of the scenario.

Returns the deal and ticket pipelines of your portal, with the stages each of them contains.

Lists the deals matching the filters or the query you give it.

Sends a deal to the recycling bin.

Writes a company record and returns it with the ID the next modules will need.

Updates the properties of one company by its ID and returns the result.

Reads one company record into the scenario, with the values it currently holds.

Finds companies from the filters or the query you set.

Moves a company to the recycling bin.

Logs an interaction against a record: a note, a task, an activity, the kind of trace that tells the next person what already happened.

Removes a task or an activity logged on an object.

Writes a custom event on the timeline of a record, so activity born in your own product sits next to the calls and the emails.

Returns the timeline event types declared for an application, which is how you find the one your scenario should write into.

Makes a folder in the HubSpot file manager.

Returns what sits in the file manager, one bundle per file for the modules that follow.

Puts a new file into the file manager, coming from a previous module or from a download step.

Moves a file from one folder of the file manager to another, despite a name that promises something broader.

Erases a file for good, along with the related data and the thumbnails that came with it.

Marks a folder as deleted in the file manager.

Returns the details of one owner, meaning the HubSpot user a record is assigned to.

Brings back every owner in the portal, one bundle each.

Straight from your scenario, Create a Ticket files a support case in HubSpot, so the request lands in the same queue your team already works from.

Once a case moves on, Update a Ticket rewrites the ticket you point at instead of opening a second one. The whole history stays on a single record.

Hand it a ticket ID and Get a Ticket reads that one ticket back, with enough detail for the scenario to decide what happens next.

Matching tickets come back one result after another with Search for Tickets, and the rest of the scenario runs on each of them.

Removing a ticket from HubSpot is all this module does, and it is how a rehearsal stops polluting the numbers your team reports on.

When someone attaches a document to a HubSpot form, this module pulls that file into the scenario from its file ID, ready to go somewhere else.

Finding the right form without digging through HubSpot starts with List Forms, which gives the scenario every form in the account.

Once Submit Data to a Form sends an entry into a HubSpot form from your scenario, a signup collected elsewhere arrives the way a real submission would.

This one drops a contact into a HubSpot workflow, the chain of automatic steps your team already set up on their side. It starts on its own for that person.

The mirror move: the contact leaves the workflow, and the sequence stops when it no longer matches what that person just did.

When a person agrees to receive a given type of email, Subscribe Contact records it, and the consent sits on their contact record in HubSpot.

Going the other way, this module unsubscribes a contact from the emails you name, which is how an opt-out collected outside HubSpot reaches the CRM.

Two HubSpot records get tied together with Create an Association, a contact to a company or a deal to a ticket, and the link shows on both sides.

Ask it about one record and it returns the IDs of the records linked to it, for the association type you choose.

Cutting the link between two records while leaving both records alone is what Delete an Association does, and it helps when only the relationship was wrong.

Logging a phone conversation on a HubSpot record from what the scenario already holds is the job of Create a Call, which hands back the new call including its ID.

Already logged the call and something changed? Update a Call rewrites the properties of that one call and returns the new version.

A single logged call comes back into the scenario through Get a Call, so the next step works on fresh data rather than on a copy.

Goes through every call in the account and returns the ones that pass your filters, one result per call.

This module moves a logged call to the recycling bin, the clean way to clear what a test scenario left behind.

A note is the free text HubSpot keeps on a record. This module writes one from whatever the scenario gathered, and the reply carries its ID.

The text of a note that already exists gets replaced by Update a Note, so the record keeps one clear entry rather than a trail of corrections.

Point this module at a note ID and it reads the note back, text included, for whatever comes next.

Filters go in, matching notes come out. Search for Notes covers the case where a scenario hunts for text written on records without knowing a single ID.

This module does one thing: it sends the note whose ID you hand over to the recycling bin.

From the scenario, Create a Task puts a to-do into HubSpot and returns the new task with its ID. The follow-up exists before anyone thinks to write it.

An existing to-do gets edited by Update a Task, which is how a scenario marks progress instead of stacking near duplicates.

One ID in, one task out. Get a Task reads a single to-do so the scenario knows where it stands before acting.

Without you needing to know a single ID in advance, Search for Tasks returns the to-dos that meet your criteria.

A to-do dropped into the recycling bin by Delete a Task leaves the list for the whole team, not only for whoever was following it.

Once the scenario has the data, Create a Product adds an entry to the HubSpot catalog and returns the new product with its ID.

A name changes, a price changes, and Update a Product rewrites that one catalog entry before returning what was modified.

The reference already sits in the catalog, and Get a Product fetches its record so the scenario works on the HubSpot version.

When all you have is a name, Search for Products surfaces the catalog entries that match, one per result.

Pulling a reference out of the catalog and into the recycling bin is what Delete a Product does, out of everything the scenario builds afterwards.

Adding a line to the sales document your scenario is building is the job of Create a Line Item, which returns the new line and its ID.

A quantity to correct, a line to revise: Update a Line Item changes the line you point at and returns what it now contains.

On a sales document, this read targets one line and one only, the one whose ID you pass in.

Instead of knowing every ID, Search for Line Items returns the lines that pass your filters and hands them to the next module one by one.

The line goes to the recycling bin and the sales document really does lose it.

A new order gets written into HubSpot from the properties your scenario passes, and Create an Order hands back a copy with its ID. Later modules use that ID to attach anything else belonging to the same order.

Give this module an order ID and the properties you want changed. HubSpot applies them to that one order, then returns the new values for the rest of the scenario to read.

Reading comes before deciding. Get an Order pulls a single order back from HubSpot and drops its current values into the scenario, changing nothing along the way.

Somewhere in HubSpot sits the handful of orders you care about. Search for Orders finds them from your filters or your query, and each match leaves as its own bundle, the single item the next module receives.

Sending an order to the HubSpot recycling bin is the whole job here, and the module does it without asking anyone first.

A meeting logged in HubSpot is what the next person opening the record sees. Create a Meeting adds one from the properties your scenario supplies and returns it with its ID.

Times move and records should follow. Update a Meeting rewrites the properties you send on the meeting whose ID you point at, then returns them as HubSpot saved them.

One meeting, all its stored values, no edits: that is what this module brings back to the scenario.

Ask by criteria rather than by ID, and Search for Meetings answers with every meeting matching your filters or your query.

HubSpot keeps what you delete in a recycling bin, and this module is what puts a meeting there. The record leaves the timeline your scenario was reading.

Every email worth keeping in the CRM has to get there somehow. Create an Email puts one in from the properties your scenario passes and returns a copy with its ID.

Something logged against a record turns out wrong. Update an Email corrects the properties you send on the email whose ID you give it, and returns them as saved.

What did that email actually say? Get an Email brings the record back into the scenario so the modules after it work from the real content.

Filters or a search query go in, the matching email records come out. This is how a scenario finds them when it has no ID to start from.

This one takes an email record out of sight. It lands in the recycling bin, off the HubSpot record the rest of your team reads.

Exchanges live in HubSpot as objects, and a communication is one of the types on offer. Create a Communication adds one from the properties your scenario sends and returns it with its ID.

Once a communication exists, this is how its values change: the ID of the record, the properties to set, and HubSpot returns what it stored.

Sometimes a scenario only needs to look. Get a Communication returns one exchange exactly as HubSpot holds it, without writing anything back.

Takes your filters or a query and returns the exchanges that match, one bundle per exchange.

The exchange whose ID this module receives goes to the recycling bin, and the run carries on.

Invoices are the one group in this app you can only read. Get an Invoice returns a single invoice, so a scenario can work from what accounting already recorded.

When the scenario has no invoice ID to start from, this is the way in: filters or a query, and back come the invoices that match.

Sales rarely remembers a quote ID. Search for Quotes works from the criteria you set instead, and returns the matching quotes one bundle at a time.

A new quote starts here. Create a Quote makes one in HubSpot from what the scenario passes, so the document exists before anyone opens the CRM.

With the quote ID in hand, Get a Quote returns that quote and only that one. Nothing is written, nothing is searched.

Prices move and dates slip. Update a Quote keeps the HubSpot copy in line: give it the quote ID and the values to change.

Cleanup is the reason this module exists: hand it a quote ID and the quote goes away.

When the list above stops short of what you need, Make an API Call is the way out: it calls any endpoint of the HubSpot CRM API through the connection your other modules already use.