---
title: "Connect Adobe Marketo Engage to Claude: Manage Leads & Smart Lists"
slug: connect-adobe-marketo-engage-to-claude-manage-leads-smart-lists
date: 2026-10-31
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Adobe Marketo Engage to Claude using Truto's managed MCP server. A step-by-step engineering guide to configuring tools, handling bulk jobs, and automating lead ops."
tldr: "Connect Adobe Marketo Engage to Claude using Truto's managed MCP server. This guide covers UI and API setup, asynchronous bulk jobs, custom tool configurations, and real-world AI workflows."
canonical: https://truto.one/blog/connect-adobe-marketo-engage-to-claude-manage-leads-smart-lists/
---

# Connect Adobe Marketo Engage to Claude: Manage Leads & Smart Lists


If your team needs to connect Adobe Marketo Engage to Claude to automate lead scoring, trigger smart campaigns, or orchestrate bulk data exports, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Marketo's complex REST API architecture. You can either [build and maintain this infrastructure yourself](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses ChatGPT, check out our guide on [/connect-adobe-marketo-engage-to-chatgpt-orchestrate-assets-flows/](https://truto.one/connect-adobe-marketo-engage-to-chatgpt-orchestrate-assets-flows/). If you are building automated pipelines without a chat interface, explore our broader architectural overview on [/connect-adobe-marketo-engage-to-ai-agents-automate-bulk-operations/](https://truto.one/connect-adobe-marketo-engage-to-ai-agents-automate-bulk-operations/).

Giving a Large Language Model (LLM) read and write access to a sprawling marketing automation platform like Marketo Engage is a serious engineering challenge. You have to handle fragmented API versions, map highly nested JSON schemas to MCP tool definitions, and deal with Marketo's strict API quotas. Every time Marketo deprecates a legacy endpoint or you add a custom object to your instance, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Adobe Marketo Engage, connect it natively to Claude Desktop, and execute [complex marketing workflows](https://truto.one/connect-adobe-marketo-engage-to-ai-agents-automate-bulk-operations/) using natural language.

> Want to give your AI agents secure, authenticated access to Adobe Marketo Engage and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Adobe Marketo Engage API

A custom MCP server is a self-hosted integration layer. While the [open MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for models to discover tools, the reality of implementing it against Marketo's APIs is painful. You are not just integrating a simple CRM - you are interacting with lead databases, custom activities, asynchronous bulk extract jobs, and complex filtering syntax.

If you decide to build a custom Marketo Engage MCP server, here are the specific integration challenges you will face:

### Asynchronous Bulk Export and Import Jobs
Marketo limits synchronous lead queries strictly. For any operation involving more than 300 records, you must use their Bulk Extract APIs. These are asynchronous batch jobs. You cannot simply ask Claude to "export all leads from the past month." The AI needs explicit tool definitions to handle the state machine: create the job with a specific filter, enqueue it, poll the status endpoint until the state reads `Completed`, and finally download the CSV stream. An LLM has no intuition for this workflow unless you build highly constrained tools that guide it step by step.

### Custom Objects and Custom Activities
Marketo instances are rarely standard. Marketing teams heavily rely on custom objects (e.g., custom event attendance) and custom activities (e.g., logged a webinar view). Because these are instance-specific, their schemas do not exist in standard documentation. A custom MCP server requires you to query the `Describe` endpoints, dynamically map those custom schemas into JSON Schema format, and inject them into your tool definitions at runtime. Truto handles this automatically, deriving tool schemas dynamically from the integration's documented state.

### Strict Rate Limits and Concurrency Quotas
Marketo enforces aggressive rate limits - typically 100 calls per 20 seconds and a maximum of 10 concurrent API requests. Exceeding these triggers `606 Max rate limit exceeded` or `615 Concurrent access limit reached` errors.

**Note on Truto's rate limit handling:** Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Marketo API returns an HTTP 429 (or Marketo's specific 6xx rate limit codes mapped to 429), Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized HTTP headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) following the IETF specification. The caller (the AI agent or MCP client) is entirely responsible for reading these headers and implementing its own retry and backoff logic.

## Step 1: Create the Adobe Marketo Engage MCP Server

Truto dynamically generates MCP tools based on the resources available to your authenticated Marketo instance. The server URL contains a cryptographic token that securely maps to your specific integrated account, requiring no complex auth handling on the client side.

You can generate this server either via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

This is the fastest method if you are manually configuring a Claude Desktop environment.

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Adobe Marketo Engage account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., provide a name, set an expiration date, or restrict access to only `read` methods or specific tags).
6. Click **Create** and copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<token>`).

### Method 2: Via the Truto API

For teams building programmatic [AI agent](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) provisioning, you can generate MCP servers on the fly using the Truto REST API. This request validates that the integration has tools available, generates a secure token, and returns a ready-to-use URL.

**Request:**
```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Marketo Claude Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["leads", "campaigns"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

**Response:**
```json
{
  "id": "mcp_abc123",
  "name": "Marketo Claude Assistant",
  "config": {
    "methods": ["read", "write"],
    "tags": ["leads", "campaigns"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

Save this `url`. It is the only configuration your AI client needs to discover tools and execute API calls.

## Step 2: Connect the MCP Server to Claude

Once you have your Truto MCP URL, you need to expose it to Claude. The open MCP standard allows Claude to automatically request the `tools/list` JSON-RPC endpoint and understand exactly how to format queries for Marketo.

### Method A: Via the Claude UI (or ChatGPT)

If you are using a consumer UI that supports remote MCP connectors (like Claude Desktop or ChatGPT Developer Mode):

1. In your AI client, open the **Settings** menu.
2. Navigate to **Connectors** (in ChatGPT) or **Integrations -> Add MCP Server** (in Claude).
3. Select **Add custom connector**.
4. Give it a name (e.g., "Adobe Marketo Engage").
5. Paste the Truto MCP URL into the Server URL field and click **Add**.

Claude will immediately ping the server, complete the handshake, and expose the Marketo tools in your chat interface.

### Method B: Via Manual Config File (`claude_desktop_config.json`)

If you are configuring Claude Desktop manually or running headless agents, you can wire the server using the standard configuration file. Because Truto serves tools remotely over HTTPS via Server-Sent Events (SSE), you use the official MCP SSE transport adapter.

Open your Claude Desktop config file:
- **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`

Add the Marketo server configuration:

```json
{
  "mcpServers": {
    "marketo_engage": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}
```
Restart Claude Desktop. The tools will now be available in your prompt context.

## Hero Tools for Adobe Marketo Engage

Truto automatically generates highly descriptive snake_case tools based on the Marketo REST API schema. When Claude calls these tools, Truto routes the JSON-RPC request to the underlying Marketo endpoint, managing the pagination cursors and flat input namespaces automatically.

Here are some of the highest-leverage hero tools available in the Marketo Engage MCP server:

### list_all_adobe_marketo_engage_leads
Fetches a list of lead records filtered by a specific field value. Truto automatically injects `limit` and `next_cursor` properties into the query schema to handle Marketo's 300-record batch pagination.

> "Find all leads in Marketo where the lead status is 'Disqualified'. Fetch the first 50 records."

### create_a_adobe_marketo_engage_lead
Syncs (creates or updates) one or more leads in the Marketo instance. The AI can format an array of lead objects, and Marketo will deduplicate them based on the email address or custom dedupe fields.

> "Create a new lead in Marketo for Jane Doe (jane.doe@example.com) and set her company name to 'Acme Corp'."

### create_a_adobe_marketo_engage_custom_activity
Adds a custom activity to a lead's timeline. This requires provisioning custom activity types in the instance beforehand. The AI uses this tool to log offline events, webinar attendance, or product usage milestones.

> "Log a custom activity for lead ID 104592 indicating they attended the 'Q3 Product Roadmap' webinar."

### adobe_marketo_engage_campaigns_trigger
Triggers an active Smart Campaign by passing a set of leads through its flow. The campaign must have a 'Campaign is Requested: Web Service API' trigger configured in the Marketo UI.

> "Trigger the 'Welcome Nurture' smart campaign (campaign ID 1024) for leads 5521 and 5522."

### list_all_adobe_marketo_engage_smart_lists
Retrieves the user-created Smart Lists available in the Marketo instance. This is essential for AI agents looking to assign leads to specific segmented audiences or retrieve list IDs for subsequent operations.

> "List all available smart lists in the 'Q4 Trade Shows' folder so we can find the correct list ID to add our new prospects to."

### create_a_adobe_marketo_engage_bulk_lead_export
Initiates an asynchronous Bulk Export Activity job. Because Marketo restricts synchronous read sizes, this tool allows the AI to kick off large-scale extraction jobs using a filter parameter.

> "Create a bulk lead export job in Marketo for all leads created in the past 7 days. Return the export ID so we can enqueue it."

To view the complete inventory of available tools, including bulk export status tracking, custom object management, and program member syncing, visit the [Adobe Marketo Engage integration page](https://truto.one/integrations/detail/adobemarketoengage).

## Workflows in Action

When Claude has access to the Marketo MCP server, it can chain multiple tools together to accomplish complex operational tasks. Here are two real-world examples of how an AI agent executes multi-step Marketo workflows.

### Workflow 1: Qualifying and Triggering a Smart Campaign

Marketing Operations teams frequently need to qualify leads based on intent signals and inject them into specific nurture tracks.

> "Find the lead record for john.smith@techcorp.com. If he exists, find the smart campaign named 'Enterprise ABM Nurture' and trigger that campaign for his lead ID."

**Execution Steps:**
1. Claude calls `list_all_adobe_marketo_engage_leads` with `filterType=email` and `filterValues=john.smith@techcorp.com`.
2. Marketo returns the lead record containing `id: 99482`.
3. Claude calls `list_all_adobe_marketo_engage_smart_campaigns` and filters the response to locate the ID for "Enterprise ABM Nurture" (e.g., `id: 412`).
4. Claude calls `adobe_marketo_engage_campaigns_trigger` passing `campaign_id: 412` and a body containing the lead ID `99482`.

```mermaid
sequenceDiagram
  participant User as User
  participant Claude as Claude Desktop
  participant MCP as Truto MCP Server
  participant Marketo as Marketo API

  User->>Claude: Find john.smith@techcorp.com & trigger ABM campaign
  Claude->>MCP: list_all_adobe_marketo_engage_leads(email, john.smith...)
  MCP->>Marketo: GET /rest/v1/leads.json?filterType=email...
  Marketo-->>MCP: { "result": [ { "id": 99482 } ] }
  MCP-->>Claude: Lead ID 99482
  Claude->>MCP: list_all_adobe_marketo_engage_smart_campaigns()
  MCP->>Marketo: GET /rest/asset/v1/smartCampaigns.json
  Marketo-->>MCP: { "result": [ { "id": 412, "name": "Enterprise ABM Nurture" } ] }
  MCP-->>Claude: Campaign ID 412
  Claude->>MCP: adobe_marketo_engage_campaigns_trigger(412, [99482])
  MCP->>Marketo: POST /rest/v1/campaigns/412/trigger.json
  Marketo-->>MCP: { "success": true }
  MCP-->>Claude: Trigger successful
  Claude-->>User: "I have successfully triggered the ABM campaign for John Smith."
```

### Workflow 2: Managing the Asynchronous Bulk Export Pipeline

When a user requests a massive data dump, the LLM must navigate Marketo's asynchronous bulk extract endpoints.

> "I need to export all leads modified this week. Start the bulk export job, enqueue it, and tell me the export ID so I can check on the status later."

**Execution Steps:**
1. Claude calls `create_a_adobe_marketo_engage_bulk_lead_export` with the required `fields` and `filter` parameters defining the date range.
2. The MCP server returns the new job details, noting the status is `Created` and providing the `exportId`.
3. Claude calls `adobe_marketo_engage_bulk_lead_exports_enqueue` using the returned `exportId`.
4. Marketo updates the status to `Queued`.
5. Claude informs the user that the job is queued and provides the ID for future reference. (Later, the user can prompt Claude to call `adobe_marketo_engage_bulk_lead_exports_get_status` and `adobe_marketo_engage_bulk_lead_exports_get_file`).

## Security and Access Control

Granting an LLM direct access to your marketing database requires strict governance. Truto's MCP architecture provides four distinct layers of security and filtering configurable when you generate the server token:

*   **Method Filtering (`methods`):** You can explicitly restrict the MCP server to read-only operations. By setting `methods: ["read"]`, Truto will omit any `create`, `update`, or `delete` tools from the generated server, ensuring the LLM cannot accidentally modify Marketo records.
*   **Tag Filtering (`tags`):** If you only want the AI to manage "leads" but not "campaigns" or "bulk_exports", you can provide an array of tags. Truto filters the documentation records and only exposes tools associated with those requested domains.
*   **Secondary Authentication (`require_api_token_auth`):** By default, possessing the MCP URL is enough to connect. Enabling this flag forces the client to also pass a valid Truto API token in the `Authorization` header, preventing unauthorized execution even if the URL leaks.
*   **Time-to-Live (`expires_at`):** You can set an absolute ISO datetime for the server's expiration. Once expired, Truto automatically cleans up the database record and invalidates the Cloudflare KV entries, permanently shutting down access.

## Give Your AI Agents Secure Marketo Access

Building a custom MCP server for Adobe Marketo Engage forces your team to take ownership of complex API schemas, pagination logic, and asynchronous job pipelines. Truto abstracts this away, dynamically generating documented, safe, and curated tools directly from your integrated accounts.

By leveraging Truto's managed MCP servers, you can instantly give Claude read and write capabilities across your marketing stack without managing a single server deployment.

> Ready to orchestrate your marketing operations with AI? Talk to our engineering team about deploying managed MCP servers for your enterprise.
>
> [Talk to us](https://truto.one/book-a-demo/)