DEV Community

Germey
Germey

Posted on Edited on

Build an AI API Site You Can Monetize: Custom Domain Launch Checks

A branded AI API portal needs two different network entry points: one for people and one for software. Treating them as interchangeable is a reliable way to produce broken documentation, confusing login redirects, or requests sent to a website instead of an API.

This tutorial explains a launch-gate workflow for custom domains on an Ace Data Cloud White Label API Platform. It is an independently rewritten, AI-assisted guide based on Ace Data Cloud’s public documentation. Ace Data Cloud is the product discussed here; this is commercial educational content, not a claim that I created a tenant, changed DNS, made customer purchases, or earned revenue while writing it.

Scope: configuration and verification only. Use placeholder domains below and obtain real DNS targets from your own console.

Start with two explicit domain roles

Use separate subdomains under one brand:

Address Consumer Responsibility
portal.example.com Browser Homepage, catalog, pricing, docs, login, console, and support
api.example.com Application API Base URL used by customer code

The shared brand does not make these addresses interchangeable. Do not put an API Base URL into a browser onboarding instruction, and do not send application requests to the page domain.

A custom API domain is also a branded entry point—not a separately delivered gateway, independent tenant identity system, or automatic credential-isolation mechanism. Authentication and billing still use the platform’s unified systems. Customers should use their own accounts and API keys.

Establish a known-good baseline

Before touching DNS, open the system-provided site URL in a private browser window. Check that the homepage, service catalog, documentation, login, and support path work.

This baseline separates application configuration from DNS problems. If the origin works but the custom domain does not, investigate binding, DNS, or certificate state. If both fail, changing CNAME records is unlikely to repair the site configuration.

Basic portal creation may take only a few minutes when you are already signed in and have a site name and prefix ready. That estimate should not include DNS propagation, HTTPS certificate readiness, documentation review, customer acquisition, purchases, or settlement.

Bind each domain in its own console section

Open Site Management, select the site, and go to Custom Domain. The page domain and API domain have separate controls.

For each section:

  1. Enter the complete hostname without https:// or a path.
  2. Select Bind Domain in that same section.
  3. Copy the CNAME target shown for that domain role.
  4. Add the record at your DNS provider.
  5. Return to the console and refresh or verify until both domain and HTTPS status are ready.

Custom-domain screen showing page-domain binding and status controls

A DNS plan might look like this:

Type   Host     Value
CNAME  portal   <PAGE_TARGET_FROM_YOUR_CONSOLE>
CNAME  api      <API_TARGET_FROM_YOUR_CONSOLE>
Enter fullscreen mode Exit fullscreen mode

Never copy a target from a screenshot, another tenant, or a tutorial. The page and API targets may differ; the current values in your own console are authoritative.

Before adding a CNAME, inspect existing records for that hostname. A pre-existing A, AAAA, or CNAME record may support another application. If its purpose is uncertain, choose an unused subdomain rather than deleting production DNS.

Treat DNS and HTTPS as separate gates

A resolvable CNAME does not prove that the TLS certificate is ready. Avoid promising a fixed completion time for DNS propagation or certificate issuance.

Use a small verification sheet:

[ ] portal.example.com resolves to the console-provided page target
[ ] api.example.com resolves to the console-provided API target
[ ] portal.example.com has a valid HTTPS certificate
[ ] api.example.com has a valid HTTPS certificate
[ ] both hosts are marked active in Site Management
Enter fullscreen mode Exit fullscreen mode

Do not start paid acceptance requests while domain or HTTPS state is incomplete. First validate resolution and certificates with non-billable checks.

Verify the browser path

Open https://portal.example.com in a private window and test:

  • homepage, service catalog, pricing, docs, and support;
  • a documentation deep link followed by a hard refresh;
  • login and the post-login return URL;
  • title, logo, and favicon;
  • terms and privacy pages.

A custom domain that renders the wrong site is not successful merely because HTTPS works. Confirm that the domain is bound to the intended Site.

White-label authentication uses a shared identity system rather than a separate user database per portal. An existing account signing in through a new portal is therefore not equivalent to a newly attributed customer.

Verify the programmatic path

After https://api.example.com is active, inspect generated examples and default documentation. Their Base URL should use the custom API host.

Custom Markdown may not be rewritten automatically, so search your documentation repository or CMS content for stale public hosts. A practical release check is:

# Illustration only: point this at your exported docs or source tree.
grep -R "OLD_API_HOST" ./docs
Enter fullscreen mode Exit fullscreen mode

Then use a test customer’s own key and copy the smallest request from the selected service’s current documentation. Do not invent a universal SDK or endpoint. Native APIs, OpenAI-compatible protocols, and MCP connections can require different paths and payloads.

Acceptance requires more than an HTTP response:

  1. the request reaches the intended service through the custom API host;
  2. the result completes, including status polling for asynchronous tasks;
  3. the customer console shows a matching usage record and balance change.

For diagnosis, record the timestamp, path, status code, and a safe request identifier. Never place a real key in screenshots, public docs, source control, or support tickets.

Diagnose by symptom, not guesswork

Symptom First checks
Page domain opens another site Site binding and page-domain CNAME
HTTPS warning Public DNS and certificate status
API returns 401 Customer key, path, scope, and balance—not DNS alone
Generated docs show public host API-domain activation and refreshed site configuration
Handwritten docs show old host Update custom Markdown manually

Catalog visibility is not authorization. Hiding a service does not necessarily block a valid unrestricted key. Apply credential/API scope controls where available and verify them separately.

Keep monetization claims tied to orders

A branded domain can improve trust and customer onboarding, but it does not guarantee income. Earnings depend on attributable customers, valid completed purchases, and current distribution rules. Refunds, risk controls, order status, settlement timing, and other adjustments may affect the final record. A configured markup changes channel pricing; it should not be represented as guaranteed profit or as a commission paid for every API call.

For a commercial launch, reconcile customer orders and distribution records separately from technical usage records.

Final release gate

Ship only when the page domain serves the correct portal, deep links survive refresh, login returns correctly, the API domain has valid HTTPS, documentation contains the correct Base URL, and one minimum-cost request matches one customer usage record.

Further reading: page and API domain setup, building a White Label API Platform, and customer registration and key delivery.

Top comments (0)