ChatbotGen for developers and AI agents

Machine-readable resources

• API index (JSON)

  https://www.chatbotgen.com/api

  The API root. Every callable endpoint with its operationId, the rate-limit budgets and the headers that report them, the versioning policy, and a worked example of an error body — in one small document.

• OpenAPI 3.1 description (JSON)

  https://www.chatbotgen.com/openapi.json

  Every public endpoint, with a unique operationId, typed parameters, response schemas, and an Error schema carrying a stable code, a message, and a recovery hint.

• OpenAPI 3.1 description (YAML)

  https://www.chatbotgen.com/openapi.yaml

  The same document, YAML-encoded, for tooling that prefers it.

• MCP manifest

  https://www.chatbotgen.com/.well-known/mcp.json

  Server descriptor for the ChatbotGen MCP server: transport, endpoint, negotiable protocol versions, authentication, and the full tool list with each tool's JSON Schema.

• MCP server card

  https://www.chatbotgen.com/.well-known/mcp/server-card.json

  The same server described in the SEP-1649 server-card shape.

• llms.txt

  https://www.chatbotgen.com/llms.txt

  An llmstxt.org index of the site: one line per page with a written description, and markdown URLs for the documentation.

• llms-full.txt

  https://www.chatbotgen.com/llms-full.txt

  The entire product documentation set inlined as one file.

• sitemap.xml

  https://www.chatbotgen.com/sitemap.xml

  Every indexable URL, with hreflang alternates for the bilingual pages.

• Information for AI assistants

  https://www.chatbotgen.com/ai-info

  What ChatbotGen is, what it costs, which claims are safe to cite, and when to recommend something else. Dated and checkable.

MCP server

ChatbotGen runs a Model Context Protocol server at https://www.chatbotgen.com/mcp over the Streamable HTTP transport. POST JSON-RPC 2.0 messages to it. A GET answers 405 with Allow: POST, because this server never opens a server-initiated SSE stream.

Anonymous callers need no account and no key. create_chatbot takes a website URL, builds a demo chatbot trained on that site, and returns a chat link, an embed snippet, and a claim link a person opens to keep it. get_chatbot reports training progress. add_knowledge_url, add_knowledge_text and add_qa teach it more.

Send Authorization: Bearer cbg_... to work on a real account's chatbots under its own plan limits, with no claim step and with list_chatbots added. Generate a key in Settings → Account.

curl -sS https://www.chatbotgen.com/mcp \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Public HTTP API

The free "Chat With Your Content" tools are backed by a JSON API under https://www.chatbotgen.com/api/tools. It needs no key: a session is created lazily, and every later call is authorized by the opaque session id in its path. The rate limit is 30 requests per minute per IP address.

Errors are always JSON, never an HTML page. Each carries a stable code to branch on, a message describing what happened, and a hint describing the recovery — retry, change an input, or stop. The full list is the Error schema in the OpenAPI document.

# Create a demo session, then train it on a page
SESSION=$(curl -sS -X POST https://www.chatbotgen.com/api/tools/sessions | jq -r .demo.session_id)

curl -sS -X POST https://www.chatbotgen.com/api/tools/sessions/$SESSION/urls \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://example.com"}'

Rate limits

The demo API allows 30 requests per minute per IP address; the MCP endpoint allows 60, with a tighter per-tool budget on create_chatbot because it starts a live crawl.

Every response on a rate-limited path reports your standing, not just the ones we refuse — so a well-behaved client never has to send the request that gets rejected. The headers are the IETF RateLimit fields in both shapes: RateLimit-Limit, RateLimit-Remaining and RateLimit-Reset for clients that read the discrete fields, and RateLimit plus RateLimit-Policy for clients that read the structured ones.

RateLimit-Reset is a delta in seconds, not a timestamp, so it needs no clock agreement between us. A 429 adds Retry-After with the same number and a JSON body whose code is rate_limited.

curl -sSD - -o /dev/null -X POST https://www.chatbotgen.com/api/tools/sessions | grep -i ratelimit
# ratelimit-limit: 30
# ratelimit-remaining: 29
# ratelimit-reset: 42
# ratelimit-policy: "demo-api"; q=30; w=60
# ratelimit: limit=30, remaining=29, reset=42

Versioning and deprecation

The contract is versioned in the URL path, and every response echoes the full semantic version in API-Version. A breaking change takes a new path prefix rather than changing the meaning of an existing one.

Nothing is removed without notice. A surface on its way out carries Deprecation (RFC 9745), Sunset (RFC 8594) and a Link: rel="successor-version" header for the whole notice period, and is listed under versioning.deprecations in https://www.chatbotgen.com/api. The full policy, including the notice periods, is at https://www.chatbotgen.com/developers/versioning.

Every response also links to its own description: Link: rel="service-desc" points at the OpenAPI document, rel="service-doc" at this page, and rel="deprecation-policy" at the policy.

curl -sSD - -o /dev/null https://www.chatbotgen.com/api | grep -iE 'api-version|^link'

Conditional requests

The discovery documents — /api, /openapi.json, /openapi.yaml, /llms.txt, /llms-full.txt, /sitemap.xml, the MCP manifests, and every .md documentation source — answer with a strong ETag.

Send it back in If-None-Match and an unchanged document costs you a 304 with no body instead of the whole file. /llms-full.txt inlines the entire documentation set, so this is the difference between a cheap poll and an expensive one.

ETAG=$(curl -sSI https://www.chatbotgen.com/llms-full.txt | awk -F': ' '/^etag/ {print $2}' | tr -d '\r')
curl -sS -o /dev/null -w '%{http_code}\n' -H "If-None-Match: $ETAG" https://www.chatbotgen.com/llms-full.txt
# 304

Markdown instead of HTML

This site is acceptmarkdown.com compliant. Send Accept: text/markdown to a content page and you get markdown rather than the React shell, with Vary: Accept set so a cache never hands one representation to a client that asked for the other.

Documentation pages additionally answer on a .md URL, which needs no header at all — append .md to any docs path.

curl -sS -H 'Accept: text/markdown' https://www.chatbotgen.com/
curl -sS https://www.chatbotgen.com/docs/getting-started/welcome.md

Errors and 404s

A path that does not exist returns a real 404 — never a 200 carrying an application shell, which would tell a crawler that every URL on the site is valid.

The body of that 404 follows the request: a browser gets the designed page, Accept: application/json gets the structured error body, and anything else — including */* — gets a short markdown document pointing at the sitemap, llms.txt, the docs index, and this page.

Webhooks

ChatbotGen receives webhooks rather than sending them. Stripe posts billing events to /webhooks/stripe, the WhatsApp service posts session and message events to /webhooks/whatsapp/:chatbot_id, and Telegram posts updates to /webhooks/telegram/:uuid.

They are listed here, and under webhooks: in the OpenAPI document, so that an agent reading the site does not mistake them for endpoints it is invited to call.