Quickstart

This walkthrough takes you from an existing app to a live Syncanix assistant, in the order you actually do it: add the snippet, map your site, then publish the guides it drafts from what it found. Review and go live sit either side of that. Two steps are optional and marked as such — a deeper scan of your code, and connecting your backend directly.

Before you start

• A Syncanix workspace — talk to our sales team at syncanix.com/contact to get set up.
• Node.js 20 or newer.
• An existing HTTP API with at least one authenticated endpoint.
• An identity provider for your users — Auth0, Clerk, Cognito, WorkOS, or your own OIDC.
• An Anthropic, OpenAI, or AWS Bedrock-EU key — or use managed model access, which is included in your plan.

1. Set up your workspace and keys

The discovery CLI uploads into a Syncanix workspace, and the widget authenticates with a publishable key — so create the workspace and grab both keys before you run anything.

1. 1
   Get your workspaceTalk to our sales team at syncanix.com/contact to get your workspace set up. The dashboard is where your catalog, API keys, and widget configuration live.
2. 2
   Sign in from the CLIRun npx syncanix login — your browser opens the dashboard to approve this device, and the CLI stores a session tied to your account in ~/.syncanix/credentials so init can upload your catalog. Headless machine? Run npx syncanix login --key and paste a machine key from Settings → API keys.
3. 3
   Copy your publishable keyFrom Settings → API keys in the dashboard, copy your publishable key (pk_live_…). The widget embed snippet uses it as its data-key — it is safe to ship in the browser.

npx syncanix login

2. Embed the widget

Add one script tag to your app, using your publishable key. This is the whole install — there is no package to add and no code to change.

<script
  type="module"
  src="https://cdn.syncanix.com/widget.js"
  data-key="pk_live_..."
></script>

That’s it. The widget loads lazily, runs inside a Shadow DOM so your styles and ours never collide, picks up your brand automatically, and is right-to-left ready.

3. Let it read your product

With the widget on the page, the agent works out what your product can do by looking at it. There are two ways this happens, and you do not have to choose — the first is deliberate and fast, the second runs quietly from then on.

1. 1
   Map your site, in one passStart mapping from the dashboard and click through your own product in your own browser, signed in as yourself. It writes down each screen as you go. Nothing is sent from anywhere but the tab you are in.
2. 2
   Then continuously, as your users move aroundOnce live, it keeps reading the screens people actually visit, so a page you ship on Tuesday is known about on Tuesday. Nobody files a ticket to teach it.

4. Review what it found

Open the dashboard to see what was discovered. This is where you decide what the assistant can do, and how carefully:

• Mark internal endpoints so they stay out of the assistant’s reach.
• Set each action’s side effect — read, write, or destructive — which controls how it is confirmed.
• Require step-up authentication on sensitive actions, so the user re-confirms their identity before they run.

5. Optional: read your source for the exact shapes

Reading a screen tells the agent what a person can do there. Reading your source tells it exactly what your software accepts — the parameter names, the types, what is required — and finds capabilities nobody has visited yet. It is the deeper path, not the harder one: no source files leave your machine. Run it from your repository:

npx syncanix init

6. Optional: connect your backend

When you do add it, install the SDK for the service that owns your API. It boots in a few milliseconds and keeps your catalog fresh with runtime drift detection:

npm install @syncanix/sdk-node

import { init } from '@syncanix/sdk-node';

// Resolves your API key from SYNCANIX_API_KEY, ~/.syncanix/credentials,
// or an inline { apiKey } — in that order.
const { environment, bootDurationMs } = await init({ environment: 'development' });
console.log(`Syncanix booted in ${bootDurationMs.toFixed(1)}ms`);

You can also register SDK-native tools — actions the assistant can call that aren’t plain HTTP routes. Each runs with the end user’s identity, supplied by your identity provider:

import { createToolRegistry } from '@syncanix/sdk-node';

const registry = createToolRegistry();

registry.tool({
  name: 'refund-order',
  description: 'Refund a customer order. Requires an admin role.',
  handler: async ({ orderId, amountCents }, ctx) => {
    // ctx.userId is the verified end user from your identity provider.
    return payments.refund({ orderId, amountCents, actor: ctx.userId });
  },
});

7. Connect an AI client

Each workspace also gets its own MCP server, so your users can reach the same capabilities from Claude Desktop, Cursor, and ChatGPT. Sign-in federates to your identity provider.

8. Go live

When you’re happy with how the assistant behaves in development, promote it to production from the dashboard. An evaluation gate runs first and blocks the promote if quality regresses, so production only ever changes for the better.

What you have now

• An embedded assistant in your app that answers questions and runs your actions.
• A per-workspace MCP server for Claude Desktop, Cursor, and ChatGPT.
• An audit trail of every action, promote, and admin change.
• Everything hosted in the EU, with your data encrypted at rest.

Next steps