Claude Code + Close CRM: Built-In Calling Meets AI Automation

Claude Code and Close CRM is one of the most practical AI-plus-CRM combinations for sales teams in 2026. Close is built around calling — every lead has a built-in VoIP dialer, call recording, and sequence automation. Claude Code adds the intelligence layer: deciding which leads to call, generating pre-call briefs, enrolling prospects into the right sequence, and running post-call automation based on outcomes.

This guide covers the full integration stack. You will learn how to authenticate Claude Code against the Close REST API, automate sequence enrollment with Claude prompts, generate call prep briefs before every dial, and feed SyncGTM enrichment data into Close so Claude always queries complete lead records.

Close's own research shows that reps who log pre-call research activity close 27% more deals than those who cold-dial without context. Automating that research with Claude removes the manual work while keeping the human on the phone.

Why Close CRM for Claude Code?

Close CRM is purpose-built for outbound sales teams. It ships with built-in VoIP calling, email, SMS, and sequence automation — no third-party dialer needed. That tight integration of communication and data makes it an ideal target for Claude Code automation.

Where most CRMs store call data as free-text notes, Close structures it: call duration, outcome, recording URL, and follow-up task — all queryable via the API. Claude Code can read that structure and act on it: routing leads based on call outcomes, re-enrolling no-shows, or flagging stale opportunities for manager review.

The Close + Claude integration launched in 2025 as an official MCP server built jointly by Close and Anthropic. It gives Claude named tools for every core CRM operation — no raw HTTP required.

For context on where Close CRM fits in the broader sales stack, see the Close CRM 2026 review covering pricing and built-in calling features in detail.

Close API: Authentication and Setup

The Close REST API uses HTTP Basic Auth with an API key. The key acts as the username; the password field is left blank. This is the fastest path to getting Claude Code talking to Close — no OAuth dance required for personal integrations.

Step 1: Generate a Close API key

1. Log in to Close CRM
2. Go to Settings → Developer → API Keys
3. Click + Generate API Key
4. Name it (e.g., claude-code-integration) and copy the key

Store the key as an environment variable. Never paste it into Claude directly or hardcode it in a script.

# Add to your shell profile (.bashrc, .zshrc) or .env file
export CLOSE_API_KEY="api_xxxxxxxxxxxxxxxxxxxx"

# Verify
echo $CLOSE_API_KEY

Step 2: Create a Close API helper script

Give Claude a thin wrapper that handles authentication. This prevents Claude from reconstructing the auth pattern each session and keeps credentials out of the prompt.

#!/usr/bin/env python3
# close_helper.py — place in your project root

import os
import requests
import json

API_KEY = os.environ.get("CLOSE_API_KEY")
BASE_URL = "https://api.close.com/api/v1"

def close_get(endpoint, params=None):
    """GET request to Close API."""
    resp = requests.get(
        f"{BASE_URL}{endpoint}",
        auth=(API_KEY, ""),
        params=params or {},
    )
    resp.raise_for_status()
    return resp.json()

def close_post(endpoint, data):
    """POST request to Close API."""
    resp = requests.post(
        f"{BASE_URL}{endpoint}",
        auth=(API_KEY, ""),
        json=data,
    )
    resp.raise_for_status()
    return resp.json()

def close_put(endpoint, data):
    """PUT request to Close API."""
    resp = requests.put(
        f"{BASE_URL}{endpoint}",
        auth=(API_KEY, ""),
        json=data,
    )
    resp.raise_for_status()
    return resp.json()

if __name__ == "__main__":
    # Quick test: fetch organization info
    org = close_get("/me/")
    print(json.dumps({"organization": org.get("organization_id"), "user": org.get("email")}, indent=2))

Step 3: Option B — Connect via Close MCP Server

For Claude.ai or Claude Code with MCP support, use the Close official connector. In Claude.ai, go to Settings → Connectors → search for Close and complete the OAuth flow. For Claude Code CLI, follow the Close MCP server setup guide. The MCP approach gives Claude named tools rather than raw HTTP — faster for common operations, more reliable for complex queries.

Automate Sequences With Claude Code

Close Sequences are multi-step automated workflows — email, call task, and SMS steps triggered on a schedule. The Close API exposes full sequence management: list sequences, subscribe leads, unsubscribe, and query subscription status.

Claude Code adds the decision layer. Instead of manually picking which leads go into which sequence, you describe the criteria in a prompt and Claude runs the enrollment.

Bulk sequence enrollment by ICP filter

Claude will query the leads endpoint with your filters, display the list for review, then POST to /sequence_subscription/ for each lead. The confirmation step prevents accidental enrollment at scale.

Sequence enrollment script template

# Claude will write and run something like this:

def enroll_leads_in_sequence(lead_ids: list, sequence_id: str, sender_user_id: str):
    """Subscribe a list of leads to a Close sequence."""
    results = []
    for lead_id in lead_ids:
        payload = {
            "lead_id": lead_id,
            "sequence_id": sequence_id,
            "sender": {
                "user_id": sender_user_id,
            },
        }
        result = close_post("/sequence_subscription/", payload)
        results.append({
            "lead_id": lead_id,
            "subscription_id": result.get("id"),
            "status": result.get("status"),
        })
    return results

Pause or unsubscribe based on activity

This keeps sequences clean. Leads who engage get moved to active status automatically — no manual scan of the sequence report required. For more on how Close sequences compare to other CRM automation, see top CRM automation tools in 2026.

Call Prep Automation: Brief Every Rep Before They Dial

Close's built-in calling is the feature that distinguishes it from most CRMs. Reps dial from inside the app — no tab-switching. Claude Code leverages this by automating the prep work that happens before the call.

The typical pre-call brief takes a rep 5–8 minutes to pull manually. Claude generates the same brief in under 30 seconds — and can do it for an entire call list at once.

Generate a pre-call brief for a single lead

Generate briefs for today's call queue

The output is a Slack-pasteable or email-forwardable brief for each rep. Zero manual research time. Close's activity API returns calls, emails, notes, and tasks with timestamps — Claude reads those and synthesizes the context automatically.

Lead Enrichment: SyncGTM Data Feeds Into Close

Claude Code is only as useful as the data it reads. If your Close leads are missing phone numbers, company headcount, or industry — Claude's briefs and routing logic will reflect those gaps.

SyncGTM solves this with waterfall enrichment. It pulls verified contact and company data from 50+ providers — Apollo, RocketReach, Datagma, FullEnrich, and more — and writes the results back to Close custom fields. The enrichment runs automatically on new leads and on a schedule for existing ones.

How the enrichment → Close → Claude pipeline works

1. New lead enters Close (manual entry, web form, or API import)
2. SyncGTM trigger fires — enriches the lead with verified data from waterfall providers and writes results to Close custom fields
3. Claude Code runs daily or on-demand — queries enriched leads, filters by ICP score or buying signals, enrolls in sequences, and generates call briefs
4. Rep dials from Close — with a complete brief already prepared

The specific custom fields SyncGTM creates in Close follow a consistent naming convention (e.g., sync_icp_score, sync_mobile_phone, sync_funding_stage). Claude uses these field names in queries without guessing.

For a full breakdown of enrichment options for Close CRM, see the 8 Close CRM enrichment tools our SDRs swear by. For the broader Claude Code CRM integration context, see the Claude Code CRM integration guide.

Bulk Lead Operations With Claude Code

The Close API supports bulk actions — update, email, delete, and sequence-subscribe across multiple leads in a single operation. Claude Code makes these accessible via plain-English prompts instead of manual filters in the UI.

Bulk field update by filter

Lead import with enrichment

Pipeline health report

These prompts replace what would otherwise require manual Smart View setup, CSV export, and spreadsheet work. Claude runs the query, formats the output, and returns results in the same session.

For RevOps teams using Claude Code across multiple CRMs and tools, see Claude Code RevOps workflows for the full automation stack.

Close MCP vs Direct REST API: Which to Use

Close supports both integration paths in 2026. The right choice depends on your team's technical depth and workflow.

Recommendation: Start with the Close MCP server if your team uses Claude.ai and needs immediate access without scripting. Move to the direct REST API if you are building scheduled automations (cron jobs, webhook-triggered workflows) that run without a human in the loop.

For context on how this fits the broader MCP ecosystem for GTM teams, see top GTM MCPs for Claude Code in 2026.

Security Best Practices

Connecting Claude Code to a live CRM requires explicit decisions about access scope and credential management. These are non-negotiable for production integrations.

Create a dedicated integration API key

Generate a separate Close API key named specifically for the Claude integration. If the key is ever exposed, you can revoke it without affecting other integrations or team member access. Label it clearly in Close Settings → Developer → API Keys.

Store credentials in environment variables

# DO NOT paste your API key into Claude or hardcode it in a script
API_KEY = "api_xxxxxxxxxxxxxxxxxxxx"  # ← exposed in code and chat history

# Set once in your shell profile
export CLOSE_API_KEY="api_xxxxxxxxxxxxxxxxxxxx"

# Script reads from environment — never from hardcoded value
API_KEY = os.environ.get("CLOSE_API_KEY")

Confirm before bulk writes

For any prompt that will update or enroll more than 10 leads, ask Claude to list the affected records first. Verify the count and sample matches your intent before confirming the write operation. Close does not have a native undo for bulk field updates.

Test on a small subset first

For new automation workflows — especially sequence enrollment — run on 5–10 leads before scaling. Verify the enrolled leads appear correctly in the Close sequence report before processing the full list.

For comprehensive security guidance on AI-powered CRM automation, the Claude Code CRM integration guide covers the full credential management and permission scoping framework.