How to Sync HubSpot Deals to Slack and Notion Automatically
Summary
- The native HubSpot Slack integration sends one message per deal event, which can overwhelm channels during bulk updates and lead sales teams to mute notifications.
- The solution is a four-step workflow: query only qualifying deals with the HubSpot CRM Search API, enrich with owner and company names, post a single Block Kit digest to Slack, and log each deal to a Notion database.
- The workflow uses a
createdatefilter withlast_successful_run_timestampfor incremental pickup, deduplicates Notion rows byhs_object_id, and stays under 5 Search API requests per second. - Jinba Flow enables teams to deploy batched, enriched HubSpot deal alerts in days instead of months of custom development.
The native HubSpot Slack integration fires a notification for every deal event. Stage changes, property edits, and owner reassignments each become a Slack message. During a bulk import or a round of mass reassignments, a single operation can generate dozens of messages in a channel. Sales teams often mute the channel in response, which removes the signal.
The limitation is structural: the native tool has no batching, no amount threshold, and no way to resolve a hubspot_owner_id into a readable name before sending. It also writes nothing to a system of record. Teams either copy deal details into Notion manually or forgo logging.
This guide presents a four-step automated workflow that replaces that pattern. It queries HubSpot for only the deals that meet defined criteria, enriches each result with the owner name and company, posts a single structured digest to Slack, and logs each deal to a Notion database.
Why the native integration falls short
The HubSpot Slack integration is configured at the workflow level and fires per-event. Every qualifying trigger sends its own message. There is no native option to batch these into a digest, and the filtering options do not extend to deal amount, specific close date ranges, or custom properties.
Three capabilities are structurally absent:
- Fine-grained filtering: the native integration cannot suppress messages below a deal amount threshold or outside a close date window.
- Data enrichment: the notification carries the
hubspot_owner_idvalue, not the owner's name. Resolving that ID requires a separate API call the native tool does not make. - Cross-system logging: there is no native path from HubSpot to a structured Notion database. The record exists only in the CRM.
The custom workflow below fills each of these gaps.
Step 1: Query only the deals that matter
The HubSpot CRM Search API accepts a POST request to /crm/v3/objects/deals/search. The request body takes a filterGroups array, which supports stacking multiple conditions.
A query targeting deals in the "Appointment Scheduled" stage with a value above $5,000, created after a recorded timestamp, looks like this:
{
"filterGroups": [
{
"filters": [
{ "propertyName": "dealstage", "operator": "EQ", "value": "appointmentscheduled" },
{ "propertyName": "amount", "operator": "GT", "value": "5000" },
{ "propertyName": "createdate","operator": "GT", "value": "{{last_successful_run_timestamp}}" }
]
}
],
"properties": ["dealname", "amount", "hubspot_owner_id", "closedate", "hs_object_id"],
"limit": 100,
"after": 0
}
The createdate filter is the incremental pickup mechanism. Each run passes the timestamp from the previous successful run. This ensures the workflow processes only new deals and does not resubmit results already sent to Slack and Notion.
The response shape is { total, results[], paging }. Each item in results carries an id and a properties object. For subsequent pages, pass paging.next.after as the after value in the next request.
The Search API enforces a rate limit of 5 requests per second. Workflows that page through large result sets should insert a short delay between requests to stay within this limit.
Step 2: Enrich each deal with owner and company names
The search result returns hubspot_owner_id as a numeric identifier. Sending that value to Slack produces a message that cannot be acted on.
The owner name is resolved with a GET request to /crm/v3/owners/{ownerId}. The response includes firstName, lastName, and email. The first and last name are concatenated for use in the notification.
Resolving the associated company requires two calls. First, retrieve the deal's associations using the HubSpot Associations API to find the linked company ID. Then fetch the company record to extract its name property. This step is optional, but it elevates the notification from a deal ID to a named account, which sales teams act on.
Step 3: Post a curated digest to Slack
With enriched data, the workflow posts a single structured message per run rather than one message per deal. This is the core change that makes the HubSpot Slack integration usable: one digest instead of a stream of individual events.
The Slack chat.postMessage method accepts a channel argument (channel ID or name) and a blocks array for structured formatting. The method requires the chat:write scope on the bot token.
Using Slack Block Kit instead of plain text allows the message to display deal name, amount, owner, company, and close date as labelled fields. A representative block structure:
{
"channel": "#new-deals",
"blocks": [
{
"type": "section",
"text": { "type": "mrkdwn", "text": "*New High-Value Deal:* {{deal.properties.dealname}}" }
},
{
"type": "section",
"fields": [
{ "type": "mrkdwn", "text": "*Amount:*\n${{deal.properties.amount}}" },
{ "type": "mrkdwn", "text": "*Owner:*\n{{owner.firstName}} {{owner.lastName}}" },
{ "type": "mrkdwn", "text": "*Company:*\n{{company.properties.name}}" },
{ "type": "mrkdwn", "text": "*Close Date:*\n{{deal.properties.closedate}}" }
]
}
]
}
The channel value can also be a Slack user ID to send a direct message. Platforms that support dynamic routing can map the hubspot_owner_id to a Slack user ID and send deal alerts directly to the owner rather than a shared channel.
Step 4: Log each deal to a Notion database
The Notion API creates a new database row via POST https://api.notion.com/v1/pages. The request requires three headers: Authorization: Bearer <token>, Content-Type: application/json, and Notion-Version: 2022-06-28.
The parent object in the request body specifies the target database:
{
"parent": { "database_id": "YOUR_NOTION_DATABASE_ID" },
"properties": {
"Deal Name": { "title": [{ "text": { "content": "{{deal.properties.dealname}}" } }] },
"Amount": { "number": {{deal.properties.amount}} },
"Owner": { "rich_text": [{ "text": { "content": "{{owner.firstName}} {{owner.lastName}}" } }] },
"Close Date": { "date": { "start": "{{deal.properties.closedate}}" } },
"HubSpot Deal ID": { "number": {{deal.properties.hs_object_id}} }
}
}
The POST /v1/pages endpoint carries no idempotency key. Calling it twice for the same deal produces two rows. To prevent duplicates, the workflow queries the Notion database before creating a page. It filters by the "HubSpot Deal ID" property. If the query returns any results, the create call is skipped. The hs_object_id from HubSpot is the stable identifier to use as that key.
Putting it all together: a complete SKILL.md workflow
The following is a complete SKILL.md file that packages the four steps above into a single agent skill. The allowed-tools list maps directly to the pre-authorised MCP tool connectors the agent uses.
---
name: SyncHotHubSpotDeals
description: "Finds HubSpot deals over $5k in Appointment Scheduled stage, enriches each
with owner and company names, posts a curated digest to Slack, and logs new
deals to a Notion database. Uses incremental pickup via createdate filter."
allowed-tools:
- HUBSPOT_SEARCH_DEALS
- HUBSPOT_GET_OWNER
- HUBSPOT_GET_COMPANY_BY_ASSOCIATION
- SLACK_POST_MESSAGE
- NOTION_QUERY_DATABASE
- NOTION_CREATE_DATABASE_ITEM
---
# Step 1: Search for qualifying deals using incremental pickup.
# Rate limit: 5 req/s on the Search API. Add delay between pages if result set is large.
- tool: HUBSPOT_SEARCH_DEALS
inputs:
filter_groups:
- filters:
- { propertyName: "dealstage", operator: "EQ", value: "appointmentscheduled" }
- { propertyName: "amount", operator: "GT", value: "5000" }
- { propertyName: "createdate",operator: "GT", value: "{{last_successful_run_timestamp}}" }
properties: ["dealname", "amount", "hubspot_owner_id", "closedate", "hs_object_id"]
limit: 50
# Step 2: Enrich and sync each deal found.
- for_each: deal in HUBSPOT_SEARCH_DEALS.results
do:
# Step 2a: Resolve hubspot_owner_id to a readable name.
- tool: HUBSPOT_GET_OWNER
inputs:
owner_id: "{{deal.properties.hubspot_owner_id}}"
# Step 2b: Resolve the associated company name.
- tool: HUBSPOT_GET_COMPANY_BY_ASSOCIATION
inputs:
deal_id: "{{deal.properties.hs_object_id}}"
# Step 3: Post a curated Block Kit message to #new-deals.
- tool: SLACK_POST_MESSAGE
inputs:
channel: "#new-deals"
blocks:
- type: "section"
text:
type: "mrkdwn"
text: "*New High-Value Deal:* {{deal.properties.dealname}}"
- type: "section"
fields:
- { type: "mrkdwn", text: "*Amount:*\n${{deal.properties.amount}}" }
- { type: "mrkdwn", text: "*Owner:*\n{{HUBSPOT_GET_OWNER.firstName}} {{HUBSPOT_GET_OWNER.lastName}}" }
- { type: "mrkdwn", text: "*Company:*\n{{HUBSPOT_GET_COMPANY_BY_ASSOCIATION.properties.name}}" }
- { type: "mrkdwn", text: "*Close Date:*\n{{deal.properties.closedate}}" }
# Step 4a: Check for existing Notion record before creating a duplicate.
- tool: NOTION_QUERY_DATABASE
inputs:
database_id: "YOUR_NOTION_DATABASE_ID"
filter:
property: "HubSpot Deal ID"
number:
equals: "{{deal.properties.hs_object_id}}"
# Step 4b: Create Notion record only if no existing row was found.
- if: "NOTION_QUERY_DATABASE.results | length == 0"
then:
- tool: NOTION_CREATE_DATABASE_ITEM
inputs:
database_id: "YOUR_NOTION_DATABASE_ID"
properties:
"Deal Name": { title: [{ text: { content: "{{deal.properties.dealname}}" } }] }
"Amount": { number: "{{deal.properties.amount}}" }
"Owner": { rich_text: [{ text: { content: "{{HUBSPOT_GET_OWNER.firstName}} {{HUBSPOT_GET_OWNER.lastName}}" } }] }
"Close Date": { date: { start: "{{deal.properties.closedate}}" } }
"HubSpot Deal ID": { number: "{{deal.properties.hs_object_id}}" }
What this workflow delivers
The four steps above replace three separate failure modes with a single scheduled job.
The createdate filter with last_successful_run_timestamp means each run processes only new deals. Resubmissions and duplicate Notion rows are eliminated once the de-duplication query is in place.
The enrichment calls convert raw IDs into names. The Slack digest carries deal name, amount, owner, company, and close date in a single structured message rather than a stream of per-event pings. Teams can stop muting the channel because it carries a consolidated digest.
The Notion log creates a queryable record outside the CRM. Sales operations teams can filter by owner, stage, or amount without a HubSpot licence, and the record persists independently of any workflow change in HubSpot.

Sales teams that need additional filtering can extend the filterGroups block. Adding a closedate filter with LT and a date value restricts results to deals closing within a specific window. Swapping appointmentscheduled for another deal stage identifier targets a different part of the pipeline. The YAML is the reusable unit; the criteria inside it are the variables.
The next step is to schedule the skill. Running it as a shared agent skill on a consistent interval ensures the workflow executes on a defined cadence without manual triggering.
Frequently Asked Questions About HubSpot Slack Deal Alerts
Why is the HubSpot Slack integration sending too many notifications?
The native HubSpot Slack integration sends one message per qualifying event, so bulk deal updates can generate dozens of notifications in a channel. It does not provide batching, amount thresholds, close-date filtering, or owner-name enrichment. Sales teams often mute the channel to avoid noise, which removes the signal entirely. A custom workflow that queries deals in batches and posts one structured digest addresses the root cause.
Can HubSpot send a batched deal digest to Slack natively?
No. The native HubSpot Slack integration is configured at the workflow level and fires per event, so it cannot group multiple deals into a single digest. To send a batched digest, organizations use the HubSpot CRM Search API to collect qualifying deals, enrich them with owner and company data, then post one Slack chat.postMessage request with Block Kit fields. This produces a single structured message per run instead of a stream of individual notifications.
How do I filter HubSpot deals by amount and close date before posting to Slack?
Filtering uses the HubSpot CRM Search API with a filterGroups array and filters for amount, closedate, and dealstage. For example, amount set to GT 5000 and closedate set to LT a target date restricts alerts to high-value deals closing in a specific window. The native Slack integration cannot apply these deal-property thresholds, so the Search API is the required filtering layer.
How do I show the HubSpot deal owner's name in Slack instead of the owner ID?
The deal search returns hubspot_owner_id as a numeric ID, so the workflow resolves it with a GET /crm/v3/owners/{ownerId} call and concatenates firstName and lastName. That readable name is passed into the Slack Block Kit message instead of the raw owner ID. The native HubSpot Slack notification does not make this extra API call, which is why owner IDs often appear unresolved.
How do I log HubSpot deals to a Notion database automatically?
The workflow queries HubSpot deals with the CRM Search API, transforms the deal properties into Notion page properties, then calls POST https://api.notion.com/v1/pages with the target database_id. It maps dealname to a title property, amount to number, closedate to date, and hs_object_id to a stable HubSpot Deal ID field. This creates a structured, queryable record outside the CRM without manual copying.
How do I prevent duplicate Notion pages when syncing HubSpot deals?
The workflow checks Notion for an existing row before creating a page. It queries the target database filtered by the "HubSpot Deal ID" property using hs_object_id, and it skips the create call if any result is returned. The Notion POST /v1/pages endpoint has no idempotency key, so this pre-check is the reliable way to avoid duplicate rows.
How do I make the workflow process only new HubSpot deals?
The workflow adds a createdate filter to the HubSpot Search API request with the GT operator and passes the last_successful_run_timestamp from the previous successful run. That incremental pickup ensures each run processes only deals created since the last run, so the workflow does not resend results already posted to Slack or logged to Notion. The timestamp is stored after a successful run to keep the next execution accurate.
What HubSpot and Slack APIs are needed for a custom deal alert workflow?
The workflow requires the HubSpot CRM Search API for deal filtering, the Owners API for owner names, and the Associations API plus company record endpoint for company names. It then uses Slack chat.postMessage with chat:write and Block Kit for the digest, and the Notion API for database logging. Together these APIs replace the native integration's missing batching, enrichment, and cross-system logging.
How often should a HubSpot-to-Slack deal digest run?
The workflow runs on a cadence that matches the sales response window, such as every 15 to 60 minutes for high-velocity teams or once daily for lower-volume pipelines. It uses last_successful_run_timestamp for incremental pickup, so the schedule controls freshness without causing duplicates. For high-volume portals, a delay between Search API pages keeps request volume within the 5 requests per second limit.
