A practical field guide from Automation Ace.
Short answer: a direct API call is your code sending a request straight to an app's API with a token it holds. An authenticated proxy is your code sending the same request to a platform such as Nango or Pipedream Connect, with a connection ID instead of a token; the proxy adds the user's credentials and forwards it. An MCP tool call is an AI client asking an MCP server, such as Zapier MCP or one from Composio or Arcade, to run a named action with arguments; the server holds the credentials and decides how to call the API. Direct calls give the most control, proxies remove token handling, and MCP tools give agents safe, named actions.
Short answer
- Direct: your code + your token + any endpoint.
- Proxy: your code + connection ID + any endpoint; the platform holds tokens.
- MCP tool: a model + named tools; the server holds tokens and limits what is possible.
Direct API calls
Your code builds the request and authenticates it, usually with an API key, a personal access token, or an OAuth access token it obtained and refreshes. This is right for a single API using your own credentials, or when latency and full control matter. It becomes a burden when every user brings their own account across many apps. Basics: API vs webhook and API authentication for automation.
Authenticated proxies
You still write the request (the app's path, query, and body), but you send it to the proxy with your platform key and the user's connection ID. The platform injects the right token, refreshes it when needed, and can retry. You keep endpoint-level flexibility without storing anyone's tokens. See calling APIs from JavaScript without managing OAuth tokens.
MCP tool calls
With the Model Context Protocol, an MCP server publishes tools (name, description, input schema). An AI client lists them, the model picks one and fills the arguments, and the server runs it with credentials the model never sees. You trade flexibility for safety and convenience: the agent can do only what the tools allow. See how AI agents use tools: APIs, MCP, and app integrations and API vs CLI vs MCP vs SDK.
Side-by-side comparison
| Direct API call | Authenticated proxy | MCP tool call | |
|---|---|---|---|
| Who sends the request | Your code, straight to the app's API | Your code, to a proxy that forwards it | An AI client, to an MCP server that runs the action |
| Who holds the token | Your code | The proxy platform | The MCP server or its auth platform |
| What you specify | Exact URL, method, headers, body | The app's path and body, plus a connection ID | A tool name and arguments |
| Flexibility | Any endpoint | Any endpoint the app allows | Only the tools exposed |
| Who decides to call | Your code | Your code | The model, within the tools allowed |
| Auth work for you | All of it | Very little | Very little |
| Typical latency | Lowest | Slightly higher (one hop) | Higher (model plus server) |
| Best for | One API, your own credentials, full control | Many users' accounts across many APIs | Agents and AI assistants |
The same request three ways
# 1) Direct API call: your code holds the token
curl https://api.hubapi.com/crm/v3/objects/contacts?limit=10 \
-H "Authorization: Bearer $HUBSPOT_ACCESS_TOKEN"
# 2) Authenticated proxy: your code holds a connection ID (Nango shown)
curl "https://api.nango.dev/proxy/crm/v3/objects/contacts?limit=10" \
-H "Authorization: Bearer $NANGO_SECRET_KEY" \
-H "Provider-Config-Key: hubspot" \
-H "Connection-Id: $CONNECTION_ID"
# 3) MCP tool call: the model asks for a tool; the MCP client sends
{ "method": "tools/call",
"params": { "name": "hubspot_search_contacts",
"arguments": { "query": "pat@prospect.com" } } }
How to choose
| Question | Points to |
|---|---|
| Is it one API with your own API key or service account? | Direct call |
| Do your users connect their own accounts? | Proxy (or tools) from a managed auth platform |
| Is code deciding exactly what to call? | Direct call or proxy |
| Is a model deciding what to do? | MCP or tool calls |
| Do you need endpoints no tool covers? | Proxy |
| Do you need to restrict what can happen? | Tools with an allowlist, or a proxy with path rules |
Combining them
- Proxy behind your own tools: write a narrow tool such as
add_note_to_leadthat validates input and calls the proxy. The agent gets a safe action; you keep endpoint control. - MCP for agents, proxy for jobs: the same connection serves an agent through tools and a nightly sync through the proxy.
- Direct calls for your own systems: your database or internal API needs no third-party auth platform.
Security differences
- Direct: your code and infrastructure hold tokens, so encryption, rotation, and leak response are yours.
- Proxy: one platform key unlocks many users' connections, so keep it server-side, scope it, and never accept connection IDs from the browser.
- MCP: the model chooses actions, so limit tools, require approval for risky ones, and treat inputs as untrusted; see limiting which app actions an agent can take.
Platforms compared: the best managed app auth platforms.
Frequently asked questions
What is the difference between a direct API call and an authenticated proxy?
In a direct API call your code holds the token and sends the request to the app. With an authenticated proxy, your code sends the request and a connection ID to a platform, which adds the user’s token, refreshes it when needed, and forwards the request.
What is an MCP tool call?
An AI client asks an MCP server to run a named tool with arguments. The server holds the credentials and makes the API calls, so the model never sees tokens and can only do what the exposed tools allow.
Should an AI agent use an API proxy or MCP tools?
Usually MCP or other tools, because they limit the agent to named, validated actions. If you need an endpoint no tool covers, wrap a proxy call in your own narrow tool rather than giving the agent the raw proxy.
Are authenticated proxies slower than direct API calls?
Slightly, because requests take one extra hop through the platform. For most integrations the difference is small compared with the time saved on token handling.
Can I use direct calls, proxies, and MCP together?
Yes. A common setup uses MCP or tools for agents, a proxy for background jobs and custom endpoints, and direct calls for your own internal systems.
Disclaimer: Managed app auth platforms, their SDKs, endpoints, plans, and features change quickly; details reflect public documentation and coverage at the time of writing, so confirm current details with each provider before building. Automation Ace is not affiliated with Composio, Nango, Pipedream, Arcade, or the other companies named here unless a link is marked as an affiliate link. This article may include links to apps, products, or services; some links may be affiliate links, which means Automation Ace may earn a commission at no extra cost to you.