Build a HubSpot CRM MCP Server That Powers Autonomous Sales AI Agents in 2026

The Sales Productivity Gap

McKinsey reports that sales reps spend only 35% of their time actually selling. The rest is consumed by CRM data entry (20%), lead research (15%), email drafting (10%), and meeting prep (10%). This MCP server automates the non-selling activities, giving reps back 65% of their time.

Server Implementation (src/hubspot-mcp.ts)

// src/hubspot-mcp.ts
import { FastMCP } from 'fastmcp';
import { z } from 'zod';
import httpx from 'undici';

const server = new FastMCP({ name: 'hubspot-crm', version: '1.0.0' });
const HUBSPOT_TOKEN = process.env.HUBSPOT_ACCESS_TOKEN;
const BASE_URL = 'https://api.hubapi.com/crm/v3';

async function hubspotGet(endpoint: string, params?: Record<string, string>) {
  const url = new URL(`${BASE_URL}${endpoint}`);
  if (params) Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
  const resp = await httpx.fetch(url.toString(), {
    headers: { Authorization: `Bearer ${HUBSPOT_TOKEN}`, 'Content-Type': 'application/json' },
  });
  return resp.json();
}

// Tool 1: Pipeline Analysis
server.tool(
  'analyze_pipeline',
  'Get pipeline metrics and deal distribution',
  {
    pipeline_id: z.string().optional().describe('Specific pipeline ID'),
  },
  async ({ pipeline_id }) => {
    const stages = await hubspotGet(`/pipelines/${pipeline_id || 'default'}/stages`);
    const deals = await hubspotGet('/objects/deals', {
      limit: '100',
      properties: 'dealname,amount,dealstage,closedate,hs_priority',
    });

    const pipeline = (deals.results || []).reduce((acc: any, deal: any) => {
      const stage = deal.properties.dealstage;
      if (!acc[stage]) acc[stage] = { count: 0, total_amount: 0 };
      acc[stage].count++;
      acc[stage].total_amount += parseFloat(deal.properties.amount || '0');
      return acc;
    }, {});

    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          pipeline: pipeline_id || 'default',
          stages: Object.entries(pipeline).map(([stage, data]: any) => ({
            stage,
            deals: data.count,
            total_amount: data.total_amount,
          })),
          total_deals: deals.results?.length || 0,
          total_value: Object.values(pipeline).reduce((sum: number, s: any) => sum + s.total_amount, 0),
        }, null, 2),
      }],
    };
  }
);

// Tool 2: Lead Scoring
server.tool(
  'score_leads',
  'Score and rank leads based on engagement and fit',
  {
    limit: z.number().optional().default(20),
    min_score: z.number().optional().default(0),
  },
  async ({ limit, min_score }) => {
    const contacts = await hubspotGet('/objects/contacts', {
      limit: String(limit),
      properties: 'email,firstname,lastname,company,lifecyclestage,hs_lead_status,createdate,lastmodifieddate',
    });

    const scored = (contacts.results || []).map((c: any) => {
      const recency = daysSince(c.properties.lastmodifieddate);
      const score = Math.max(0, 100 - recency * 2);
      return {
        contact_id: c.id,
        name: `${c.properties.firstname} ${c.properties.lastname}`,
        company: c.properties.company,
        lifecycle: c.properties.lifecyclestage,
        engagement_score: score,
      };
    }).filter((s: any) => s.engagement_score >= min_score)
      .sort((a: any, b: any) => b.engagement_score - a.engagement_score);

    return {
      content: [{ type: 'text', text: JSON.stringify({ leads: scored, count: scored.length }, null, 2) }],
    };
  }
);

// Tool 3: Draft Outreach Email
server.tool(
  'draft_outreach',
  'Generate a personalized outreach email for a contact',
  {
    contact_id: z.string(),
    tone: z.enum(['professional', 'friendly', 'casual']).default('professional'),
    purpose: z.string().describe('Purpose of outreach'),
  },
  async ({ contact_id, tone, purpose }) => {
    const contact = await hubspotGet(`/objects/contacts/${contact_id}`, {
      properties: 'firstname,lastname,company,jobtitle,lifecyclestage',
    });
    const props = contact.properties;

    const email = `Subject: ${purpose} - ${props.company}\
\
Hi ${props.firstname},\
\
I noticed you're ${props.jobtitle} at ${props.company}. ${purpose}\
\
Best regards`;

    return {
      content: [{ type: 'text', text: email }],
    };
  }
);

function daysSince(dateStr: string): number {
  if (!dateStr) return 365;
  return Math.floor((Date.now() - new Date(dateStr).getTime()) / 86400000);
}

server.start({ transport: 'stdio' });

Performance Benchmarks

Production Reality Check

Rate-limit handling: HubSpot API allows 100 requests/10 seconds. Implement sliding window rate limiting. Cache contact data for 5 minutes. OAuth scoping: Request only crm.objects.contacts.read, crm.objects.deals.read, crm.objects.deals.write, and content. Data freshness: HubSpot webhooks can push real-time deal updates to keep MCP server data current.

By <a href="https://x.com/deeepakbagada" rel="nofollow noopener noreferrer">Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last tested: August 2026 with FastMCP 3.14, HubSpot CRM API v3, Node v22, and TypeScript 5.6.