Notion Updates 2026: Every New Feature in April and How to Use Them

Notion shipped ten features in April 2026 that change how teams build workflows, write automations, and interact with the AI layer. This guide walks through each update with practical examples so you can put them to work immediately, not just read about them.

What Shipped in April 2026: Quick Reference

| Feature | Category | Who Benefits | Effort to Adopt | |---|---|---|---| | Workers for Agents | AI + Dev | Developers, power users | Medium (requires JS/TS) | | Voice input for AI | AI | All desktop users | Zero (just speak) | | AI meeting notes via Cmd+K | AI | Meeting-heavy teams | Zero | | Custom meeting note instructions | AI | Workspace admins | Low (one-time config) | | Views API (8 endpoints) | API | Developers | Medium | | Heading 4 in API | API | Content migration tools | Low | | Tab block API support | API | Template builders | Low | | Writable wiki verification | API | QA/docs teams | Low | | Smart filters | API | App builders | Low | | Academy in 6 new languages | Education | Non-English teams | Zero |

Workers for Agents: Writing Your First Worker

Workers let Notion AI execute actual code instead of guessing from visible text. Before April 2026, asking "What percentage of deals closed this quarter?" produced an approximation. Now the AI runs a function that queries your database and returns the exact number.

Here is a minimal Worker that calculates close rate:

// notion-worker: close-rate-calculator
export async function run(params: { databaseId: string; quarter: string }) {
  const pages = await notion.databases.query({
    database_id: params.databaseId,
    filter: {
      and: [
        { property: "Quarter", select: { equals: params.quarter } },
        { property: "Stage", select: { does_not_equal: "Lead" } }
      ]
    }
  });

  const won = pages.results.filter(
    p => p.properties.Stage.select.name === "Closed Won"
  ).length;
  const total = pages.results.length;

  return {
    closeRate: total > 0 ? ((won / total) * 100).toFixed(1) + "%" : "0%",
    won,
    total,
    quarter: params.quarter
  };
}

Key limitation: Workers are stateless. Every invocation starts fresh. If you need multi-step workflows that remember state across calls, you will need to store intermediate results in a Notion database property and read them back on the next invocation.

Voice Input: When to Use It and When Not To

Voice input for AI prompts works on macOS and Windows desktop. Hold the shortcut, speak your prompt, and the transcription feeds directly into the AI action you have selected.

It works well for:

• Complex rewrite instructions ("rewrite this section for a technical audience and reduce the pricing paragraphs to bullet points")
• Brainstorming prompts where you are thinking out loud
• Meeting note instructions with specific formatting requirements

It does not work well for:

• Short prompts (typing "summarize" is faster than saying it)
• Code-heavy prompts with specific syntax
• Noisy environments where transcription accuracy drops

Views API: Building Automated Dashboard Setup

The eight new Views API endpoints are the most impactful change for developers in this release. Before April 2026, there was no programmatic way to create or modify database views. Every dashboard setup was manual clicking.

Here is how you create a filtered Kanban view using the new API:

const response = await notion.views.create({
  database_id: "your-database-id",
  type: "board",
  name: "Q2 Pipeline",
  board_by: { property: "Stage" },
  filter: {
    property: "Quarter",
    select: { equals: "Q2 2026" }
  },
  sorts: [
    { property: "Deal Size", direction: "descending" }
  ],
  properties: [
    { property: "Company", visible: true },
    { property: "Deal Size", visible: true },
    { property: "Owner", visible: true },
    { property: "Stage", visible: true },
    { property: "Last Activity", visible: true }
  ]
});

Views API Endpoint Reference

| Endpoint | Method | Purpose | |---|---|---| | /v1/views | GET | List all views for a database | | /v1/views | POST | Create a new view with filters, sorts, and property visibility | | /v1/views/{id} | GET | Retrieve a specific view configuration | | /v1/views/{id} | PATCH | Update view settings (rename, change filters, reorder) | | /v1/views/{id} | DELETE | Remove a view | | /v1/views/{id}/filters | GET | Read filter configuration separately | | /v1/views/{id}/sorts | GET | Read sort configuration separately | | /v1/views/{id}/properties | PATCH | Update which properties are visible and their order |

Practical use case: if your team provisions new project databases from a template, you can now script the view creation. Instead of manually creating "My Tasks," "This Week," and "Kanban" views for every new database, a single script handles it.

Smart Filters: Dynamic Queries That Stay Current

Smart filters solve a real pain point in the Notion API. Before this update, filtering a database by "tasks assigned to the current user" required hardcoding a user ID. Filtering by "due this week" required calculating dates in your code and updating the filter every week.

Now you can write:

const myTasksThisWeek = await notion.databases.query({
  database_id: "tasks-db-id",
  filter: {
    and: [
      {
        property: "Assignee",
        people: { equals: "me" }
      },
      {
        property: "Due Date",
        date: { this_week: {} }
      }
    ]
  }
});

The "me" keyword resolves to whoever authenticated the API call. The this_week filter adjusts automatically. No date math in your application code.

| Filter Type | Old Approach | New Approach | |---|---|---| | Current user's tasks | Hardcode user ID, update when people change | people: { equals: "me" } | | Due today | Calculate today's date in code, update daily | date: { today: {} } | | Due this week | Calculate week boundaries, update weekly | date: { this_week: {} } | | Due next week | Calculate next week's dates | date: { next_week: {} } | | Past due | Compare against current date | date: { past: {} } |

Custom Meeting Note Instructions: Setting Up Workspace Defaults

Workspace admins can now define a template that controls how AI-generated meeting summaries look across the entire workspace. This eliminates the inconsistency where different team members get different summary formats.

To configure:

1. Open workspace settings
2. Navigate to AI preferences
3. Select "Meeting Notes Template"
4. Define sections (Action Items, Decisions Made, Open Questions, Discussion Summary)
5. Set tone (technical, casual, executive brief)
6. Add team context (project abbreviations, department terminology)

Once saved, every AI-generated meeting summary follows this structure. Individual users cannot override it unless the admin enables per-user customization.

API Additions: H4 Blocks, Tab Blocks, and Wiki Verification

Three smaller API additions round out the April release:

Heading 4 support adds a fourth level of heading granularity. This matters for content migration tools and documentation generators that need to preserve deep heading hierarchies from source documents.

Tab block API support means developers can now read and write tab layouts programmatically. If you build Notion templates with tabbed content (common in product specs and meeting dashboards), these can be fully automated.

Writable wiki verification lets scripts mark wiki pages as verified or unverified via the API. Use this for automated QA pipelines: a script checks page content against your style guide, then sets the verification badge accordingly.

await notion.pages.update({
  page_id: "wiki-page-id",
  properties: {
    verification: {
      state: "verified",
      verified_by: { id: "bot-user-id" },
      date: { start: new Date().toISOString() }
    }
  }
});

Common Pitfalls with the April 2026 Updates

• Worker timeouts on large databases: if your Worker queries a database with thousands of pages, the 30-second timeout fires before pagination completes. Pre-filter aggressively or paginate in smaller batches with cursor-based iteration.
• Voice input in noisy environments: transcription accuracy drops significantly with background noise. Use a directional microphone or headset if you rely on voice for complex prompts.
• Views API rate limits: creating many views in rapid succession hits the standard Notion API rate limit of 3 requests per second. Add delays between batch view creation calls.
• Smart filter "me" with bot tokens: the "me" filter does not work with integration bot tokens since bots are not "people." You need OAuth user tokens for per-user filtering.
• Custom meeting instructions are workspace-wide: there is no way to set different templates for different teams within the same workspace. If your engineering and sales teams need different formats, this is a limitation.

Adoption Checklist

Use this to track which April 2026 features your team has evaluated:

1. Enable Workers for Agents in the developer portal (requires admin access)
2. Test voice input with your typical AI prompts on one desktop
3. Configure custom meeting note instructions if your team takes frequent meeting notes
4. Audit existing API integrations for Views API and smart filter opportunities
5. Update content migration scripts to handle H4 and tab blocks
6. Set up automated wiki verification if you maintain a knowledge base

When You Need More Than Notion

The April 2026 updates make Notion significantly more capable within its own ecosystem. Workers let AI compute real answers. The Views API automates dashboard setup. Smart filters keep queries current.

But real workflows cross application boundaries. Drafting in Notion, checking Slack threads, updating a CRM, sending follow-up emails: these multi-app sequences still require switching between tools manually.

Desktop AI agents solve this by controlling your actual computer. They read screens, click buttons, and move data between applications the same way you would, without per-app API integrations.

Fazm is an open source desktop AI agent that automates workflows across all your applications. Try it on GitHub.