How to Automatically Summarise New Notion Entries with OpenAI and Post to Slack Using Make.com

Introduction

You rely on Notion database entries as the source for requests, briefs, or handoffs, but someone still reads every new row and writes a short summary before telling the team. That manual step costs time and introduces inconsistent summaries and missed context. You want predictable, short summaries in Notion and a one-line Slack alert so the team can act quickly.

This post shows how to build a production-ready Make.com scenario that watches a Notion database, sends the new entry content to OpenAI for a structured summary, validates and stores the summary back in Notion (or a linked page), and posts a concise, actionable Slack message. You will get the exact modules to use, a copy-paste prompt template that returns JSON, validation rules, and operational gotchas to avoid.

What you'll know by the end: the Make.com modules and mappings to wire Notion → OpenAI → Notion + Slack, the strict JSON prompt to get consistent summaries, and how to add audit logging in Google Sheets to measure drift.

What You'll Need

• Notion account with the database you want to summarise and an integration token authorised in Make.com. You must have permission to create or update pages in that database.
• OpenAI API key. Use deterministic settings (temperature 0–0.2) for consistent summaries.
• Make.com account (paid plan recommended for reliable webhooks, retries, and higher operation quotas).
• Slack workspace and a bot token with permission to post into your destination channel(s).
• Google Sheets account for audit logging and deduplication (recommended). A single sheet will store run_id, notion_page_id, prompt_version, raw_model_output, and parse_status.

Notes on permissions and limits: Notion API rate limits apply; keep writes consolidated. OpenAI costs scale with tokens and frequency; trim inputs where possible.

How It Works (The Logic)

Trigger: a new page is created in a Notion database or a page property flips (for example, Status = "New"). Make.com fetches the page content and relevant properties, builds a cleaned text payload and sends it to OpenAI with a strict prompt that requires JSON: {title, one_line_summary, key_points, action_items, confidence}. Make.com validates the JSON, writes the summary back into Notion (either as page properties or a child summary page), appends an audit row in Google Sheets, and posts a short Slack alert when confidence meets your threshold.

In plain terms: Notion new page → Make.com extracts content → OpenAI JSON summary → Validate → Update Notion + log → Slack alert.

Step-by-Step Setup

1. Decide the trigger and where the summary lives in Notion

• Trigger options: Notion webhooks (if available in your Make account) or Make.com polling of the database using "Watch database items". For reliability use a webhook if you can; otherwise poll a filtered view.
• Choose storage: either a database property (short_summary text, key_points as multi-select or text) or create a child page titled "AI Summary" to store the full structured output. If you use properties keep the summary concise.

Why this matters: use properties for quick scanning, pages for longer audit content.

2. Build the Make.com scenario skeleton

Modules (in order):

1. Notion, "Watch Database Items" or Webhook trigger
2. Notion, "Get a Page" (fetch full block content if you need long text)
3. Tools: Formatter / Text cleanup (strip markdown, remove signatures, limit length)
4. OpenAI: HTTP request or OpenAI module to call Chat Completions or Responses
5. JSON parse + validation step
6. Notion: Update page properties or Create child page with structured content
7. Google Sheets: Append audit row
8. Slack: Post message (conditional on confidence)
9. Error handler branch (notifications and manual review)

3. Clean and limit the Notion text before calling OpenAI

• Extract the blocks you want to summarise. If the page includes long lists or attachments, decide whether to include them. Prefer the first 1,500–3,000 characters of concatenated plain text for summaries.
• Remove boilerplate, pasted HTML, or repeated templates. A simple heuristic is to cut at common separators and keep the first 2,000 characters.

Gotcha: feeding the entire page including long tables and attachments increases cost and can reduce summary quality. Keep inputs focused.

4. Use a strict OpenAI prompt that returns JSON

• Module: OpenAI (Chat Completions) or HTTP POST to the OpenAI Responses API.
• Prompt pattern (copy-paste). Use system + user roles:

System message: You are an internal summarisation assistant for operational handoffs. Return only valid JSON matching the schema exactly. Do not add commentary.

User message (example, map fields): Page title: "{{notion_title}}" Page content: "{{cleaned_text}}"

Return JSON only with these keys: { "title": "short title string (max 60 chars)", "one_line_summary": "one sentence summary (max 140 chars)", "key_points": ["bullet 1", "bullet 2", "bullet 3"], "action_items": [{"who":"email_or_role","what":"one-line task","due":"YYYY-MM-DD or null"}], "confidence": 0.0-1.0 }

Settings: temperature = 0.0, max_tokens = 400, stop sequences optional. Include 1–2 examples in the prompt if your entries follow a specialised format.

Why JSON: structured output makes parsing and mapping into Notion properties straightforward.

5. Parse and validate the model output in Make.com

• Add a JSON Parse module to convert the returned text to data fields.
• Validate:
  • title is non-empty string
  • one_line_summary length <= 140 chars
  • key_points is an array with 1–5 items
  • action_items entries have at least what filled
  • confidence is numeric between 0 and 1

Fallback behaviour: if parsing fails or confidence < 0.60, set needs_human_review = true, write the raw output into Google Sheets, and post to a private Slack review channel instead of updating the public database fields.

6. Write the summary back into Notion

Two options:

• Properties approach: Update the Notion page properties (one_line_summary, key_points_text, summary_confidence). Keep key_points as a single text field or map to multi-select if your values are stable.
• Child page approach: Create a new Notion page under the original page titled "AI Summary" and populate the blocks with Title, Bulleted list for key_points, To-do blocks for action_items, and a small metadata table with confidence and prompt_version.

Module names: Notion "Update a Page" for properties or Notion "Create Page" for a child page. Remember Notion expects property IDs; store these in a Make.com config variable.

Gotcha: Notion API rate limits. Batch writes where possible and avoid updating the same page multiple times in quick succession.

7. Append an audit row to Google Sheets

• Fields to capture: run_id, notion_page_id, notion_title, prompt_version, raw_model_output (or link to Drive), parsed_summary (short), confidence, status (succeeded|review_needed), timestamp.

Why: the audit sheet is how you measure drift and roll back prompt changes if summaries degrade.

8. Post a concise Slack alert

• Only post to the public channel when confidence >= threshold (example 0.70). For high-value items you may choose a higher threshold.
• Slack message template (one-line + link):

[Category or tag if present] {{one_line_summary}} — <Notion link|Open page> • Confidence: {{confidence}}

If action_items exist and contain owners, mention or route to the owner channel. Keep alerts short with one click to the Notion page.

9. Human review workflow

• For low-confidence or malformed outputs post to a private #ai-summaries-review Slack channel with the raw model output and a direct link to the Notion page and the audit row.
• Provide buttons or a simple link that triggers another Make.com webhook the reviewer can call to accept the AI summary, edit and write back, or flag the entry for further action.

This keeps the public channel high signal while allowing humans to correct mistakes.

10. Test and iterate

• Start with a sample set of representative Notion pages. Compare AI summaries to human summaries, log precision and false positives, and iterate on the prompt.
• Version your prompt by storing prompt_version in Google Sheets and in the Notion summary page. If you change the prompt, run a regression on the audit sheet to detect drift.

Real-World Business Scenario

A product team used this flow to summarise incoming feature requests added to a Notion backlog page. Before automation a PM manually read every request and wrote a short summary for triage. After implementing the Make.com scenario, OpenAI produced consistent one-line summaries and 2–3 key points. The automation wrote the summary into the page and posted a single Slack alert to #product-triage for high-confidence items. The PMs saved around 30 minutes daily and had an auditable log of AI suggestions to speed grooming.

We recommend reading our related guide on reliable Notion to Slack updates for deduplication and status transition rules, How to Automate Notion to Slack Updates Using Make.com (No Duplicate Alerts), and our contract-triage case study that integrates Notion with OpenAI and PandaDoc How to Auto-Triage Contract Emails Using Gmail, OpenAI, PandaDoc, Notion and Slack with Make.com for ideas on approval flows.

Common Variations

• Multi-lingual summaries: detect language first and call language-specific prompts or a translation step before summarisation.
• Summarise attachments: fetch text from PDFs or images using OCR and append to the body before summarising, but store the OCR output in Drive and reference it in Notion rather than feeding long raw text to OpenAI.
• Ensemble approach: run a cheap extractive summariser first for obvious cases, and only call OpenAI for longer, ambiguous pages to save cost.

Final notes and implementation help

You built a production pattern: trigger on new Notion entries, use OpenAI to generate strict JSON summaries, validate and write results back to Notion, keep an audit log in Google Sheets, and post a single short Slack alert when confidence is sufficient. Key operational knobs are input trimming, a strict JSON prompt with deterministic settings, a human-review path for low-confidence outputs, and prompt versioning in your audit log.

If you want this implemented, Olmec Dynamics builds these exact automations for product, ops, and support teams and helps tune prompts, error handling, and Notion mappings. See how we work at https://olmecdynamics.com.