HubSpot + Notion: client record from CRM into the knowledge base

When a deal closes in HubSpot, the onboarding and success team needs context about the client - contract value, product, account manager, the specifics of what was agreed. A custom integration via HubSpot webhook and Notion API solves this without manual copying: when a deal moves to “Closed Won,” a client page is automatically created in Notion with all key fields.

A native HubSpot-Notion integration exists, but it solves a different problem - it lets you embed Notion pages inside HubSpot cards. Data does not flow the other way, from CRM into the knowledge base.

In Exceltic.dev projects this is one of the most repeated requests from 20-80-person companies: sales lives in HubSpot, the delivery team lives in Notion. The gap between them costs real time at every onboarding. This article covers the integration architecture, the specific API fields, and the two-way write-back scheme.

The operational pain

Every time a deal closes, an account manager spends 15-30 minutes: copying the contract value, contact, product, and their notes from HubSpot and pasting them into Notion manually. At 10-15 deals per month that is 2-4 hours spent purely on data transfer. Worse - some information gets lost or becomes stale by the time onboarding starts. The success team begins with incomplete context.

Client knowledge base is a structured collection of Notion pages where each client is represented by a separate record with CRM fields, interaction history, and internal team notes.

What the native integration does (and where it stops)

HubSpot App Marketplace contains several connectors for Notion - from Notion itself as well as from third parties (Zapier, Make, n8n). As of Q2 2026, none of them cover the task of full client-card synchronization.

What works in native options:

• Embedding Notion pages inside HubSpot cards in view mode
• Manual page creation via Make/Zapier when a trigger fires

What does not work:

• The native HubSpot-Notion integration does not write data to the deal timeline and does not create Notion pages with CRM fields
• Zapier and Make only support standard HubSpot fields - custom deal properties are not passed through
• Reverse write from Notion to HubSpot (page URL, notes) via no-code tools requires a separate mirrored workflow and often breaks on API updates
• The polling architecture of Make/Zapier creates a 5-15 minute delay and is expensive at volume

The main ceiling: there is no two-way connection. The account manager cannot see the Notion page link inside HubSpot, and the success team cannot add a note in Notion and have it reflected in the CRM.

What the custom integration implements

HubSpot webhook on deal closed-won -> creating a page in Notion

The logic is straightforward: HubSpot Workflows lets you configure a “Deal stage = Closed Won” trigger and send a POST request to an external webhook endpoint. The handler server receives the payload with the deal ID, fetches complete data via the HubSpot CRM API (GET /crm/v3/objects/deals/{dealId}?properties=dealname,amount,closedate,dealstage,hubspot_owner_id), and then calls the Notion API to create a page.

The request structure for the Notion API (POST https://api.notion.com/v1/pages) looks like this:

{
  "parent": { "database_id": "<your-notion-database-id>" },
  "properties": {
    "Name": {
      "title": [{ "text": { "content": "Acme Corp - Enterprise" } }]
    },
    "Amount": {
      "number": 45000
    },
    "Close Date": {
      "date": { "start": "2026-06-15" }
    },
    "Product": {
      "select": { "name": "HubSpot Integration" }
    },
    "Account Manager": {
      "rich_text": [{ "text": { "content": "Anna Ivanova" } }]
    },
    "HubSpot Deal URL": {
      "url": "https://app.hubspot.com/contacts/xxx/deal/12345"
    }
  }
}

Authentication: header Authorization: Bearer <integration-token> plus Notion-Version: 2026-03-11. The token is issued when creating an Internal Integration in Notion settings and has access only to the databases you explicitly share with the integration.

Supported Notion property types for mapping from HubSpot: title, rich_text, number, select, multi_select, date, url, email, phone_number, checkbox. This covers all standard deal fields and most custom ones.

Reverse write: Notion page URL into HubSpot + two-way notes

After the Notion page is created, the API returns the id and url of the new record. The handler server immediately writes this URL to a custom HubSpot deal property via PATCH /crm/v3/objects/deals/{dealId}. From any HubSpot deal card you can now navigate to the Notion client page in one click.

Two-way notes are implemented via a Notion webhook (available in the API): when a block is added to a client page in Notion, the handler creates a Note engagement in HubSpot via POST /crm/v3/objects/notes. This gives the account manager the full picture: internal discussions from the success team are visible in the deal timeline.

Step-by-step integration guide

1. Configure the HubSpot Workflow - trigger “Deal Stage = Closed Won”, action “Send Webhook” with payload: dealId, dealname, amount, closedate, associated_contact_id
2. Handler server (Node.js/Python, hosting: Railway, Heroku, AWS Lambda) receives the POST, verifies the HubSpot signature (X-HubSpot-Signature), fetches complete deal data
3. HubSpot CRM API request - GET /crm/v3/objects/deals/{dealId} with the needed properties, GET /crm/v3/objects/contacts/{contactId} for the contact’s email, name, and company
4. Field mapping - convert HubSpot data types to Notion types (for example, HubSpot timestamp to ISO-8601 for Notion date, numeric amount directly to number)
5. POST to Notion API - create a page in the client knowledge base, receive the page id and url in the response
6. Reverse write to HubSpot - PATCH the deal with the Notion URL into a custom property notion_page_url
7. Notion webhook for notes (optional) - subscribe to database events, write new blocks as Notes in the HubSpot deal timeline

Idempotency: before creating a page the handler checks whether a record with this dealId already exists in the Notion database (query POST /v1/databases/{db_id}/query with a filter on the HubSpot Deal ID field). This prevents duplicates when the webhook fires more than once.

Real-world case

A 35-person B2B SaaS team closing 12-18 deals per month. Before the integration: the account manager spent about 20 minutes manually transferring data to Notion on each deal, and the onboarding manager spent another 10-15 minutes clarifying details in Slack. Total: roughly 6 hours of team time per month just on passing context.

After the custom integration launched: a Notion page is created within 30 seconds of a deal closing. Fields: amount, product, contact, account manager, close date, link to the HubSpot card. Implementation time - 3 business days (webhook setup, handler server, field mapping, staging tests). Ongoing support cost - zero with a stable stack.

A separate win: the success manager adds the first onboarding notes directly in Notion and they automatically appear in the HubSpot deal timeline. The head of sales sees client activity without switching between tools.

Connecting HubSpot to other team work tools is a pattern that Exceltic.dev implements in different configurations. For example, HubSpot + Slack: deal notifications solves a similar problem for real-time team alerts.

Who this integration is right for

The integration is relevant for B2B companies with 20 or more employees where sales and delivery work in different tools. More specifically - when three conditions are met: HubSpot as the main CRM, Notion as the knowledge base or tool for the success/onboarding team, and a regular flow of closed deals from 5 or more per month. At lower volume, manual transfer takes less time than the setup costs.

If your stack already includes custom HubSpot integrations for other services, Notion can be added to the same handler without separate infrastructure.

Not a fit: if Notion is only used as a personal tool by a few people with no shared client database - creating pages without a structured database adds no value.

Frequently asked questions

Which HubSpot deal fields can be passed to Notion?

Via the HubSpot CRM API (GET /crm/v3/objects/deals/{dealId}) all standard deal properties are available: dealname, amount, closedate, dealstage, hubspot_owner_id, as well as any custom properties created in your HubSpot account. Additionally, associated contacts and companies can be retrieved through associations. In Notion these map to property types title, number, date, select, rich_text, url. The only constraint: long text fields (for example, notes from HubSpot) are truncated at 2,000 characters in a single rich_text element in Notion, so long texts are better passed as page blocks (children) rather than as properties.

Why not use Zapier or Make instead of custom development?

Zapier and Make handle simple scenarios: one field from a standard HubSpot property into one Notion block. Problems start with custom fields, reverse URL write-back to HubSpot, idempotency (Zapier does not check for duplicates), volume (at 20+ deals per month the cost of Zapier on this workflow adds $50-100/month), and especially two-way note synchronization. A custom integration solves all of these with a one-time development cost and no recurring per-”zap” charges.

How do I set up Notion API authentication?

For an Internal Integration (the most common case), create an integration at developers.notion.com/reference: Settings -> My integrations -> New integration. You will receive a token in the format secret_xxxxxxxx. Add the integration to the relevant Notion databases via Share -> Invite. In requests use the header Authorization: Bearer secret_xxxxxxxx plus Notion-Version: 2026-03-11. The token does not expire automatically, but if it is compromised it can be rotated in the integration settings without changing any code.

What happens if the HubSpot webhook fires twice for the same deal?

This is a real scenario: if a manager accidentally moves a deal out of “Closed Won” and back, the workflow fires again. Duplicate protection: before creating a page, the handler queries the Notion database (POST /v1/databases/{db_id}/query) with a filter on the custom “HubSpot Deal ID” field. If the record already exists, the handler updates it (PATCH /v1/pages/{page_id}) instead of creating a new one. This is the standard idempotency pattern for webhook integrations.

How long does implementation take?

For the standard scenario (HubSpot Workflow -> webhook -> create Notion page with 5-8 fields -> reverse URL write-back) - 2-3 business days including testing. If two-way note synchronization is needed - add 1-2 days. Adding new fields after launch takes 1-2 hours. Prerequisite: a structured Notion client database with a schema to write data into.

If your sales team works in HubSpot and onboarding and success work in Notion, with Slack messages and manual copy-paste bridging the gap right now - describe the problem to the Exceltic.dev team. We will map out the field schema for your stack and estimate the scope of work.

See also: HubSpot AI call summary into the contact card - a similar pattern of automatically enriching a CRM card from external sources.