The DigitalOcean MCP Server enables AI assistants to interact with DigitalOcean resources programmatically through comprehensive API access. With this server, you can:
Configure API Credentials: Set up DigitalOcean API tokens for authentication
Discover Endpoints: List, search, and get details for over 471 API endpoints
Execute API Calls: Make authenticated requests to any DigitalOcean API endpoint
Browse by Category: Filter endpoints by tags (e.g., Droplets, Databases, Load Balancers)
Manage Resources: Perform common cloud infrastructure tasks programmatically
The server dynamically extracts endpoints from the OpenAPI specification, ensuring complete and up-to-date API coverage with secure, authenticated operations.
Provides dynamic access to 471+ DigitalOcean API endpoints extracted from their OpenAPI specification, allowing management of resources like Droplets, Databases, Kubernetes clusters, Load Balancers, Block Storage, and more with full CRUD operations across all DigitalOcean service categories.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@DigitalOcean MCP Server list my droplets and show their status"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server that provides comprehensive access to all DigitalOcean API endpoints, dynamically extracted from their OpenAPI specification. This server enables AI assistants to interact with your DigitalOcean resources programmatically.
Complete API Coverage: Access to 471+ DigitalOcean API endpoints across all services
Dynamic Endpoint Discovery: Automatically extracts and indexes endpoints from DigitalOcean's OpenAPI spec
Intelligent Search: Find endpoints by operation ID, summary, description, or tags
Detailed Documentation: Get parameter details, descriptions, and requirements for each endpoint
Authenticated API Calls: Execute API calls through the MCP server with proper authentication
Tag-based Organization: Browse endpoints by category (Droplets, Load Balancers, Databases, etc.)
Auto-configuration: Automatically configures from DIGITALOCEAN_API_TOKEN environment variable
Related MCP server: Semantic API
npm install
npm run buildCreate a .env file or set the environment variable:
export DIGITALOCEAN_API_TOKEN="your-digitalocean-api-token"npm startOr for development with auto-reload:
npm run devThe server provides these MCP tools for AI assistants:
Set up API credentials (optional if using environment variable)
List all available endpoints with optional filtering by tag
Search endpoints by query string
Get detailed information about a specific endpoint
Execute API calls with authentication
Show all available endpoint categories
// List all droplets
{
"tool": "call_digitalocean_api",
"arguments": {
"operationId": "droplets_list"
}
}
// Create a new droplet
{
"tool": "call_digitalocean_api",
"arguments": {
"operationId": "droplets_create",
"parameters": {
"name": "example-droplet",
"region": "nyc3",
"size": "s-1vcpu-1gb",
"image": "ubuntu-20-04-x64"
}
}
}// Find all droplet-related endpoints
{
"tool": "search_endpoints",
"arguments": {
"query": "droplet",
"limit": 10
}
}
// List endpoints by category
{
"tool": "list_endpoints",
"arguments": {
"tag": "Load Balancers",
"limit": 5
}
}
// Get detailed endpoint information
{
"tool": "get_endpoint_details",
"arguments": {
"operationId": "droplets_list"
}
}extract_endpoints.py: Python script that parses the OpenAPI spec and extracts endpoint definitions
src/endpoints.ts: TypeScript module for loading and searching endpoint data
src/api-client.ts: HTTP client for making authenticated API calls
src/index.ts: Main MCP server implementation
The server provides access to all DigitalOcean API endpoints across categories including:
1-Click Applications
Account Management
Billing
Block Storage Volumes
CDN Endpoints
Certificates
Container Registry
Databases
Domains and DNS
Droplets
Firewalls
Floating IPs
Images
Kubernetes
Load Balancers
Monitoring
Projects
Reserved IPs
Snapshots
SSH Keys
Tags
VPCs
And more...
To regenerate the endpoint data:
python extract_endpoints.pyTo rebuild the server:
npm run buildAdd to your Claude Desktop MCP configuration (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"digitalocean": {
"command": "node",
"args": ["/path/to/digitalocean-mcp/dist/index.js"],
"env": {
"DIGITALOCEAN_API_TOKEN": "your-digitalocean-api-token"
}
}
}
}For Claude Code users, the server auto-configures from environment variables:
export DIGITALOCEAN_API_TOKEN="your-digitalocean-api-token"
claude// Check droplet status across your infrastructure
{
"tool": "call_digitalocean_api",
"arguments": {
"operationId": "droplets_list"
}
}
// Scale a droplet
{
"tool": "call_digitalocean_api",
"arguments": {
"operationId": "dropletActions_post",
"parameters": {
"droplet_id": "123456789",
"type": "resize",
"size": "s-2vcpu-4gb"
}
}
}// List database clusters
{
"tool": "call_digitalocean_api",
"arguments": {
"operationId": "databases_list_clusters"
}
}
// Create database backup
{
"tool": "call_digitalocean_api",
"arguments": {
"operationId": "databases_add_backup",
"parameters": {
"database_cluster_uuid": "your-cluster-uuid"
}
}
}// List load balancers
{
"tool": "call_digitalocean_api",
"arguments": {
"operationId": "load_balancers_list"
}
}
// Update load balancer configuration
{
"tool": "call_digitalocean_api",
"arguments": {
"operationId": "load_balancers_update",
"parameters": {
"lb_id": "your-lb-id",
"name": "updated-lb-name",
"algorithm": "round_robin"
}
}
}API tokens are handled securely and never logged
All requests use HTTPS
Rate limiting is handled automatically
Environment variables are preferred for token storage
Fork the repository
Create a feature branch
Make your changes
Add tests if applicable
Submit a pull request
MIT License - see LICENSE file for details
GitHub Issues: Report bugs or request features
Documentation: See the examples above and endpoint details via the get_endpoint_details tool
DigitalOcean API Docs: Official API Documentation
Call a DigitalOcean API endpoint
| Name | Required | Description | Default |
|---|---|---|---|
| operationId | Yes | Operation ID of the endpoint to call | |
| parameters | No | Parameters for the API call |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'call' implies an action, but doesn't specify whether it's read-only, destructive, requires authentication, has rate limits, or what the response format might be. For a general API-calling tool with zero annotation coverage, this leaves critical behavioral traits undefined.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste—it directly states the tool's function without fluff. It's appropriately sized for a general-purpose tool and front-loaded with the core action, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (making API calls with dynamic parameters) and lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects like error handling, authentication needs, or return values, which are crucial for an agent to use this tool effectively. Siblings suggest this is part of a broader API management suite, but the description doesn't integrate that context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for 'operationId' and 'parameters', so the schema does the heavy lifting. The description adds no meaning beyond this—it doesn't explain how to use 'operationId' (e.g., referencing endpoints from 'list_endpoints') or what 'parameters' might include. Baseline 3 is appropriate as the schema provides adequate documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Call a DigitalOcean API endpoint' states the action (call) and target (DigitalOcean API endpoint), which provides a basic purpose. However, it's vague about what 'call' entails (e.g., making HTTP requests, executing operations) and doesn't distinguish it from siblings like 'get_endpoint_details' or 'list_endpoints', which might involve similar API interactions. It avoids tautology but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing configuration via 'configure_digitalocean_api'), exclusions, or comparisons to siblings like 'list_endpoints' for browsing or 'search_endpoints' for filtering. Without such context, an agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Configure DigitalOcean API credentials. Can be auto-configured from DIGITALOCEAN_API_TOKEN environment variable.
| Name | Required | Description | Default |
|---|---|---|---|
| baseUrl | No | API base URL (default: https://api.digitalocean.com) | https://api.digitalocean.com |
| token | Yes | DigitalOcean API token |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that credentials 'can be auto-configured,' which hints at a setup or initialization behavior, but it doesn't disclose critical traits such as whether this action is idempotent, if it requires specific permissions, what happens on failure, or if it persists credentials globally. For a configuration tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, consisting of just two sentences that directly state the purpose and a key usage note. Every sentence earns its place by providing essential information without any waste, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a configuration tool with no annotations and no output schema, the description is incomplete. It lacks details on what the tool actually does behaviorally (e.g., stores credentials, validates them, returns success/failure), and it doesn't explain the outcome or any potential side effects. For such a tool, more context is needed to be fully helpful to an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not add any parameter-specific information beyond what the input schema provides. The schema has 100% description coverage, clearly documenting both parameters ('baseUrl' and 'token') with their types, defaults, and requirements. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate with additional semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Configure DigitalOcean API credentials.' It specifies the verb ('configure') and resource ('DigitalOcean API credentials'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'call_digitalocean_api' or 'list_endpoints,' which might also involve API interactions, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context by mentioning auto-configuration from an environment variable, which implies when this tool might be used (e.g., for initial setup). However, it lacks explicit guidance on when to use this tool versus alternatives like manually setting credentials elsewhere or using other sibling tools. No exclusions or clear alternatives are stated, leaving usage somewhat implied rather than fully guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific endpoint
| Name | Required | Description | Default |
|---|---|---|---|
| operationId | Yes | Operation ID of the endpoint |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), but doesn't mention potential side effects, authentication requirements, rate limits, error handling, or the format of the returned information. This leaves significant gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a simple tool, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'detailed information' includes, how to handle errors, or any behavioral traits. For a tool with no structured data beyond the input schema, more context is needed to fully guide an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the parameter 'operationId' fully documented in the schema. The description adds no additional meaning about the parameter beyond implying it identifies a 'specific endpoint', which is already covered by the schema's description. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about a specific endpoint'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_endpoints' or 'search_endpoints' beyond the 'specific' qualifier, which is why it doesn't reach a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'list_endpoints' or 'search_endpoints'. It mentions 'specific endpoint' but doesn't clarify prerequisites, such as needing an operation ID from another source, or exclusions for when other tools might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available DigitalOcean API endpoints
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Limit number of results | |
| tag | No | Filter by tag (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't describe how it behaves—no information on pagination, rate limits, authentication needs, error handling, or what 'list all' means in practice (e.g., does it return a complete list or require pagination?). This leaves significant gaps in understanding the tool's operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse. Every word earns its place, achieving ideal conciseness for a simple listing tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 optional parameters, no output schema, no annotations), the description is incomplete. It doesn't address behavioral aspects like how results are returned (e.g., paginated vs. all at once), error cases, or usage context relative to siblings. For a tool with no annotations or output schema, more contextual information would be helpful for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters ('limit' and 'tag') clearly documented in the schema. The description adds no parameter-specific information beyond what the schema provides. According to the rules, when schema coverage is high (>80%), the baseline score is 3 even with no param info in the description, which applies here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all available DigitalOcean API endpoints'), making the tool's purpose immediately understandable. It doesn't explicitly differentiate from siblings like 'search_endpoints' or 'get_endpoint_details', but the scope ('all available') provides some implicit distinction. This is clear but lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'search_endpoints' or 'get_endpoint_details'. There's no mention of prerequisites, context, or exclusions. The agent must infer usage from the name and description alone, which is insufficient for optimal tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available endpoint tags
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states what the tool does without any behavioral context. It doesn't mention whether this is a read-only operation, what format the results come in, if there are rate limits, or any other behavioral characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that gets straight to the point with no wasted words. It's perfectly sized for a simple tool with no parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description provides the basic purpose but lacks important context about what 'endpoint tags' are, how they relate to endpoints, and what the output format looks like. The absence of annotations means more behavioral context should be provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there's no need for parameter documentation. The description appropriately focuses on the tool's purpose rather than parameter details, which is sufficient given the empty input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('endpoint tags'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'list_endpoints' or explain what 'endpoint tags' are versus 'endpoints' themselves.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'list_endpoints' or 'search_endpoints'. There's no mention of prerequisites, context, or specific use cases for retrieving tags rather than endpoints.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for DigitalOcean API endpoints
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Limit number of results | |
| query | Yes | Search query |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the search action without mentioning permissions, rate limits, response format, or pagination behavior. This is inadequate for a search tool with zero annotation coverage, as it leaves critical operational details unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste, front-loading the core purpose. It is appropriately sized for the tool's complexity, making it easy to parse without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't address behavioral traits, result handling, or differentiation from siblings, which are essential for effective tool use. This gap is significant for a search tool with multiple related siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning the input schema already documents both parameters ('limit' and 'query') fully. The description adds no additional meaning beyond what the schema provides, such as query syntax examples or result filtering details, so it meets the baseline score for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search for') and resource ('DigitalOcean API endpoints'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from sibling tools like 'list_endpoints' or 'get_endpoint_details,' which likely have overlapping functionality, so it misses the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as 'list_endpoints' or 'get_endpoint_details.' It lacks explicit context, exclusions, or prerequisites, leaving the agent with minimal usage direction beyond the basic purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0call_digitalocean_apiconfigure_digitalocean_apiget_endpoint_detailslist_endpointslist_tagssearch_endpointsThe tools have some clear distinctions, such as list_endpoints vs. search_endpoints, but there is significant overlap and ambiguity. For example, call_digitalocean_api and get_endpoint_details both relate to endpoint interactions, and configure_digitalocean_api is a setup tool that might be confused with the others in practice. The descriptions help clarify, but the boundaries between endpoint-related tools are not sharply defined.
The tool names follow a mostly consistent verb_noun pattern, such as list_endpoints, get_endpoint_details, and search_endpoints. However, there are minor deviations like call_digitalocean_api (which uses 'call' instead of a more specific verb) and configure_digitalocean_api (which is more of a setup action). Overall, the naming is readable and predictable with only slight inconsistencies.
With 6 tools, the count is reasonable for a server focused on DigitalOcean API interactions. It covers configuration, listing, searching, and calling endpoints, which aligns well with the apparent scope. However, it might be slightly thin if more granular operations (e.g., specific resource management) are expected, but it's well-scoped for its purpose.
The tool set provides basic coverage for exploring and using DigitalOcean APIs, including configuration, listing, searching, and calling endpoints. However, there are notable gaps: it lacks direct CRUD operations for DigitalOcean resources (e.g., droplets, volumes, databases), which are core to the domain. This makes the surface incomplete for full agent workflows, as users might need to rely heavily on generic API calls instead of dedicated tools.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Search, document and execute authenticated API calls across 700+ apps via one MCP server
APIs.guru MCP — keyless directory of 2,500+ public APIs and their OpenAPI specs.
Discover and call 10,000+ production APIs from one MCP server. Pay-per-call billing for AI agents.
Remote MCP for 1,500+ APIs. Vault-managed credentials; OAuth or API key. Search, load, and execute.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/amranu/digitalocean-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
