MCP vs. API: What’s the difference and why it matters
Your RMM or PSA may already have an API. So why would anyone add MCP on top of it?
It is a fair question. The MCP vs. API debate often sounds like a choice, but MCP does not replace the API. A script that patches endpoints on a schedule should keep calling the API directly. MCP matters when the caller is an AI agent that has to work out, at runtime, which tool fits the request.
This guide explains the differences in plain terms. It walks through one Datto RMM task done both ways, then covers when each approach makes sense and where security fits.
MCP vs. API: The short answer
An API is an interface that software calls directly. Developers read the documentation, write the requests and decide the order of the calls. The Datto RMM API works this way. It is a REST API with documented endpoints, OAuth 2.0 authorization and an OpenAPI specification.
Model Context Protocol (MCP) is a protocol that standardizes how an AI application finds and calls tools. A server describes each tool with a name, a description and an input schema. The AI application reads that list and lets the model choose. The MCP architecture overview gives file operations, API calls and database queries as typical tool examples.
That last example matters. An MCP tool often wraps an API call. The API still does the work, and MCP describes which parts of it the model may use.
| API | MCP | |
|---|---|---|
| Main caller | Code a developer wrote | An AI application |
| Who picks the operation | The developer, ahead of time | The model, at runtime |
| How you see what is available | Documentation or an OpenAPI file | The server lists its tools on request |
| What the contract defines | Endpoints and data models | Tools, resources and prompts |
| Typical relationship | Does the work | Often calls the API underneath |
What the API still does best
Direct API calls remain the right choice for anything predictable. If a nightly job pulls device data into a report, the schedule, endpoint and fields never change. A model would add cost and uncertainty without adding judgment.
APIs also come with controls built for volume. Datto RMM limits query requests to 600 within 60 seconds and write requests to 100, counted across the whole account. Results come back 250 at a time. Those numbers are easy to plan around in code. They are easier to trip when an agent loops through every device.
Access is explicit, too. The API documentation lists the minimum permissions each endpoint needs, and each API key carries a security level. Nothing happens that a developer did not write down.
What MCP adds for AI agents
MCP standardizes the parts that every agent integration would otherwise rebuild by hand. Three of them stand out.
Discovery at runtime
A client asks a server what it offers. Every MCP server must answer a server/discover request with its capabilities, and clients can call tools/list to get each tool’s name, description and input schema. The model works from those descriptions instead of from code someone wrote for one integration.
One pattern across many servers
The same list-and-call pattern works whether a server wraps a REST API, a database or a local file system. An assistant that speaks MCP can connect to a new server without custom adapter code.
Tools shaped around outcomes
An API has endpoints for sites, devices, alerts and jobs. A good MCP tool can sit one step above that, such as “list open alerts for a site by name.” Public listings show community-built Datto RMM MCP servers ranging from about eight tools to 46 tools that cover the full v2 API. More tools is not always better. The MCP documentation suggests progressive tool discovery for clients that connect to many servers.
One caution on older comparisons. Many explainers describe MCP as keeping session state. The current specification revision, dated July 28, 2026, describes MCP as stateless, because every request carries the information needed to process it. If an article leans on session context as the main difference, check its date.
One Datto RMM task, two ways
Take a simple request: show the open alerts for one client site, then decide whether to run a job. The Datto RMM API can do all of it. The difference is who does the planning.
Calling the API directly
A developer writes the sequence. The code gets the account’s sites with GET /v2/account/sites, finds the site’s unique ID and requests that site’s open alerts with GET /v2/site/{siteUid}/alerts/open. Each call needs a valid access token, and tokens expire after 100 hours. The code also handles pagination, retries and the rate limit. Nothing is left to interpretation.
Calling it through MCP
A technician types the request in plain language. The assistant reads the MCP server’s tool list and picks a tool such as list_open_alerts. That name is hypothetical, and real servers vary. The server runs the same API calls and returns a trimmed result. The model can then suggest a next step, such as running a quick job.
Running that job should need an approval. Creating a quick job through the API requires Manage permission on Active Jobs, so the key behind the server decides what is possible.
Notice what did not change. The same API sits underneath, the same permissions apply and the same rate limit counts every call. MCP changed who plans the sequence, not what the platform allows.
When to use the API, MCP or both
The deciding question is who or what makes the call.
Use the API directly when:
- Code already knows the exact operation
- The job is scheduled, high volume or sensitive to latency
- A script or SDK already does the job cleanly
- The same interface must serve apps and partners
Add MCP when:
- An AI assistant should choose among approved actions
- Several AI clients need the same integration
- The API is broad and agents need a smaller surface
- Technicians want to ask questions in plain language
Many teams need both. Keep the API as the source of truth and put the MCP server beside it. Do not copy the business logic into a second place.
Where security fits
Neither interface is safe by default. An API key with administrator rights carries the same access behind an MCP server as it does in a script.
MCP adds one new risk. The model reads text that outsiders can write, such as tickets or event logs, and it can act on that text. The NSA’s May 2026 guidance on MCP says established defenses fall short of covering risks such as dynamic tool invocation and implicit trust.
The practical answer is the discipline you already apply to APIs, tightened. Use one key per integration and the narrowest security level that works. Start read-only and require approval before writes. Datto RMM lets administrators set an API Security Level and an API Component Level on each key, which gives you scoping controls to start with.
What this means for MSPs
Your RMM’s API is the foundation for your own automation, and MCP is one way AI assistants will reach it. Kaseya has said it is expanding API access so MSPs can build their own integrations.
Demand is already there. Kaseya’s 2026 State of the MSP Report found that 53% of MSPs already use AI to automate ticketing, patching and monitoring. More than half have automated only about a quarter of their workload.
That makes the interface decision practical. Keep the API for fixed workflows that already work. Add MCP where technicians would benefit from asking questions in plain language, and pilot it on one low-risk site first.
Learn more about Kaseya’s MCP servers and skills.
MCP vs. API questions, answered
Does MCP replace APIs?
No. An MCP server often calls an API underneath. The API still performs the work. MCP describes which operations an AI application can discover and use.
Can an agent use an API without MCP?
Yes. An agent that can read documentation and make web requests can call an API directly. That can be fine for a one-off, low-risk task. MCP helps when you want a consistent, discoverable and controlled interface across AI clients.
Do I need MCP for my own scripts?
No. Scripts already know what they need to call, so direct API calls are simpler to test and run.
How to decide this week
Pick one task your team repeats. If the steps never change, script it against the API. If the request changes every time, such as “what is wrong at this client,” that is where an MCP-connected assistant earns its place. Just make sure the key behind it is scoped.
Want to see the Datto RMM API controls in action? Request a demo.
Key Takeaways
- MCP does not replace APIs. It gives AI agents a standard way to find and call them.
- Use the API for predictable work and add MCP when an AI must choose.
- The key behind an MCP server still decides what an agent can do.
Table of Contents


