AceDataCloudMCP

A Model Context Protocol (MCP) server for managing your AceDataCloud account through the platform management API.

Check your balance, look up usage and spend, manage API keys, list services, create and pay recharge orders, manage platform tokens, list models, and use account permissions to edit and publish blogs or announcements — directly from Claude, VS Code, Studio, or any MCP-compatible client.

This is the management / console API (platform.acedata.cloud) — different from the data-generation MCP servers (Suno, Midjourney, …) that call api.acedata.cloud.

Tool Reference

The default curated catalog advertises 345 tools before account-permission filtering, including acedatacloud_get_usage_guide. The complete compatibility registry retains 516 tools. Discovery is grouped by business task, not by one tool per REST endpoint.

Categories

Workspace tools cover delegated editing and site/webhook management. Admin tools require their exact permission grants, not just an admin label.

Account & API keys

Catalog & documentation

Applications & deployments

Usage & billing

Sites & branding

Community & wallet

Content & announcements

Email marketing & analytics

Access control & automation

Payment authorization

Administration & risk

Files & utilities

Calling a write/admin tool without confirm=true returns a redacted dry-run preview and performs no HTTP request.

Quick Start

Hosted OAuth

Connect to https://mcp.acedata.cloud/mcp with an OAuth-capable MCP client and review the account capabilities shown on the authorization page:

Documentation, service/pricing catalogs, API definitions and public model catalogs are public reads and require no OAuth scope. Administrative tools still require the account's existing backend roles and object/site access.

After consent, the hosted server reuses or creates a durable platform token. Tool calls use that token and the account's current permissions; the OAuth scope list describes consent and is not a scope ceiling stored on the platform token. The token stays valid until revoked. Mutating tools retain their confirm=true checks.

1. Get a platform token

Create one at platform.acedata.cloud/console/platform-tokens. It starts with platform- and never expires.

Use a platform token, not the per-service api.acedata.cloud token — the latter returns 401 against the management API.

2. Install

pip install mcp-acedatacloud

3. Configure your client

Claude Desktop / VS Code (stdio):

{
  "mcpServers": {
    "acedatacloud": {
      "command": "mcp-acedatacloud",
      "env": {
        "ACEDATACLOUD_PLATFORM_TOKEN": "platform-v1-xxxxxxxx"
      }
    }
  }
}

Hosted (HTTP) — token per request:

{
  "mcpServers": {
    "acedatacloud": {
      "url": "https://mcp.acedata.cloud/mcp",
      "headers": { "Authorization": "Bearer platform-v1-xxxxxxxx" }
    }
  }
}

Example prompts

• "Draft a Chinese product blog in Markdown, show it for review, then save it."
• "Read blog draft <id> and publish it after I approve the content."
• "Schedule blog <id> for 2026-10-10T09:00:00+08:00."
• "How many credits do I have left?"
• "What did I spend on Suno in the last 7 days?"
• "List my API keys and show which ones have a spend cap."
• "Create a new API key on application <id> named ci." → previews, then run with confirm.
• "Top up application <id> with package <id> and give me the Stripe pay link."

Configuration

Development

pip install -e ".[dev,test,http]"
pytest -m "not integration"      # unit tests
ruff check .                      # lint
mypy core tools                   # type-check
mcp-acedatacloud --transport http --port 8000

Notes

• Amounts (remaining_amount, used_amount, totals) are in Credits, not USD.
• Newly created credential/platform tokens are returned in full only once — store them immediately.
• Credential rotation = delete + recreate (no in-place rotate endpoint).
• Blog editorial tools use blog:read, blog:write, and blog:publish permissions. Direct grants and permission groups work without making the account a superuser.
• Blog publication requires a saved draft approved by a different account with blog:read and blog:publish. The publisher must also differ from the reviewer. Read the draft's review_version before approval; content edits revoke approval.
• Hosted OAuth resolves the signed-in account's canonical permissions dynamically. The consent page displays the actual scopes; accounts without blog grants receive none. Reconnect OAuth to review newly granted permissions. Existing durable platform tokens follow current account permissions, including revocations, on each request.
• Announcement tools require the corresponding account permission.

Management API coverage

The checked-in route ledger in contracts/management_surface.json covers the current Platform management API. Every business operation maps to a native typed tool; callbacks, internal/device protocols, website asset delivery and methods rejected by the backend have explicit exclusion reasons. Existing account tools retain their subject-scoped queries. Administrative tools use the backend's canonical permission names and ownership checks.

Hosted tools/list is filtered using the current platform credential's effective permissions from /platform-tokens/me/. Deploy the Backend subject response and the Auth consent changes before this MCP. File upload inputs and binary outputs are Base64 artifacts bounded to 2 MiB; signed download links are returned directly.

Discovery and compatibility

The default ACEDATACLOUD_TOOL_PROFILE=curated advertises task-oriented tools instead of duplicate generated REST aliases, redundant PUT variants and web-client helpers (rendering, read receipts, telemetry and protocol plumbing). It keeps personal-account, site, editorial and administrative business workflows. The usage guide lists only tools visible to the current credential. Each advertised API tool also carries acedatacloud/category and acedatacloud/audience metadata in its MCP _meta field.

Legacy names, arguments and routes remain callable for existing integrations; hidden aliases are not redirected to another implementation. The complete API coverage ledger and schema snapshot remain unchanged. Set ACEDATACLOUD_TOOL_PROFILE=full explicitly for compatibility discovery or diagnostics. This restores discovery only: permissions, ownership checks, secret redaction and confirm=true requirements still apply.

Cross-account collection tools stay discoverable only with the matching :any permission. Personal-account tools continue to scope queries to the authenticated subject. An unrelated administrative permission never promotes an account query into a cross-account query.

To refresh the generated surface with the Backend runtime and then the MCP runtime:

<backend-python> scripts/export_platform_management.py --backend <PlatformBackend> --output /tmp/platform-routes.json
python scripts/compile_platform_management.py --input /tmp/platform-routes.json --backend <PlatformBackend>

Both scripts live at the monorepo root. The exporter uses synthetic configuration and does not read a production .env or execute endpoint handlers.

Documentation

Documentation

License

MIT — see LICENSE.