• Use Cases
  • Pricing
  • Security
  • Docs
Sign InStart free

The outbound integration layer for SaaS products: emit once, then let Meshes handle routing, retries, fan-out, and delivery history.

© Copyright 2026 Meshes, Inc. All Rights Reserved.

About
  • About
  • Security
  • Blog
  • Contact
  • FAQ
Product
  • Pricing
  • Demo
  • Integrations
  • Guides
  • Changelog
  • Status
Compare
  • All comparisons
  • Build vs buy
  • vs Zapier
  • vs Make
  • vs n8n
  • vs Paragon
  • vs Merge
Use Cases
  • All use cases
  • Payment failed
  • User signup fan-out
  • Churn prevention
  • Trial expired events
  • Lesson completion flows
  • Page completion triggers
  • Page visit Intercom flows
Developers
  • Documentation
  • Agents
  • API Reference
  • MCP Server
  • llms.txt
Legal
  • Terms of Service
  • Privacy Policy
  • Acceptable Use Policy
  • Cookie Policy

IntegrationCRM destination

HubSpot logoHubSpot Integration - Route Product Events to HubSpot

Meshes routes product events into HubSpot through list membership and contact property updates. That lets marketing, sales, and onboarding automation react to real product behavior instead of delayed imports or brittle destination-specific jobs.

Start freeView documentation
DestinationHubSpot|AuthenticationOAuth|Example eventsuser.signuptrial.startedlesson.completed|Actionsadd_to_listremove_from_listupdate_property

The event names shown here are examples. In Meshes, event types are fully customized for each organization.

What you can do

Supported actions with real product context behind them

Create the HubSpot connection in your Meshes workspace with OAuth. Once the account is authorized, Meshes loads the live lists and properties available to that HubSpot portal so rules can target real destinations instead of hardcoded IDs.

HubSpot is often where lifecycle segmentation becomes operational. When user.signup or trial.started lands, teams want the contact in the right list, the right properties updated, and downstream automation ready immediately.

Meshes keeps that logic in your event-routing layer instead of your signup handler or background workers. You emit the event once, map the fields in your Meshes workspace, and let Meshes handle delivery, retries, and replay if HubSpot is temporarily unavailable.

add_to_list

Add contacts to HubSpot lists

Use signup, trial, or activation events to place contacts into the lifecycle list that should trigger HubSpot automation next.

remove_from_list

Remove contacts from lists when state changes

Move users out of the old nurture or trial list when the product event means they have advanced, converted, or churned.

update_property

Write product context into contact properties

Map plan, onboarding stage, qualification, or milestone fields into HubSpot contact properties so reporting and automation use current product data.

Common use cases

How Meshes teams usually put HubSpot to work

These are the workflows where this destination tends to matter first. The point is to keep the product event, the destination action, and the operational retry path in one place.

Start welcome and lifecycle automation on signup

Route user.signup into the right HubSpot list and set initial lifecycle properties the moment a new account is created.

See the signup fan-out use case

Track onboarding or education milestones in contact properties

Use lesson.completed or page completion events to update progress fields that sales, success, and lifecycle marketing can all read.

See the lesson completion guide

Surface high-intent behavior before outreach

Capture visits to pricing, upgrade, or purchase-intent pages and write that context into HubSpot so follow-up happens with better timing.

See the high-intent routing guide

Keep lifecycle state current without manual imports

Let HubSpot automation react to the product event itself instead of waiting for a nightly sync or CSV export to catch up.

How it works

Connect the destination, define the rule, emit the event

In Meshes, the operating model is simple: create the connection in the workspace, create the rule, then let the event delivery layer handle the last mile.

1

Connect HubSpot

Create a HubSpot connection in Meshes, authorize the portal, and confirm the lists and properties you expect are visible in the rule builder.

2

Create routing rules in Meshes

Create rules for events like user.signup or trial.started, choose add_to_list or update_property, then map Meshes event fields into the selected HubSpot targets.

3

Emit the event and review delivery

Emit the product event from your app or use Send Test Event in Meshes. Meshes delivers to HubSpot, retries transient failures, and keeps per-delivery history for replay.

Event example

Emit the product event once

import MeshesEventsClient from '@mesheshq/events';

const meshes = new MeshesEventsClient(
  process.env.WORKSPACE_PUBLISHABLE_KEY!,
);

await meshes.emit({
  event: 'user.signup',
  resource: 'user',
  resource_id: 'usr_2048',
  payload: {
    email: 'alex@northstar.io',
    first_name: 'Alex',
    last_name: 'Nguyen',
    plan: 'growth',
    source: 'product-led',
  },
});

Connection model

OAuth

Create the HubSpot connection in your Meshes workspace with OAuth. Once the account is authorized, Meshes loads the live lists and properties available to that HubSpot portal so rules can target real destinations instead of hardcoded IDs.

Why Meshes

Why teams use Meshes for HubSpot

The benefit is not just that the destination is supported. It is that the destination sits inside the same fan-out, retry, replay, and delivery-visibility layer as the rest of your stack.

Lists and properties stay in one delivery layer

Meshes can drive both membership changes and property updates from the same source event, so HubSpot automation starts with consistent state.

Mappings can evolve without rewriting app code

When HubSpot fields change, you update the Meshes rule and mappings instead of shipping a new destination-specific deploy path.

Retries and replay protect lifecycle automation

A transient HubSpot failure does not have to become missing lifecycle state. Meshes captures the attempt, retries it, and lets you replay after a fix.

It works for customer-facing integrations too

If you expose Meshes workspaces to customers, each workspace can connect its own HubSpot account while your product keeps one event-emission path.

Keep exploring

Related guides, use cases, docs, and comparison pages

These links are the next layer down: concrete patterns, supporting documentation, and the build-vs-buy context that usually comes up during evaluation.

Catalog

All integrations

Browse the full destination catalog and compare HubSpot with the rest of the Meshes integration surface.

Open link

Docs

HubSpot integration docs

See the HubSpot connection flow, rule setup, and testing steps in the product docs.

Open link

Use Case

User signup fan-out

See how one user.signup event can update CRM, lifecycle email, support, and internal alerts at the same time.

Open link

Guide

Add HubSpot properties on signup

See a concrete pattern for writing signup data into HubSpot contact properties from Meshes.

Open link

Guide

Lesson completion to HubSpot progress

Use lesson.completed to keep HubSpot progress fields in sync with product education milestones.

Open link

Compare

Meshes vs. DIY

See what it costs to own HubSpot retries, field mapping, replay, and delivery visibility yourself.

Open link

Next stepStart free, read the docs, or browse the catalog

Start routing product events to HubSpot

Emit user.signup once, let Meshes update lists and properties in HubSpot, and keep lifecycle automation aligned with the product state your teams actually care about.

Start freeView documentationSee all integrations