Fathom to Pipedrive: Create Follow-Up Tasks from Calls

We built and shipped an integration that reads Fathom call summaries and creates assigned Pipedrive Activities with the right subject, type, due date, and owner. Sales follow-up stayed consistent and nothing lived in a rep's notebook. This guide shows the exact pattern, the API calls, and the gotchas we hit in production.

Fathom to Pipedrive task automation is: a service that consumes post-call summaries, decides the next step, and writes a Pipedrive Activity linked to the right owner and timing so follow-up actually happens.

The problem it solves

Sales calls ended with good intentions and scattered next steps. Reps copied action items from Fathom into Pipedrive or forgot them. Managers had no audit trail of who owned what or when it was due.

Harvard Business Review reported that firms responding within one hour were seven times more likely to qualify a lead than those taking longer than an hour (source: hbr.org, The Short Life of Online Sales Leads). Speed and consistency matter.

How the automation works

The service watches for new post-call summaries, normalizes them, applies routing rules, and then calls Pipedrive's Activities API to create a follow-up task with an owner, type, subject, due date, and time.

• Summary ingestion: we accept Fathom's post-call exports or the post-call email and normalize fields like participants, topics, and action items.
• Routing rules: we map participants and domains to a Pipedrive user for assignment. Fall back to an account-level default when needed.
• Activity creation: we call Pipedrive's Activities endpoint with subject, type, due_date, due_time, and user assignment. Activities are the "tasks" object in Pipedrive.
• Idempotency: we hash meeting UID plus the action to avoid duplicate Activities on retries.
• Optional enrichment: we append a short note from the summary to the Activity's note field for context.

Step-by-step: how to build it

1) Normalize Fathom post-call summaries

Capture the essentials: meeting id, attendees, summary bullets, and explicit action items. We store a normalized JSON and derive a simple follow-up subject and due policy.

// example normalized record we persist
const call = {
  meeting_uid: "fathom-2026-08-05-1430-abc123",
  title: "Q3 pricing review with Acme",
  attendees: [{ name: "Dana", email: "dana@acme.com" }],
  action_items: ["Send revised proposal", "Schedule pricing workshop"]
};

Key gotcha: do not rely on free text alone. Extract action verbs into discrete items so each becomes a concrete Activity.

2) Decide the owner and the due window

We route by email domain or last-touch owner. If neither resolves, fall back to a default user id.

function resolveOwnerId(domain, lastTouchOwnerId, fallbacks) {
  if (lastTouchOwnerId) return lastTouchOwnerId;
  if (fallbacks.domainOwner[domain]) return fallbacks.domainOwner[domain];
  return fallbacks.defaultOwnerId;
}
 
function dueFor(action) {
  // example: proposals due today 4:30pm, other tasks tomorrow 9:00am
  const now = new Date();
  const d = new Date(now);
  if (/proposal/i.test(action)) {
    d.setHours(16, 30, 0, 0);
  } else {
    d.setDate(d.getDate() + 1);
    d.setHours(9, 0, 0, 0);
  }
  return { due_date: d.toISOString().slice(0,10), due_time: d.toTimeString().slice(0,5) };
}

Gotcha: Pipedrive separates due_date and due_time. Compute both explicitly in your timezone handling.

3) Create the Pipedrive Activity

Authenticate with an API token or OAuth 2.0. Activities are the task object you create and assign. We use the x-api-token header and set a valid type and both due fields.

curl -X POST "https://YOURCOMPANY.pipedrive.com/api/v2/activities" \
  -H "Content-Type: application/json" \
  -H "x-api-token: $PIPEDRIVE_API_TOKEN" \
  -d '{
    "subject": "Send revised proposal: Acme",
    "type": "call",
    "user_id": 123456,
    "due_date": "2026-08-05",
    "due_time": "16:30"
  }'

Gotcha: activity type must exist. Use a known type like call or meeting, or ensure your custom type is present before use.

4) Add context to the Activity note

Append the key bullet points so the assignee knows what to do without opening another system. Keep it short.

async function addContext(activityId, context) {
  const body = { note: `From Fathom: ${context}` };
  await fetch(`https://YOURCOMPANY.pipedrive.com/api/v2/activities/${activityId}`, {
    method: "PUT",
    headers: {
      "Content-Type": "application/json",
      "x-api-token": process.env.PIPEDRIVE_API_TOKEN
    },
    body: JSON.stringify(body)
  });
}

Gotcha: keep notes concise. Long dumps lower readability and do not help execution.

5) Prevent duplicates with a stable key

Compute a deterministic key per Activity and skip if already written.

import crypto from "node:crypto";
 
function activityKey(callUid, action) {
  return crypto.createHash("sha256").update(`${callUid}::${action}`).digest("hex");
}
 
async function alreadyCreated(db, key) {
  return await db.has(key);
}

Gotcha: idempotency saves you from retry storms and accidental duplicates when inputs reprocess.

6) Optional: build with Make.com or Zapier

You can prototype this with Make or Zapier using their official Pipedrive apps. Use a router step to set due_date and due_time and a Create Activity action with a valid type. We still recommend a small code step for idempotency and routing logic.

Zapier and Make both provide official Pipedrive modules. If your team prefers a no-code starting point, this path gets a working version live quickly while we harden a service behind it.

7) Reassign on owner changes

If you later subscribe to Pipedrive webhooks to mirror owner changes, follow Pipedrive's webhook guide. Non 2xx responses or slow handlers can trigger bans, and redirecting subscription URLs is not allowed.

Gotcha: keep webhook handlers fast and always return 2xx within the timeout window.

Where it gets complicated

• Due fields are separate: due_date and due_time are distinct. If you omit one, Activities can land at midnight or without a time. Compute both in the right timezone.
• Activity type hygiene: creation can fail if you pass a type that does not exist. Standardize on a small set like call, meeting, task and document any custom types.
• User mapping: you need reliable user_id assignment. We cache a domain to owner map and refresh daily; manual overrides handle exceptions.
• Event idempotency: Fathom exports or emails can resend on edits. Hash meeting id plus action text to prevent duplicates.
• Webhook discipline: if you add Pipedrive webhooks later, respect the ban rules. Non 2xx or handlers slower than the documented window increment a ban counter.

What this actually changes

In production, the system turned every clear action item into an assigned, timed Activity. Managers stopped chasing follow-up in chat threads and started working from Pipedrive lists. Reps no longer copied items from summaries.

HBR found that contacting prospects within one hour yields a seven times higher chance of qualifying the lead versus slower responses (source: hbr.org). Salesforce's State of Sales reports reps spend roughly 28 percent of their time actually selling, implying automation that removes admin work can return meaningful selling time (source: salesforce.com, State of Sales).

Frequently asked questions

Does Pipedrive have an API for tasks?

Yes. Pipedrive exposes a public API and Activities are the task object you create and assign. You can authenticate with OAuth 2.0 or with an API token passed in the x-api-token header. We use Activities to hold subject, type, due_date, due_time, and owner.

How do you prevent duplicate Activities from the same call?

We compute a stable key from the meeting id and the action text, store it, and skip creation when we see the same key again. That makes retries safe and avoids duplicates when summaries are re-sent or edited.

Can this link the task to a deal or contact?

Yes in practice, though we design around a mapping you already trust. We resolve the right record via routing rules and maintain a cache so we do not guess at link targets. Clean linkage and ownership are more important than stuffing every field.

Will this run in real time?

Near real time. We ingest summaries promptly and create Activities with computed due times. If you later add Pipedrive webhooks for ownership mirrors, keep handlers fast and return 2xx responses to meet Pipedrive's webhook rules.

Do I need a developer, or can I build this in Zapier or Make?

You can prototype in Zapier or Make using their official Pipedrive apps. For production we ship a small service for idempotency, routing, and consistent due-date logic, then keep the no-code path as an override when you want edits without a deploy.

What does this cost to run monthly?

API usage for this pattern is light and the infrastructure footprint is small. The main cost is the initial build. Ongoing costs are minimal compared to the time saved and the lift in follow-up consistency.

If you want this running against your Pipedrive in under a week, we have shipped this integration before. See our CRM automation services at /services#crm-automation, and for adjacent patterns read our HubSpot version in /blog/fathom-to-hubspot-create-tasks-from-calls. When you are ready, book a working session at /book.