> ## Documentation Index
> Fetch the complete documentation index at: https://docs.acedata.cloud/llms.txt
> Use this file to discover all available pages before exploring further.

# AceKit - One-Click Integration of AceData AI Capabilities for Coding Agents

> Platform integration guide - Ace Data Cloud

You have probably encountered this situation too: you are using Claude Code, Cursor, or Codex, writing code smoothly, and suddenly need an illustration, a piece of background music, a short video, or want it to look up the latest information along the way. Then you discover—agents themselves do not know how to do these things. You have to find APIs yourself, read documentation, configure keys, write calling code, handle asynchronous polling; after all that hassle, your inspiration has long gone cold.

[AceKit](https://github.com/AceDataCloud/AceKit) is here to save you from this entire set of hassles. With one command, it installs image generation, video generation, music generation, web search, LLM conversations, and other capabilities from AceData Cloud into your coding agent as a complete package. After installation, you can just speak naturally; the agent will load the corresponding skills itself, authenticate itself, poll itself, and finish the work.

## Understand What It Does in 30 Seconds

Before installation vs. after installation:

| What you say | Before installation | After installation (the agent does it itself) |
| - | - | - |
| "Add a cover image to this README" | The agent cannot do it and asks you to find an image generation API yourself | Calls NanoBanana / Flux / Midjourney to generate an image |
| "Turn this script into a 30-second short video" | Cannot do it | Calls Sora / Veo / Kling / Seedance to generate a video |
| "Add a piece of background music to this demo" | Cannot do it | Calls Suno to generate music |
| "Search for the latest X and summarize it" | Cannot access the internet | Calls Google SERP to get real-time results |
| "Shorten this long URL" | Cannot do it | Calls a URL shortening service and returns a surl.id link |

In one sentence: **your coding agent goes from "only able to write code" to "also able to generate images, generate videos, generate music, and search the web."**

## Get Started in Three Steps

The entire process can be completed in a few minutes and requires Node.js 18+.

**Step 1 · Get an API Token.** Go to the [console](https://platform.acedata.cloud/console/applications) and copy a Token—this single one is shared by all capabilities. Your first application comes with free credits, so you can try it for free first.

![Copy the API Token in the console](https://cdn.acedata.cloud/dvc3cg.jpg)

**Step 2 · Install.** One command:

```bash theme={null}
npx acekit
```

It automatically detects the coding agents on your machine and installs the complete skill set. A real run looks like this (this machine only has Claude Code installed):

```text theme={null}
🃏  AceKit — wiring AI into your coding agent
✓  Detected: Claude Code
📦  Installing the AceData skill toolkit via @acedatacloud/skills …
Installed 19 skills to ~/.claude/skills
✅  Done. Try it now — ask your agent:
      "generate a hero image for this README"
      "turn this script into a 30-second video"
```

> If no Token is set, the first run will interactively prompt you to paste one; you can also run `export ACEDATACLOUD_API_TOKEN=yourtoken` in advance for a completely unattended installation. The number of skills will change as platform capabilities increase; refer to the current list displayed by `npx acekit list`.

**Step 3 · Speak naturally.** Reload your agent, then directly give it instructions, for example:

```text theme={null}
Use the short-url skill to shorten https://platform.acedata.cloud/services
```

The agent will load the skill itself, initiate the call itself, and give you a real, accessible result.

## Run It for Real (With Output)

The following four examples are all **real calls with results returned on the spot**, not demonstrations. The `$KEY` in the commands is your API Token.

**① Shorten a URL (synchronous, returns in seconds)**

```bash theme={null}
curl -X POST https://api.acedata.cloud/shorturl \
  -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
  -d '{"content":"https://platform.acedata.cloud/services"}'
```

Returns `https://surl.id/r/1uKp2kilXQ`—opening it will redirect with 302 back to the original services page.

**② Web search (synchronous)**

```bash theme={null}
curl -X POST https://api.acedata.cloud/serp/google \
  -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
  -d '{"query":"OpenAI Sora release date","type":"search","number":3}'
```

Gets real-time Google results (excerpt):

```text theme={null}
- Sora is here — OpenAI                       https://openai.com/index/sora-is-here/
- Sora (text-to-video model) — Wikipedia
- What to know about the Sora discontinuation — OpenAI Help
```

**③ LLM conversation (synchronous, one API for 50+ models)**

```bash theme={null}
curl -X POST https://api.acedata.cloud/v1/chat/completions \
  -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
  -d '{"model":"gpt-4.1-mini","messages":[{"role":"user","content":"Explain MCP in one sentence"}]}'
```

```text theme={null}
MCP is a protocol for centrally managing and exchanging model context information.
(39 tokens, approximately 0.00007 credit this time)
```

**④ Image generation (asynchronous, about 20 seconds, the agent automatically polls until the image is generated)**

```bash theme={null}
curl -X POST https://api.acedata.cloud/nano-banana/images \
  -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
  -d '{"action":"generate","model":"nano-banana",
       "prompt":"a cute cartoon banana mascot waving hello, flat vector logo, white background"}'
```

After about 22 seconds, it returns a real image (HTTP 200 · image/png · 317 KB · approximately 0.13 credit this time):

![An image actually generated by AceKit](https://cdn.acedata.cloud/assets/examples/nanobanana/957be0ef-5eaf-49cb-b3ed-3268e506db6e-130096c7ecec.png)

You do not actually need to remember these APIs—after installing the skills, the agent will assemble the correct requests itself according to each `SKILL.md`, and handle authentication and polling. The above only lays out for you "what it does behind the scenes."

## What Exactly Does It Install

AceKit is the "front door" to AceData's entire developer tool surface. At present, a single installation installs the **skill toolkit (Skills)**:

* **A set of Agent skills**: each skill is a pre-written `SKILL.md` operation manual—authentication, asynchronous polling, error retries, and how to fill in parameters are all clearly documented; the agent only needs to follow it. Run `npx acekit list` to see the current list (there are 19 at the time of writing, and it continues to grow):

```text theme={null}
acedatacloud-api   ai-chat            face-transform     fish-audio
flux-image         google-search      hailuo-video       kling-video
luma-video         midjourney-image   nano-banana-image  producer-music
seedance-video     seedream-image     short-url          sora-video
suno-music         veo-video          wan-video
```

* **One unified Token**: One `ACEDATACLOUD_API_TOKEN` unlocks all capabilities, billed based on actual usage.

Classified by capability (subject to `npx acekit list`):

| Type | Providers |
| - | - |
| 🖼️ Image Generation | Midjourney · Flux · Seedream · NanoBanana |
| 🎬 Video Generation | Sora · Veo · Kling · Luma · Hailuo · Seedance · Wan |
| 🎵 Music / Audio Generation | Suno · Producer · Fish Audio（TTS） |
| 💬 LLM Chat | Unified interface for 50+ models（GPT · Claude · Gemini · DeepSeek · Grok…） |
| 🔎 Search | Google SERP（Web · Images · News · Maps · Videos） |
| 🔗 Tools | Short URLs · Face Processing |

> For these same capabilities, AceData also provides standalone **MCP servers** (Suno, Midjourney, Sora, SERP… published to PyPI / VS Code / Smithery / Docker), **command-line CLI**, and **Python / TypeScript SDK**, which can be used separately as needed. AceKit v0.2 plans to support single-capability installation via `acekit add <name>`, as well as automatically writing MCP configurations for each agent.

## Which Agents Are Supported

| Agent | Skill Installation Location |
| - | - |
| Claude Code | `~/.claude/skills` |
| Codex CLI | `~/.agents/skills` |
| Cursor / Gemini / OpenCode, etc. | `~/.agents/skills`（point your agent here） |

During installation, AceKit automatically detects the agents installed on the machine and installs only into the detected ones.

## Easter Egg: Use the Same Token to Power Claude Code Itself

AceData's interface is also compatible with Anthropic's `/v1/messages` format, so you **do not need an official Anthropic subscription**. You can use the same AceData Token to power Claude Code. Create `.claude/settings.local.json` in the project root directory:

```json theme={null}
{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "你的token",
    "ANTHROPIC_BASE_URL": "https://api.acedata.cloud"
  }
}
```

Simply restart Claude Code—it can use the full Claude model lineup while also gaining the "hands" to generate images, videos, and music through AceKit. For more details, see the [Claude Code Integration Guide](https://platform.acedata.cloud/documents/claude-code-integration).

## Start for Free

AceKit is open source (MIT), with the repository at [github.com/AceDataCloud/AceKit](https://github.com/AceDataCloud/AceKit). If you find it useful, please give it a ⭐.

* 🔑 Free API Key & Documentation: [https://platform.acedata.cloud](https://platform.acedata.cloud)
* 💬 Discord: [https://discord.gg/f9GRuKCmRc](https://discord.gg/f9GRuKCmRc)
* 🐦 X: [@acedatacloud](https://x.com/acedatacloud)
* 📧 Email: [office@acedata.cloud](mailto:office@acedata.cloud)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.