# MCP Client Integration

> Connect any remote MCP server to Taskade and call its tools as steps inside your automations, with a live tool list and structured results.

- Source: https://www.taskade.com/learn/connect/mcp-client-integration
- Section: Connect
- Updated: 2026-11-03
- Index of all pages: https://www.taskade.com/learn/llms.txt

## Overview

The MCP Client connector lets a Taskade automation use the tools of another service. Paste the address of an MCP server once. Each tool on that server becomes a step your automation can run.

> **TL;DR:** Add the MCP Client connector to an [automation](https://www.taskade.com/learn/automation/automations-execution), paste an MCP server address, and call that server's tools as steps. **List Tools** shows what a server offers. **Call Tool** runs one and hands the result to the next step. It works on every plan. See [Pricing](https://www.taskade.com/pricing) for run limits.

```text
┌──────────────────────────────┐
│  Automation trigger          │
└──────────────┬───────────────┘
               ▼
┌──────────────────────────────┐
│  MCP Client: Call Tool       │
└──────────────┬───────────────┘
               │  calls a tool
               ▼
┌──────────────────────────────┐
│  Remote MCP server           │
└──────────────┬───────────────┘
               │  the result
               ▼
┌──────────────────────────────┐
│  Next step uses the result   │
└──────────────────────────────┘
```

This page covers the outbound direction, where Taskade calls out. For the inbound direction, where Claude or Cursor connects into your workspace, see [Taskade MCP Server](https://www.taskade.com/learn/connect/mcp-server).

## Before You Start

- **What you need**: the address of an MCP server that starts with `https://`, and its token if it asks for one.
- **Plan**: every plan, Free included.
- **Time**: about 5 minutes.

## Connect an MCP Server

1. Open **Automations** in your workspace and click **Create**.
2. Add a trigger, then add a step and pick **MCP Client**.
3. Click **Connect**.
4. Paste the **Server URL**.
5. If the server needs a token, paste it in **Bearer Token**. For an open server, leave it empty.
6. Save.

You are done when the connection saves. Taskade asks the server for its tool list when you save. A wrong address or an expired token fails at once, not at run time.

Taskade masks your token on screen and stores it encrypted. One connection covers the whole workspace, so each automation that talks to that server reuses it.

> 💡 **Tip:** Your own Taskade MCP server is at `https://www.taskade.com/mcp`. Connect to it with a personal access token from [Settings → API](https://www.taskade.com/settings/api) to let an automation work in another workspace. The target workspace must be on a paid plan.

## Add the Two Actions

| Action | What it does | Returns |
| --- | --- | --- |
| **List Tools** | Asks the server what it can do | `tools` (name, description, input schema) and `count` |
| **Call Tool** | Runs one tool and waits for the result | `text`, `content`, `structuredContent`, `isError` |

Run **List Tools** once while you build. It shows each tool with its name, its description, and the fields it expects.

**Call Tool** has two fields:

- **Tool**: a list loaded live from the server. If the server is down for a moment, type the name by hand.
- **Arguments (JSON)**: an object that matches the input of the tool, for example `{"query": "hello"}`. For a tool with no inputs, leave it empty.

## Read the Result

| Field | What it holds |
| --- | --- |
| `text` | The readable text of the result, in one string. Use it for messages and summaries. |
| `content` | The raw blocks the tool sent back, in order. |
| `structuredContent` | Data for a machine. Only a tool with an output schema fills it. |
| `isError` | `true` when the server marks the result as a failure. Add a filter on it for a fallback path. |

An image, audio, or other file comes back as a link. Taskade uploads the file and puts its address in the result, so a later step can use the link.

## Check That a Server Works

The connector speaks the standard protocol. A public MCP server works when it is open or accepts a bearer token. Taskade tries the newer connection type first and falls back to the older one, so you never pick.

| Rule | What happens |
| --- | --- |
| The address starts with `http://` | Rejected. Use `https://`. |
| The address holds a user name or password | Rejected. Put the token in **Bearer Token**. |
| The address points at `localhost` or a private network | Rejected. The server must be on the public internet. |
| The server asks you to sign in through a browser | Not supported. Ask the service for a token instead. |
| The server never finishes the connection | The step stops after 20 seconds and asks you to check the address. |

## Common Patterns

| You want to | Build this |
| --- | --- |
| Pull a fact from another tool | Trigger, **Call Tool**, then write `text` into a project |
| Handle a tool that can fail | **Call Tool**, a filter on `isError`, then two branches |
| Pass structured data on | **Call Tool**, then map fields out of `structuredContent` |
| Let an agent decide, then act | Ask an agent for the input, then **Call Tool** with its answer |
| Try a new server first | **List Tools** on its own, run once, and read the output |

## Frequently Asked Questions

**What is the MCP Client connector?**

It is an automation connector that calls tools on a remote MCP server. Connect the server once with its address and an optional token. Then add **List Tools** or **Call Tool** steps to any automation in the workspace.

**How is this different from the Taskade MCP server?**

The direction is different. The [Taskade MCP server](https://www.taskade.com/learn/connect/mcp-server) lets outside AI tools such as Claude and Cursor work in your workspace. The MCP Client connector goes the other way: your automations call the server of another service.

**Can my AI agents call an external MCP server directly?**

No. Agents use their [built-in tools](https://www.taskade.com/learn/agents/agent-tools) and your custom tools. To reach an MCP server, put the **Call Tool** step in an automation, and let the agent hand its answer to that step. See [Agents and External MCP Servers](https://www.taskade.com/learn/connect/mcp-client).

**Why is my server URL rejected?**

The address must start with `https://` and point at a server on the public internet. Taskade refuses `localhost`, an internal company address, and an address with a user name or password in it. Put a token in the **Bearer Token** field instead.

**Why is structuredContent empty?**

Only a tool that publishes an output schema returns `structuredContent`. Every other tool returns its result in `text` and `content`. Run **List Tools** to see what a tool declares before you build a branch on it.

**Which plan includes the MCP Client connector?**

Every plan. These steps carry no upgrade badge. Plans differ in the number of automation runs you get. See [Pricing](https://www.taskade.com/pricing) for the full matrix.

## Related guides

- [Automations](https://www.taskade.com/learn/automation/automations-execution). Triggers, steps, filters, and run history
- [Agents and External MCP Servers](https://www.taskade.com/learn/connect/mcp-client). How agents use outside MCP tools
- [Taskade MCP Server](https://www.taskade.com/learn/connect/mcp-server). The inbound direction, for Claude and Cursor
- [MCP Connectors](https://www.taskade.com/learn/genesis/mcp-connectors). A map of every MCP path in Taskade
- [Custom AI Agents](https://www.taskade.com/learn/agents/custom-agents). Give an agent the judgment call inside an automation