How to integrate Unify with Notion

To integrate Unify with Notion, send a Play webhook to the Create a page API with a connection token, a Notion-Version header, and a parent data source. Map prospect fields to that data source’s property schema. The connection needs access to the parent and Insert Content capability.[1][3]

By UnifyDocumentation reviewed September 15, 2026

Explore scenarios Technical setup Open Unify

Connection: Via webhook; Team collaboration
Tool: Notion; Notion Create a page API
Data flow: Unify → Notion; JSON payload

At a glance

Choose a data source the connection can access
Map typed values to the actual schema
Give the created item a clear human purpose

When this workflow makes sense

Start with the decision your team needs to make, then choose the connection that supports it.

A Notion item is useful when the next step needs context and human judgment. Keep the incoming prospect facts separate from reviewer notes and decisions. Name the person who checks the item, and decide whether another handoff should create a new review or update the existing one.

A good fit when

Teams that use Notion data sources for owned prospect research or manual review.

Reconsider the plan when

If the destination needs transactional uniqueness or rapid automated state changes, use a system designed for those requirements or add a controlled intermediary.

Design the handoff

Use this framework to agree on the input, the next action, and who owns the result.

Suggested workflow design, based on the documented capabilities below.

Stage	Decision to make
Parent	Choose a data source the connection can access
Properties	Map typed values to the actual schema
Review	Give the created item a clear human purpose
Repeats	Decide whether another delivery should create another item

Explore the scenarios

Choose the situation that fits your team and work through the proposed plan.

Open a scenario to explore its plan. Checklists track your selections in this page only.

Create a research review item

A rep needs a place to review prospect facts before acting.

The decision that matters

Make the page useful to its reviewer, not merely a JSON archive.

Choose the data source and reviewer
Map a controlled record into its properties
Inspect the item with its intended owner

Your validation checklistThe correct parent receives the itemThe properties contain the expected factsThe reviewer knows the next action

0 of 3 checks marked by you

Handle a data source schema change

A teammate renames or changes a mapped property.

The decision that matters

Treat the schema as a maintained contract.

Record the properties used by the request
Test a schema change with a controlled item
Update mapping and inspect the next result

Your validation checklistThe changed property is accounted forFailures stay visibleThe new item uses the intended schema

0 of 3 checks marked by you

Illustrative workflow, not a preconfigured automation. Complete these checks in your own account.

Define success before launch

Inspect the data and the intended outcome separately. Connection status is only the first check.

Expected, not tested

A new page appears in the intended Notion data source with the expected title and email.

Inspect the page in its actual parent. An HTTP result is not a human review decision, and repeating Create a page can create another item.

Documentation-based reference. This workflow has not been tested end to end. Use a record or event you control before enabling live activity.

Questions answered

Common decisions when connecting Unify and Notion.

Does Unify have to send a generic prospect JSON object to Notion?

No. The Create a page API expects a parent and typed properties. Map the fields into that request shape.[3]

Which parent ID should I use?

For this data-source example, use parent.data_source_id and verify that the connection can access it.[3]

Which Notion capability is required?

Create a page requires Insert Content capability on the target parent, along with access to that content.[3]

Will this update an existing prospect page?

No. This example creates a new page. Searching for a match and updating it requires another implementation.[3]

Why include Notion-Version?

The header selects the version of the API contract. This example pins 2026-03-11 rather than relying on an unstated default.[5]

Limits & decisions

Check these boundaries before designing a live workflow around the connection.

Property names and types in the example must be adapted to your data source
Create a page does not establish deduplication or bidirectional synchronization
Unify does not expose the returned page body to later Play steps
No live Notion page was created

What the connection supports

Understand the connection, the data involved, and the behavior that matters for a Unify + Notion workflow.

Connection flowVia webhook

Unify

Notion

Prospect data

POST / JSON

Documented behavior at a glance
Decision	What to know
Operation	POST /v1/pages creates a child page[3]
Parent	A data_source_id selects the target data source[3]
Properties	Names and values must match the parent schema[3]
Authorization	The connection needs content access and Insert Content capability[3]
Version	Notion-Version selects the API contract[5]

Technical setup reference

References and requirements for the Notion connection.

Unify reference: Webhook action Notion reference: Create a page

Connection requirements and setup checklist

Before connecting

A Unify Play with a Webhook action
A Notion connection with Insert Content and access to the parent
The parent data_source_id and its actual property schema
An agreed review owner and repeat-delivery policy

Give the connection access
Create or select a Notion connection and grant access to the target parent. Confirm Insert Content capability. Access to a workspace does not automatically make every parent available to the connection.[3][4]
Read the property contract
Identify the data source ID and its property names and types. This sample assumes a title property named Name and an email property named Email. Adapt the body to your actual schema.[3]
Configure the request
In Unify, choose POST, JSON, and Bearer Token authentication. Add Notion-Version: 2026-03-11. Set parent.data_source_id and construct typed property values rather than sending the generic prospect object unchanged.[1][3][5]
Inspect a created item
Check Expand preview, send a controlled sample, and inspect the returned page and its parent in Notion. Confirm the title and email match the input before enabling the Play.[2][3]
Choose how to handle repeats
Create a page creates a new item. If one page per prospect is required, implement a separate lookup and update path, with an explicit policy for uncertain responses and retries.[2][3]

Request configuration

Method: POST
URL pattern: https://api.notion.com/v1/pages
Headers: Content-Type: application/json
Authorization: Bearer YOUR_NOTION_CONNECTION_TOKEN
Notion-Version: 2026-03-11
Authentication: Use Bearer Token authentication with the Notion connection token. Grant the connection access to the target parent and Insert Content capability. Send Notion-Version: 2026-03-11, the version used by this example.

Choose JSON as the body format. Unify sets Content-Type automatically. The receiver must respond within Unify’s 8-second timeout; request responses are not passed to later Play steps.[2]

Replace URL placeholders with the actual receiver URL from your account or deployed application. These example URLs are not working endpoints.

Example handoff payload

Start with a fictional prospect. Validate the resolved values before using a real record.

Inspect the sample payload and field mapping

Example request body

{
  "parent": {
    "data_source_id": "YOUR_DATA_SOURCE_ID"
  },
  "properties": {
    "Name": {
      "title": [
        {
          "text": {
            "content": "Avery Morgan"
          }
        }
      ]
    },
    "Email": {
      "email": "avery@example.com"
    }
  }
}

Fictional data. Replace sample values before using a real Play.

Fictional example for a data source with Name (title) and Email (email) properties. Replace the parent ID and adapt the property schema before sending. Use the field mapping to distinguish record data from fixed settings. Select available fields in your Play and inspect Expand preview; do not replace configuration values with prospect data.[2][3]

Payload field	Value to send
`parent.data_source_id`	Set the actual parent data source ID, not a prospect field
`properties.Name.title[0].text.content`	Map the person name using documented Unify fields and check Expand preview
`properties.Email.email`	Map the intended person email and validate the target property type

Replace the parent ID with your data source ID. Map the title text to the documented person-name value available in the Play and Email.email to the intended person email. Property names and types must match your Notion schema.

Troubleshooting

Start with the stage where the expected data or action stops appearing.

The parent is unavailable

Check the parent ID and the connection’s access to that content. Confirm Insert Content capability before changing the payload.[3][4]

The property request is rejected

Compare Name and Email with the real data source schema. Their types matter as well as their labels.[3]

Two review items appear

Inspect delivery retries and your desired identity rule. This example creates pages and does not implement an atomic find-or-create operation.[2][3]

Sources & review

Official documentation reviewed on September 15, 2026.

Technical claims link to primary documentation from Unify and the destination tool. Scenarios, field choices, and recovery plans are editorial implementation examples. Documentation review is separate from execution testing.

Documentation reviewed; end-to-end execution not tested. No named technical reviewer has signed off on these articles yet.

Content updated: 2026-09-16. Report a correction to Unify with the tool name, source URL, and behavior you observed.

How to integrate Unify with Notion