Overview

Start with the job you need to get done.

Most teams begin by putting the widget in their product. From there you can add audience rules, recurring schedules, AI-assisted drafts, signing, and API automation when you need them. Use the guide that matches your next step.

What Chainlog helps you do

One system to collect product changes, turn them into readable updates, publish them where users already are, and keep the workflow consistent as the stakes rise.

Create a customer-facing source of truth

Start with a hosted changelog or widget so release communication stops living in scattered docs, tickets, and support replies.

Keep updates and docs inside the product

The same runtime can power a launcher, panel, inline widget, or contextual docs surface, so users do not have to leave your app.

Add automation, AI, and proof when needed

Layer in schedules, AI draft workflows, MCP, webhooks, analytics, and signing as communication becomes more operational.

Start from your role

Pick the path that matches the job you own. You do not need to understand the whole product first.

Product and release owners

Turn launches and changes into clear customer-facing updates on a repeatable cadence.

Open API and automation

Frontend and platform engineers

Keep updates and docs inside the product with the widget, targeting, and runtime behavior.

Open quickstart

Automation and AI builders

Wire schedules, AI drafts, MCP clients, webhooks, or server-side publishing into existing workflows.

Open API and automation

Support, success, and trust teams

Explain what shipped, prove what changed, or give customers a stable source of truth.

Open signing guide

Choose your path

Each guide is organized around a job to be done, not around internal terminology.

Start with the right guide

Pick the guide that matches the job you need to get done.

Get the widget live

Best starting point if you want release notes inside your product with the fewest moving parts.

Understand the model

Learn the handful of terms that make the rest of the docs easier to follow.

See the full widget reference

Use this when the widget is already live and you need runtime options, methods, events, or layout details.

Control who sees what

Learn the simple token setup first, then add audience rules only when you actually need them.

Use a framework example

Pick the example closest to your stack instead of translating the runtime docs from scratch.

Automate publishing and recurring work

Use the API, schedules, webhooks, and signing when work needs to happen outside the widget.

Automate AI-generated drafts

Let Chainlog watch your synced artifacts and produce release-note drafts on a daily, weekly, monthly, or quarterly cadence.

Start from a recipe

Go straight to working examples for common jobs like CI publishing, inline embeds, and custom domains.

Minimal production example

For most teams, this is the fastest safe path: load the widget once, then ask your backend for a short-lived token when the widget needs one.

1. Queue stub + loader

<script>
  window.ChainlogWidget = window.ChainlogWidget || {
    _q: [],
    init: function(config) { this._q.push({ method: "init", config: config }); },
    update: function(config) { this._q.push({ method: "update", config: config }); },
    destroy: function() { this._q.push({ method: "destroy" }); },
    open: function() { this._q.push({ method: "open" }); },
    close: function() { this._q.push({ method: "close" }); },
    toggle: function() { this._q.push({ method: "toggle" }); }
  };
</script>
<script async src="https://chainlog.tech/widget.js"></script>

2. Minimal init call

window.ChainlogWidget.init({
  tenantId: "CHAINLOG_TENANT_ID",
  useTenantDefaults: true,
  tokenProvider: async () => {
    const response = await fetch("/api/widget-token", {
      credentials: "include",
    });

    const { token, expiresInSeconds } = await response.json();
    return { token, expiresInSeconds };
  },
});

Why this shape is the default

Your browser never receives your long-lived widget secret. Your backend creates a short-lived JWT instead, and the widget refreshes it through tokenProvider when needed.