Meeting notes to action items to calendar automation

Every meeting generates decisions, action items, and scheduling conflicts. Yet most teams still do this manually: someone transcribes notes, someone else extracts action items, and another person blocks off calendar time. By the time the third person finishes, the context is already stale and someone has forgotten they own a task.

This workflow solves that problem completely. You record a meeting with MeetGeek, it transcribes and identifies action items automatically, those items land in your productivity app as tasks with reminders, and your calendar automatically blocks time for the highest-priority items. No copy-pasting. No Slack messages asking "who's doing what?" Three tools, one simple connection, and your team stays aligned.

This is a beginner-friendly automation that works with any orchestration platform. We'll walk through the exact API calls, show you where data moves between tools, and explain how to set this up in Zapier, n8n, Make, or Claude Code depending on your preference.

The Automated Workflow

How it works conceptually

MeetGeek records and transcribes your meeting, then extracts action items. Those action items flow into your productivity app as nested tasks with due dates and reminders. Finally, Reclaim AI looks at those tasks and automatically reserves calendar blocks for the most urgent ones, protecting that time against meeting invitations.

The entire chain runs without anyone touching a keyboard after the meeting ends.

Which orchestration tool to choose

For this particular workflow, we recommend starting with Zapier or Make if you want a visual interface with minimal coding. If you want more control over data transformation or have existing n8n infrastructure, n8n works equally well. Claude Code is useful if you need to write custom logic for extracting specific action item details or filtering tasks by priority.

We'll show examples using Make and n8n; the logic translates directly to Zapier.

Step 1: Trigger on MeetGeek meeting completion

MeetGeek sends a webhook when a meeting finishes transcription and analysis. You configure a webhook URL in your orchestration tool, and MeetGeek POSTs to it with the following payload structure:

Copy{
  "meeting_id": "mg_12345abc",
  "title": "Q4 Planning Session",
  "date": "2024-01-15T10:00:00Z",
  "duration_minutes": 45,
  "transcript": "Full meeting transcript text...",
  "action_items": [
    {
      "text": "Finalise budget allocation for marketing",
      "owner": "Sarah Chen",
      "priority": "high",
      "due_date": "2024-01-22"
    },
    {
      "text": "Review competitor analysis report",
      "owner": "James Park",
      "priority": "medium",
      "due_date": "2024-01-25"
    }
  ],
  "attendees": [
    {
      "name": "Sarah Chen",
      "email": "sarah@company.com"
    },
    {
      "name": "James Park",
      "email": "james@company.com"
    }
  ]
}

In Make, create a new scenario and select "Webhooks" as your trigger module. Copy the webhook URL that Make generates, then paste it into MeetGeek's integration settings under "Outgoing Webhooks."

In n8n, use the "Webhook" trigger node and set the method to POST. The URL will look like https://your-n8n-instance.com/webhook/meetgeek-webhook. Add this to MeetGeek's settings.

Step 2: Create tasks in your productivity app

MeetGeek sends an array of action items. You need to create one task per action item in your productivity app. Most productivity tools with AI (like Notion, Todoist via API, or custom apps with nested chat features) expose a task creation endpoint.

For this example, we'll assume an API endpoint like:

Copy
POST /api/v1/tasks

With this request body:

Copy{
  "title": "Finalise budget allocation for marketing",
  "description": "From Q4 Planning Session on 2024-01-15. Owner: Sarah Chen",
  "due_date": "2024-01-22",
  "priority": "high",
  "assignee_email": "sarah@company.com",
  "tags": ["meeting-action-item", "Q4-planning"],
  "reminders": [
    {
      "type": "email",
      "time_before": "1_day"
    },
    {
      "type": "in_app",
      "time_before": "2_hours"
    }
  ]
}

In Make, add an "HTTP" module after your webhook trigger. Set it to POST, paste your task creation endpoint URL, and add authentication headers (usually Authorization: Bearer YOUR_API_KEY). Map the fields from the MeetGeek payload:

• title field receives action_items[].text
• assignee_email receives the corresponding attendee email
• due_date receives action_items[].due_date
• priority receives action_items[].priority

In n8n, use the "HTTP Request" node with similar configuration. The key difference is how you handle the array: use a "Loop" node to iterate over each action item and create a separate HTTP request for each one.

Step 3: Extract assignee information and enrich task data

MeetGeek tells you who owns each action item by name, but your productivity app probably needs an email address. You need to match names to emails from the attendees array.

In Make, use a "Set multiple variables" module after your trigger to create a lookup object:

Copy{
  "Sarah Chen": "sarah@company.com",
  "James Park": "james@company.com"
}

Then when creating tasks, use the get() function to look up the email:

Copy
{{get(attendeeMap; action_item.owner)}}

In n8n, use the "Set" node to construct the same mapping, then use a "Function" node with this logic:

Copyconst attendees = $input.first().json.attendees;
const actionItems = $input.first().json.action_items;

const attendeeMap = {};
attendees.forEach(a => {
  attendeeMap[a.name] = a.email;
});

return actionItems.map(item => ({
  ...item,
  assignee_email: attendeeMap[item.owner]
}));

Step 4: Connect to Reclaim AI for calendar blocking

Reclaim AI integrates with most calendar systems (Google Calendar, Outlook) and accepts tasks via API or its integration layer. Once a task exists in your productivity app, you send it to Reclaim AI so it can automatically block calendar time.

Reclaim AI's task creation endpoint:

Copy
POST https://api.reclaim.ai/api/v2/tasks

Request body:

Copy{
  "title": "Finalise budget allocation for marketing",
  "description": "Action item from Q4 Planning Session",
  "duration_minutes": 90,
  "priority": "high",
  "due_date": "2024-01-22",
  "assignee": "sarah@company.com",
  "calendar_event": true
}

The calendar_event: true flag tells Reclaim AI to automatically block this time on Sarah's calendar, and Reclaim will intelligently find the best slot before the due date.

In Make, add another "HTTP" module after your first task creation module. Set it to POST to Reclaim AI's endpoint. Use Authorization: Bearer YOUR_RECLAIM_API_KEY. Map the same task fields.

In n8n, add another "HTTP Request" node in parallel or in sequence, depending on whether you want to wait for the productivity app response before creating the Reclaim task (you probably do, so the task ID from the first tool can be referenced).

Complete workflow diagram in code form

Here's how a complete n8n workflow looks in JSON:

Copy{
  "nodes": [
    {
      "parameters": {
        "path": "meetgeek-webhook"
      },
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "jsCode": "const attendees = $input.first().json.attendees;\nconst actionItems = $input.first().json.action_items;\nconst meeting = $input.first().json;\n\nconst attendeeMap = {};\nattendees.forEach(a => {\n  attendeeMap[a.name] = a.email;\n});\n\nreturn actionItems.map(item => ({\n  title: item.text,\n  description: `From ${meeting.title} on ${meeting.date}. Owner: ${item.owner}`,\n  due_date: item.due_date,\n  priority: item.priority,\n  assignee_email: attendeeMap[item.owner],\n  meeting_id: meeting.meeting_id,\n  tags: ['meeting-action-item']\n}));"
      },
      "name": "Transform Action Items",
      "type": "n8n-nodes-base.function",
      "typeVersion": 1,
      "position": [450, 300]
    },
    {
      "parameters": {
        "loopOver": "={{ $json }}"
      },
      "name": "Loop Each Action Item",
      "type": "n8n-nodes-base.loop",
      "typeVersion": 1,
      "position": [650, 300]
    },
    {
      "parameters": {
        "url": "https://api.yourproductivityapp.com/api/v1/tasks",
        "method": "POST",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "httpHeaderAuth",
        "headerParameters": {
          "parameters": [
            {
              "name": "Authorization",
              "value": "Bearer YOUR_PRODUCTIVITY_API_KEY"
            }
          ]
        },
        "body": "{\n  \"title\": \"{{ $json.title }}\",\n  \"description\": \"{{ $json.description }}\",\n  \"due_date\": \"{{ $json.due_date }}\",\n  \"priority\": \"{{ $json.priority }}\",\n  \"assignee_email\": \"{{ $json.assignee_email }}\",\n  \"tags\": {{ JSON.stringify($json.tags) }}\n}"
      },
      "name": "Create Task in Productivity App",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [850, 300]
    },
    {
      "parameters": {
        "url": "https://api.reclaim.ai/api/v2/tasks",
        "method": "POST",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "httpHeaderAuth",
        "headerParameters": {
          "parameters": [
            {
              "name": "Authorization",
              "value": "Bearer YOUR_RECLAIM_API_KEY"
            }
          ]
        },
        "body": "{\n  \"title\": \"{{ $json.title }}\",\n  \"description\": \"{{ $json.description }}\",\n  \"duration_minutes\": 90,\n  \"priority\": \"{{ $json.priority }}\",\n  \"due_date\": \"{{ $json.due_date }}\",\n  \"assignee\": \"{{ $json.assignee_email }}\",\n  \"calendar_event\": true\n}"
      },
      "name": "Block Calendar with Reclaim AI",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [1050, 300]
    }
  ]
}

This workflow runs entirely hands-off. The moment MeetGeek finishes processing, your orchestration platform automatically creates tasks and calendar blocks.

The Manual Alternative

If you prefer more control over which action items actually create tasks, or if you want to review decisions before automation runs, you can insert a human approval step.

In Make, add an "Email" module that sends you a summary of extracted action items before creating tasks. You reply with "approve" or "approve with changes," and a second scenario listens for your response email and then creates tasks based on your feedback.

In n8n, add an "Email" trigger node with a custom inbox monitored by your orchestration tool. Wait for approval, then continue.

This slows the process down, but some teams prefer it if action items are frequently misidentified or if priorities need human judgment. The trade-off is that you've introduced a manual step back into an otherwise automated workflow, so consider whether the benefits outweigh the delay.

Pro Tips

Error handling and failed API calls

If MeetGeek sends a malformed action item (missing due date, no assignee identified), your task creation will fail silently unless you add error handling.

In Make, add an "Error" handler after your HTTP module. If the call fails, route to a Slack notification that alerts you to manually review that meeting.

In n8n, use a "Try/Catch" node or add an "On Error" path that logs the failure to a Slack channel or database for manual review.

Always log the original MeetGeek payload so you can debug why extraction failed.

Rate limiting and API quotas

MeetGeek, your productivity app, and Reclaim AI all have rate limits. If you run this for 50 people and 10 meetings per day, you might hit rate limits quickly.

Stagger requests using a small delay between API calls. In Make, use the "Sleep" module to wait 500ms between task creations. In n8n, add a delay of 1 second between HTTP requests using the "Wait" node.

Monitor your API usage in each tool's dashboard. Most offer alerts when you're approaching quota limits.

Data enrichment with AI

If your productivity app supports nested AI chats, send the full meeting transcript to an AI model to extract more context about each action item. For example, an AI can identify dependencies between tasks or flag tasks that might need budget approval.

In Claude Code or via Claude's API, you can run a prompt like:

Copy
Analyse these action items and their full context from the meeting transcript.
For each item, identify: dependencies on other items, estimated effort, required approvals, and key discussion points.
Return as JSON.

Then include this enriched data in your task creation.

Cost optimisation

Most of these tools charge per API call or per monthly user. If you're creating tasks for 50 action items per week, prioritise which ones actually get calendar blocks.

You can filter by priority: only send "high" priority items to Reclaim AI, and let medium and low priority tasks live in your productivity app without automatic calendar blocking. This reduces Reclaim AI API calls and keeps calendars less cluttered.

Alternatively, batch task creation: instead of creating tasks one at a time, collect several action items and send them in bulk if your APIs support it.

Testing your workflow

Before connecting to real meetings, test with a fake MeetGeek webhook payload. Manually POST a test JSON to your orchestration tool's webhook URL:

Copycurl -X POST https://your-make-webhook-url.com \
  -H "Content-Type: application/json" \
  -d '{"meeting_id":"test_123","title":"Test Meeting","action_items":[{"text":"Test action","owner":"Test User","priority":"high","due_date":"2024-02-01"}],"attendees":[{"name":"Test User","email":"test@example.com"}]}'

Run the test scenario and verify tasks appear in your productivity app and calendar blocks appear in Reclaim AI. Only then connect the live MeetGeek webhook.

Cost Breakdown

The exact cost depends on how many action items you generate monthly. If your team holds 200 meetings per month with an average of 3 action items each (600 tasks created), you'll use roughly 600 operations in Make or n8n, which is well within standard pricing.

For larger organisations creating 2,000+ tasks per month, self-hosting n8n becomes more cost-effective than Make or Zapier.