How to Use Ace Data Cloud as an OpenAI-Compatible Provider in ChatBox

Sometimes you do not need to build a full chat UI from scratch; you just need a reliable desktop or web client where you can plug in your own OpenAI-compatible endpoint and start testing models.

This guide walks through configuring Ace Data Cloud inside ChatBox, then verifying the setup with a direct API call so you can separate “client configuration problem” from “endpoint or token problem.”

What you can do

ChatBox is an open-source AI client that runs on Windows, macOS, Linux, iOS, Android, and the web. It supports custom providers in an OpenAI API Compatible mode, which makes it a useful client for testing an OpenAI-compatible chat endpoint without writing frontend code first.

For Ace Data Cloud, the important configuration values are:

ChatBox field	Value
API Mode	OpenAI API Compatible
API Key	your Ace Data Cloud token
API Host	https://api.acedata.cloud
API Path	/v1/chat/completions

The small but important detail is that the host and path are separate fields. ChatBox builds the final request as {API Host} + {API Path}, so the correct final request becomes:

https://api.acedata.cloud/v1/chat/completions

Do not put /openai or /v1 into the API Host. The documentation calls out two common broken combinations:

https://api.acedata.cloud/openai/v1/chat/completions
https://api.acedata.cloud/openai/v1/v1/chat/completions

Both are wrong because ChatBox will concatenate the host and path for you.

How it works

The setup flow is simple:

1. Get an Ace Data Cloud API token from the console.
2. Open ChatBox.
3. Go to Settings → Models → Add Custom Provider.
4. Set API Mode to OpenAI API Compatible.
5. Fill in API Host as https://api.acedata.cloud.
6. Fill in API Path as /v1/chat/completions.
7. Add one or more model IDs in the custom models box.
8. Save, pick the model from the ChatBox dropdown, and send a test message.

ChatBox does not automatically call the model list endpoint. If you do not see any models in the dropdown, that does not necessarily mean the API key or network is broken. It usually means you still need to manually enter model IDs in the Custom Models input box, one model per line.

When manual entry is required, first query the model list endpoint:

GET https://api.acedata.cloud/v1/models

Then choose model IDs according to the capabilities you need and what ChatBox can use in its current UI.

Verify the endpoint before debugging the app

Before spending time inside client settings, I like to verify the same endpoint directly with curl. This gives you a quick yes-or-no answer about the token and base URL.

Use this request, replacing {token} and MODEL_ID with your actual values:

curl -X POST 'https://api.acedata.cloud/v1/chat/completions' \
  -H 'Authorization: Bearer {token}' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "MODEL_ID",
    "messages": [{"role": "user", "content": "ping"}]
  }'

If the request succeeds, you should receive an OpenAI-compatible chat.completion object. At that point, the endpoint and token are basically ready, and any remaining problem is more likely to be in ChatBox configuration: wrong host, wrong path, missing model ID, or an unsupported model capability toggle.

This is also why I recommend keeping the curl command in your project notes. It is the fastest regression test when someone changes a token, rotates credentials, switches machines, or edits the provider configuration.

Avoid the most common path mistake

The most common failure is a 404 Not Found caused by putting too much into the API Host field.

Use this:

API Host: https://api.acedata.cloud
API Path: /v1/chat/completions

Not this:

API Host: https://api.acedata.cloud/openai

And not this:

API Host: https://api.acedata.cloud/openai/v1

The reason is mechanical: ChatBox appends the path to the host. If the host already contains extra path segments, the final URL becomes something the server does not expose.

Add models intentionally

The documentation notes that ChatBox does not automatically call /v1/models, so model setup is manual. That is a good moment to be deliberate instead of pasting a random list.

A practical approach:

• Add one general-purpose chat model first.
• Send the ping test.
• Only then add additional model IDs for different use cases.
• Fill in capability toggles, context window, and output limit according to the current contract of the selected model.

The last point matters. Do not copy context-window or output-limit values from another model just because it worked elsewhere. Treat those fields as model-specific configuration.

Understand the error signals

If ChatBox says the request failed, reproduce the request with curl and interpret the result:

• 404 Not Found: usually the API Host contains /openai or /v1 when it should only be https://api.acedata.cloud.
• 401 or token_mismatched: check that the API Key field contains the token only, without a Bearer prefix and without extra spaces.
• HTTP 403 used_up: the token is valid, but the application balance is insufficient.
• No models in the dropdown: add model IDs manually in the Custom Models box and save.

These checks are not glamorous, but they save time. Most integration failures in OpenAI-compatible clients come down to URL composition, authentication formatting, or model selection.

What this does not configure

One useful boundary from the docs: ChatBox's chat path is /v1/chat/completions. Ace Data Cloud image generation uses a separate Images API path, /openai/images/generations, and ChatBox's image entry cannot directly integrate with that path. If you need image generation, call the Images API separately with curl or an SDK rather than expecting it to work through the same chat configuration.

Final checklist

Before you call the setup done, verify this checklist:

• API Mode is OpenAI API Compatible.
• API Host is exactly https://api.acedata.cloud.
• API Path is exactly /v1/chat/completions.
• The API Key field contains the token without Bearer.
• At least one MODEL_ID has been entered manually.
• The same token and model work with the curl test.

Once those are true, ChatBox becomes a convenient everyday client for testing OpenAI-compatible chat models while keeping the underlying API endpoint explicit and debuggable.

Full reference: https://platform.acedata.cloud/documents/development_chatbox