Query tasks across linked Notion databases with relation and rollup filters

Why relation.contains requires a UUID, not a project name

{
  "filter": {
    "property": "Project",
    "relation": { "contains": "dd456007-6c66-4bba-957e-ea501dcda3a6" }
  }
}

Prerequisites

The two-step query pattern

const p0Response = await notion.dataSources.query({
  data_source_id: process.env.NOTION_PROJECTS_DATABASE_ID,
  filter: {
    property: "Priority",
    select: { equals: "P0" },
  },
  page_size: 100,
});
const p0Uuids = p0Response.results.map((page) => page.id);
// e.g. ["dd456007-...", "0c1f7cb2-...", "a3b2c1d0-..."]

const filter = {
  and: [
    // Match any task linked to one of the P0 projects
    p0Uuids.length === 1
      ? { property: "Project", relation: { contains: p0Uuids[0] } }
      : { or: p0Uuids.map((uuid) => ({ property: "Project", relation: { contains: uuid } })) },
    // AND (blocked OR past due)
    {
      or: [
        { property: "Status", status: { equals: ["Blocked", "On Hold"] } },
        { property: "Due", date: { before: "today" } },
      ],
    },
  ],
};

Adding a rollup layer

{
  "filter": {
    "property": "Task statuses",
    "rollup": {
      "any": {
        "status": { "equals": "Blocked" }
      }
    }
  }
}

{
  "filter": {
    "property": "Task statuses",
    "rollup": {
      "every": {
        "status": { "equals": "Done" }
      }
    }
  }
}

{
  "filter": {
    "property": "Task completion rate",
    "rollup": {
      "number": { "less_than": 50 }
    }
  }
}

Complete Worker: P0 blocker scanner

import { Worker } from "@notionhq/workers";
import { j } from "@notionhq/workers/schema-builder";

const worker = new Worker();
export default worker;

const BLOCKED_STATUSES = ["Blocked", "On Hold"] as const;

worker.tool("p0BlockerScan", {
  title: "Scan P0 Blockers",
  description:
    "Find all tasks linked to P0-priority projects that are blocked or past due. " +
    "Requires NOTION_TASKS_DATABASE_ID and NOTION_PROJECTS_DATABASE_ID env vars.",
  schema: j.object({
    maxResults: j.number().nullable().describe("Limit results. Default: 250."),
  }),
  execute: async (input, context) => {
    const tasksDbId   = process.env.NOTION_TASKS_DATABASE_ID!;
    const projectsDbId = process.env.NOTION_PROJECTS_DATABASE_ID!;

// Step 1: resolve P0 project UUIDs
    const p0Projects: { id: string; name: string }[] = [];
    let hasMore = true, cursor: string | undefined;
    while (hasMore) {
      const res = await context.notion.dataSources.query({
        data_source_id: projectsDbId,
        filter: { property: "Priority", select: { equals: "P0" } },
        start_cursor: cursor,
        page_size: 100,
      });
      for (const page of res.results) {
        p0Projects.push({
          id: page.id,
          name: page.properties?.Name?.title?.[0]?.plain_text ?? "Unnamed",
        });
      }
      hasMore = res.has_more;
      cursor = res.next_cursor ?? undefined;
      if (hasMore) await new Promise((r) => setTimeout(r, 350));
    }

if (p0Projects.length === 0) {
      return { summary: "No P0 projects found.", tasks: [], total: 0 };
    }

// Step 2: build compound filter and query tasks
    const uuids = p0Projects.map((p) => p.id);
    const filter = {
      and: [
        uuids.length === 1
          ? { property: "Project", relation: { contains: uuids[0] } }
          : { or: uuids.map((id) => ({ property: "Project", relation: { contains: id } })) },
        {
          or: [
            { property: "Status", status: { equals: BLOCKED_STATUSES } },
            { property: "Due", date: { before: "today" } },
          ],
        },
      ],
    };

const maxResults = Math.min(input.maxResults ?? 250, 500);
    const tasks: { title: string; status: string; dueDate: string | null; url: string }[] = [];
    let taskHasMore = true, taskCursor: string | undefined;

while (taskHasMore && tasks.length < maxResults) {
      const res = await context.notion.dataSources.query({
        data_source_id: tasksDbId,
        filter,
        sorts: [{ property: "Due", direction: "ascending" }],
        start_cursor: taskCursor,
        page_size: 100,
      });
      for (const page of res.results) {
        const props = page.properties ?? {};
        tasks.push({
          title: props.Name?.title?.[0]?.plain_text ?? "Unnamed Task",
          status: props.Status?.status?.name ?? "Unknown",
          dueDate: props.Due?.date?.start ?? null,
          url: page.url,
        });
      }
      taskHasMore = res.has_more;
      taskCursor = res.next_cursor ?? undefined;
      if (taskHasMore) await new Promise((r) => setTimeout(r, 350));
    }

return {
      summary: `Found ${tasks.length} blocked/past-due tasks across ${p0Projects.length} P0 projects.`,
      tasks,
      total: tasks.length,
    };
  },
});

ntn workers env set NOTION_TASKS_DATABASE_ID=<32-char-uuid>
ntn workers env set NOTION_PROJECTS_DATABASE_ID=<32-char-uuid>
ntn workers deploy

# Smoke test locally before connecting to an Agent
ntn workers exec p0BlockerScan --local -d '{}'

Gotchas