# Guide for AI agents: set up and run Esign Comply for your person

> Your person signs up once. Then you, the AI agent, create keys, register documents, verify the domain and go live. Every step with its URL and labels.

Source: https://esigncomply.com/agents

For AI agents

You are an AI agent working for a person, in a browser or through an API. Your person creates the account and accepts the terms once. After that you do everything: create keys, register documents, build the flow, verify the domain, go live. This page gives every task with its address, the exact labels on screen, what the page says when the step worked, and what to do when it did not.

[This page as Markdown](https://esigncomply.com/agents.md)

## The handoff in three steps

What to tell your person, in their words: You create the account and accept the terms once. After that your AI agent can do everything: create keys, register documents, build the flow, verify the domain, go live.

1. **Your person signs up.** Give them `https://esigncomply.com/signup?next=/dashboard/agent`. They enter their email, tick one box and type the 6-digit code from their inbox. No card.
2. **You get an agent token.** Sign-up ends on the page **Agent access**. Press **Create agent token** yourself when you are driving their logged-in browser. Otherwise they press it and paste you the token. Keep it in `ESIGNCOMPLY_AGENT_TOKEN`.
3. **You do the rest.** In your own browser at `https://esigncomply.com/agent-login`, or without a browser through `https://esigncomply.com/v1/agent`.

How to read this page: text in bold is a label exactly as it is on screen. Text in quotation marks is what a page says. Addresses and values to type are set as code. In the dashboard, a field's accessible name starts with its label and can continue with a hint sentence, so match a field by the start of its name.

Every task, in a browser and without one

| Task | In a browser | Without a browser |
| --- | --- | --- |
| Create the account | Your person, at `/signup` | Your person |
| Get an agent token | `/dashboard/agent`, button **Create agent token** | Your person pastes it to you |
| Log in | `/agent-login`, field **Agent token** | `GET /v1/agent` |
| Create a test key | `/dashboard`, button **Create test key** | `POST /v1/agent/api-keys` |
| First API call | Not a browser task | `GET /v1/usage` |
| Register a document | `/dashboard/documents` | `POST /v1/documents` |
| Create a profile | `/dashboard/profiles` | `POST /v1/profiles` |
| Generate the build prompt | `/dashboard/prompts` | `POST /v1/prompts/generate` |
| Make it the project's rule | Not a browser task | The block at `/rules.md` |
| Convert existing flows | Not a browser task | In the project's code |
| Check conformance | `/dashboard/conformance` | `npx esigncomply check` |
| Verify the domain | `/dashboard/domains` | `PUT /v1/agent/domain`, then `POST /v1/agent/domain/verify` |
| Go live on Free, live key | `/dashboard/go-live` | `POST /v1/agent/go-live` |
| Watch usage | `/dashboard/settings/usage` | `GET /v1/usage` or `GET /v1/agent` |
| Webhooks | `/dashboard/webhooks` | `POST /v1/webhooks` |
| Records and evidence | `/dashboard/records` | `GET /v1/records` |
| Team and settings | `/dashboard/settings` | Organization details through the go-live call |

## What stays with your person

These steps need the account owner in person. Everything else that their role allows is yours.

- Creating the account: the email, the acceptance of the terms, and the 6-digit code from their inbox.
- Accepting legal terms or signing anything for the organization.
- Sign-in security: second factors.
- Creating agent tokens. You can revoke your own.
- Team members and roles.
- Billing and plan changes.

The server enforces these for every agent session, whatever the page shows. A refusal reads "This step needs the account owner in person. An agent session cannot do it. Ask the person to log in at /login and do it themselves." Tell your person which step it was and carry on with the rest.

One more case: when your person has a second factor on their account, the actions it protects need them too. Those are the form on the API keys page, revoking a key, changing a registered domain, exports, erasure and adoption. The test key on **Get started** and the live key on **Go live** stay yours.

## Start: the account, the token, the log-in

### Create the account: your person's one step

Your person creates the account. You never tick the acceptance box and you never type the code for them. Give them this link. It ends on the page where they hand the dashboard to you.

```
https://esigncomply.com/signup?next=/dashboard/agent
```

Add `&email=name@company.com` to fill the email field for them. Before they tick the box, show them these two links and get their go-ahead: the **Terms of Service** at `https://esigncomply.com/legal/terms` and the **Data Processing Agreement** at `https://esigncomply.com/legal/dpa`. The box also covers the **Acceptable Use Policy** and the **Privacy Notice**, and each of the four has a download link beside the box.

#### What your person does

URL: `https://esigncomply.com/signup?next=/dashboard/agent`

1. Field **Email**. A status line under the box reads "Waiting for your email address. The checkbox unlocks when the address is valid."
2. The status line changes to "Preparing the acceptance record. The checkbox unlocks in a few seconds." and then to "The checkbox is unlocked. Tick it to accept the documents."
3. The checkbox, labelled "By checking the box and clicking Create account, you agree to the Terms of Service, the Acceptable Use Policy and the Data Processing Agreement, and acknowledge the Privacy Notice." They tick it. The status line reads "Ready. Click Create account."
4. Button **Create account**.
5. Page **Check your email**: field **Code**, button **Continue**. The code has 6 digits and arrives at their address. They read it from their inbox. **Send a new code** sends another one and replaces the earlier code.

**It worked when:** the browser opens `https://esigncomply.com/dashboard/agent` with the heading **Agent access**. No card was asked for.

**If it did not:** "That code is not valid or has expired. Use the newest email, or press Send a new code." means exactly that. An alert under the box comes with the button **Start over**: press it, wait for the box to unlock, and have your person tick it again.

#### When you are driving your person's browser

Open the link and type their email if they ask you to. Stop at the checkbox. The tick and the click on **Create account** are your person's own act. The page records whether the tick came from a real pointer or keyboard event, and an acceptance ticked by script (`element.click()` or setting `.checked`) is refused under rule `CR-01` with "The assent control was changed by a programmatic event, not by the user."

### Get an agent token

The token lets you act as your person, with their role, in their organization. It starts with `esc_agent_`, is 53 characters long and is shown once. Only its SHA-256 hash is stored.

#### You are driving your person's logged-in browser

URL: `https://esigncomply.com/dashboard/agent`

1. Field **Name**. It is filled with "My AI agent". The name is shown in the token list and in the audit log.
2. Field **Expires after**: "1 day", "7 days", "30 days" (selected) or "90 days".
3. Button **Create agent token**.
4. Read the token from the block headed **Agent token “My AI agent”**. It is on the page as text.

**It worked when:** a status line reads "Agent token “My AI agent” created. It is shown once, below." and the table **Tokens** lists it with the state "active".

**If it did not:** "This step needs the account owner in person. An agent session cannot do it." in place of the form means the browser is already in an agent session. A token cannot create another token. Ask your person to log in at `https://esigncomply.com/login` and press the button.

#### You have your own browser, or none

Ask your person to open `https://esigncomply.com/dashboard/agent`, press **Create agent token** and paste you the block headed **Paste this to your AI agent**. It holds the token, the log-in address and the first API call.

Keep the token in the environment variable `ESIGNCOMPLY_AGENT_TOKEN`. Never put it in client code, a URL, a log line or git. Your person can end your access at any time: in the table **Tokens**, button **Revoke**, then **Revoke token**. A revoked token is refused on your very next request, in the browser and through the API.

### Log in, and log in again later

#### In a browser

URL: `https://esigncomply.com/agent-login`

1. Field **Agent token**. Type or paste the whole token.
2. Button **Log in**.

**It worked when:** the dashboard opens and the sidebar shows "Agent session: My AI agent", with the name of your token. The session lasts as long as the token. Log in again the same way whenever you start with a fresh browser.

Messages of the agent log-in page and what to do

| The page says | What to do |
| --- | --- |
| "That is not a valid agent token. Paste the whole token: it starts with esc_agent\_ and is 53 characters long." | Paste the token again, complete and without spaces. |
| "This agent token has expired. Ask the account owner to create a new one under Agent access in the dashboard." | Ask your person for a new token. |
| "This agent token was revoked. Ask the account owner to create a new one under Agent access in the dashboard." | Ask your person for a new token. |
| "This agent session has ended: its token was revoked." | You were logged in and the token stopped working. Ask your person for a new token. |
| "Too many log-in attempts from this address. Wait five minutes and try again." | Wait five minutes. |

#### Without a browser

```bash
curl -s https://esigncomply.com/v1/agent \
  -H "Authorization: Bearer $ESIGNCOMPLY_AGENT_TOKEN"
```

A `200` with `"object": "agent_account"` means the token works. The response holds the organization, the domain with its DNS record, the plan, usage, `next_step` and the full list of `steps`, each with its API call and its dashboard page. Take `api_url` from it and use it as the base URL of every other API call. A `401` carries one of the messages in the table above.

#### How your person logs in

At `https://esigncomply.com/login`: field **Email**, button **Email me a code**, then field **Code** and button **Continue**. With a password: button **Use a password instead**, field **Password**, button **Log in**. `/login?email=name@company.com` fills the address and `/login?method=password` opens the password form. Someone who is already signed in goes straight to the dashboard.

## Build: keys, documents, profiles, the prompt

### Create a test key and store it as ESIGNCOMPLY_API_KEY

#### In a browser

URL: `https://esigncomply.com/dashboard`

1. On the page headed **Get started**, button **Create test key**.
2. Read the line `ESIGNCOMPLY_API_KEY=esc_test_…` from the page. It stays there until you press the next button.
3. Button **I have saved the key**.

**It worked when:** a status block reads "Test key “Onboarding” created. It is shown once, here:" followed by the key, and step 1 is marked "Done".

For a second key, or one with another permission: `https://esigncomply.com/dashboard/api-keys`, field **Name**, field **Permission** ("Recording access", "Full access", "Read only"), button **Create test key**. The page answers "Key “name” created." and shows the line with the key once.

#### Without a browser

```bash
curl -s -X POST https://esigncomply.com/v1/agent/api-keys \
  -H "Authorization: Bearer $ESIGNCOMPLY_AGENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "test" }'
```

The response carries the key once, in the field `key`.

Store the key on the server only, as `ESIGNCOMPLY_API_KEY`, and the `api_url` value from `GET /v1/agent` beside it as `ESIGNCOMPLY_API_URL`: in `.env.local` (listed in `.gitignore`) for development, and in the host's secret settings for deployments. Never give the variable a public prefix such as `NEXT_PUBLIC_` or `VITE_`. Test keys work on `localhost` and listed preview hosts before any domain is verified. The handling rules are in [/auth.md](https://esigncomply.com/auth.md).

### Make the first API call

```bash
curl -s "$ESIGNCOMPLY_API_URL/usage" \
  -H "Authorization: Bearer $ESIGNCOMPLY_API_KEY"
```

`ESIGNCOMPLY_API_URL` holds the `api_url` value from `GET /v1/agent`. Store it next to the key: the Node SDK and the CLI read the same variable.

**It worked when:** the answer is `200` with `"object": "usage"`.

**If it did not:** `401 invalid_api_key`: the variable is empty or holds another value. `421 region_mismatch`: use the `host` named in the error.

### Register a document and publish its text

#### In a browser

URL: `https://esigncomply.com/dashboard/documents`

1. Link **New document**.
2. Field **Name**, for example "Terms of Service". Group **Type**: "Terms", "Privacy notice", "NDA", "Contract", "Consent", "Policy acknowledgement" or "Custom".
3. Button **Create document**. The document's page opens.
4. Under **Publish a version**: fields **Version label** (filled with today's date), **Language**, **Format** and **Content**. Paste the text your person gave you into **Content**.
5. Button **Publish version**.

**It worked when:** a status line reads "Published version 2026-11-22 (en). Content hash sha256:…" with your label, language and hash.

#### Without a browser

```bash
curl -s "$ESIGNCOMPLY_API_URL/documents" \
  -H "Authorization: Bearer $ESIGNCOMPLY_API_KEY" -H "Content-Type: application/json" \
  -d '{ "name": "Terms of Service", "type": "terms" }'

curl -s "$ESIGNCOMPLY_API_URL/documents/doc_8Hq2/versions" \
  -H "Authorization: Bearer $ESIGNCOMPLY_API_KEY" -H "Content-Type: application/json" \
  -d '{ "version_label": "2026-11-22", "language": "en", "content": { "format": "markdown", "text": "# Terms of Service\n..." } }'
```

Publish the text your person gives you, unchanged. A published version cannot be edited: for new text, publish a new version label. Every record pins the exact version by hash.

### Create a profile

A profile says how one kind of signing works: the method, the assurance level and the rule packs. Ask your person which jurisdictions apply.

#### In a browser

URL: `https://esigncomply.com/dashboard/profiles`

1. Link **New profile**.
2. Field **Name**, for example "Signup".
3. Field **Signature method**: "Checkbox plus button (checkbox)" for acceptances, "Typed name (typed)" for NDAs and contracts. Field **Assurance level**: "L1 Recorded" or "L2 Verified".
4. Group **Enabled packs**: tick the packs that apply. "US-FED United States, Federal" is ticked.
5. Button **Create profile**.

**It worked when:** the profile's page opens with its name as the heading and its ID (`prof_…`) in the address.

#### Without a browser

```bash
curl -s "$ESIGNCOMPLY_API_URL/profiles" \
  -H "Authorization: Bearer $ESIGNCOMPLY_API_KEY" -H "Content-Type: application/json" \
  -d '{ "name": "Signup", "jurisdictions": ["US-FED"], "method": "checkbox", "assurance_level": "L1" }'
```

### Generate the build prompt

The prompt generator turns your selections into one prompt for your AI coding tool. It is assembled from reviewed blocks and the rule packs you enable, and the same selections always give the same text. It registers the documents and creates the profiles it names.

#### In a browser

URL: `https://esigncomply.com/dashboard/prompts`

1. Link **Generate a prompt**.
2. Work through the six sections: **1 Use cases**, **2 Signers**, **3 Jurisdiction packs**, **4 Assurance level and signature method**, **5 Stack and AI tool**, **6 Options**. Every field has a default.
3. Button **Generate prompt**.

**It worked when:** the page of the new prompt opens, with its ID (`esc_prompt_…`) in the address. The prompt is on the page as text in the region **Prompt**, with the button **Copy prompt** and the link **Download as .md**.

#### Without a browser

`POST /v1/prompts/generate` with a `full_access` key. The request body is in [the account API reference](https://esigncomply.com/docs/api/account.md).

Then follow the prompt. It carries the profile IDs, the document IDs and the rules for the selected packs, and it takes precedence over the general runbook at [/setup.md](https://esigncomply.com/setup.md) where the two differ.

### Make it the project's rule

Add the block from [/rules.md](https://esigncomply.com/rules.md) to the file your project's AI tools read for standing instructions: `AGENTS.md`, or `CLAUDE.md`, `.cursor/rules`, `.github/copilot-instructions.md` if the project already has one. Every later session then builds signing and acceptance flows through Esign Comply without being told again.

The block ends with a list of the flows in the app that use it. Add each flow you build or convert: its path, what is signed or accepted, and its profile ID. Keep that list current.

### Find and convert what the project already has

1. Search the project for every place where a person signs or accepts something: sign-up forms with a terms checkbox, checkout terms, NDA and contract pages, "I agree" buttons, consent prompts that gate an action, and columns such as `accepted_terms_at`, `tos_version` or `signature`.
2. Convert one flow at a time: register its document, create or choose its profile, move the flow onto a session, confirm the record on the server, run the conformance check, then add the flow to the list in the rules block.
3. Leave the acceptance data the project already holds in place. It is the project's history. New acceptances get records.
4. When a session is refused, the flow stops and tells the person. Never fall back to an acceptance with no record.

### Check conformance

```bash
npx esigncomply check --url http://localhost:3000/signup
```

The check runs your page at three window sizes and reads the test ceremony it records. Fix every finding marked `block`. Each finding names its rule (`CR-01` to `CR-28`), the measurement and a fix. The rules are in [the conformance reference](https://esigncomply.com/docs/conformance.md).

#### In a browser

URL: `https://esigncomply.com/dashboard/conformance`

The page lists findings by rule and by page for the test ceremonies recorded so far. Button **Copy for AI** copies the findings as Markdown. Under **Run check**, the button **Run check** reads the recorded ceremonies again and stores a run.

## Go live: the domain, the Free plan, the live key

### Verify the domain

Live keys work on a verified domain. One TXT record covers the domain and every subdomain.

#### In a browser

URL: `https://esigncomply.com/dashboard/domains`

1. Field **Host or URL**, for example `app.example.com`. A status line names the registrable domain it works out.
2. Button **Register domain**.
3. Under **Verification record**, read the record from the page: **Type** `TXT`, **Name (host)** `_esigncomply`, **Value** `esc-verify=…`, and the full record name `_esigncomply.example.com`.
4. Publish that TXT record at the DNS provider.
5. Button **Check now**.

**It worked when:** a status line reads "Found. example.com is verified."

**If it did not:** "Not found. At least one of the two resolvers did not return the expected value. DNS changes can take a few minutes to reach both." Wait a few minutes and press **Check now** again. The check also runs on its own: every minute for the first hour, then every 15 minutes for 72 hours.

#### Without a browser

```bash
curl -s -X PUT https://esigncomply.com/v1/agent/domain \
  -H "Authorization: Bearer $ESIGNCOMPLY_AGENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "domain": "app.example.com" }'

curl -s -X POST https://esigncomply.com/v1/agent/domain/verify \
  -H "Authorization: Bearer $ESIGNCOMPLY_AGENT_TOKEN"
```

The first call answers with `verification`: `type`, `name` and `value` of the TXT record. The second answers with `verified`: `true` or `false`.

DNS is the one practical limit. With access to the DNS provider, add the record yourself. Without it, give your person the type, the name and the value and ask them to add that one TXT record.

### Go live on the Free plan and create a live key

There is no plan to choose, no card and no checkout. The Terms of Service and the Data Processing Agreement were accepted at sign-up, so nothing is left to sign.

#### In a browser

URL: `https://esigncomply.com/dashboard/go-live`

1. **Verify your domain** shows "Done" once the domain is verified.
2. Under **Organization details**: fields **Legal name**, **Country**, **Registered address**, **City** and **Billing email**, then button **Save organization details**. Ask your person for these values. The legal name is printed on every evidence report.
3. **Terms and data-processing agreement** shows "Done" and "Nothing more to sign."
4. Under **Create a live key**: button **Create live key**. Read the line `ESIGNCOMPLY_API_KEY=esc_live_…` from the page.
5. Optional, under **Copy your test setup to live**: button **Copy test setup to live** copies documents with their versions, profiles and webhook endpoints. Test records are never copied.

**It worked when:** the live key is on the page and `https://esigncomply.com/dashboard/api-keys` lists a key with the environment "live".

**If it did not:** "Verify example.com first. Live keys only work on a verified domain." under **Create a live key** means the domain step is open. An account created before the Data Processing Agreement joined the sign-up acceptance shows a signing step under **Terms and data-processing agreement**: that step is your person's, and the page says "This step needs the account owner in person."

#### Without a browser

```bash
curl -s -X POST https://esigncomply.com/v1/agent/go-live \
  -H "Authorization: Bearer $ESIGNCOMPLY_AGENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "organization": { "legal_name": "Acme, Inc.", "country": "US", "line1": "1 Main Street", "city": "Wilmington", "billing_email": "billing@acme.example" } }'
```

The call saves the organization details and, when the domain is verified, creates the live key. A `201` carries it once in `api_key.key`. A second call answers `200` with `"created": false`. A refusal names the open step in `blocker` and `next_step`.

Store the live key as `ESIGNCOMPLY_API_KEY` in the production environment only. Development and previews keep the test key.

### Watch usage and tell your person in time

Free covers 10 live signatures a month. If you use all 10 in a month, the account locks until you upgrade to a paid plan. It does not unlock at the start of the next month. Past the limit, new live signatures can be refused, so upgrade before you get there.

Starter covers 2,000 live signature events a year. At 2,000 the account locks until you pay: upgrade to Unlimited, add an event pack, or renew. Past the limit, new live signatures can be refused, so upgrade before you get there.

Read the count whenever you finish a piece of work: `GET /v1/usage` with the API key (`events.used` against `events.quota`), or `GET /v1/agent` with your token (`usage.events` and `locked`). Tell your person before the month's 10 are used, because using all 10 locks the account until they upgrade. Upgrading is their step, under `https://esigncomply.com/dashboard/settings/billing`.

A locked account shows a lock screen in the dashboard, and the `/v1/agent` calls that change something answer `402`. `GET /v1/agent` keeps working and reports `locked` with the count, the limit and the address where your person upgrades.

## Run: webhooks, records, settings

### Add a webhook endpoint

#### In a browser

URL: `https://esigncomply.com/dashboard/webhooks`

1. Field **Endpoint URL**. HTTPS, and in test mode `http://localhost` is accepted too.
2. Field **Description** is optional. Group **Events**: "All events, including types added later" (selected) or "Selected events only".
3. Button **Add endpoint**.

**It worked when:** a status line reads "Endpoint added." and the page shows the line `ESIGNCOMPLY_WEBHOOK_SECRET=whsec_…` once. Store it next to the API key.

Each environment has its own endpoints, and the Free plan has one in each. Verify every delivery with the secret and handle `record.completed`. The payloads and the signature check are in [the webhooks reference](https://esigncomply.com/docs/api/webhooks.md).

### Read records and download evidence

#### In a browser

URL: `https://esigncomply.com/dashboard/records`

1. The table lists the records of the environment on screen. Narrow it with the fields **Search**, **Seal state**, **Level**, **Pack**, **Purpose**, **From** and **To**, then button **Filter**. Link **Export CSV** downloads the list.
2. Open a record by its ID (`rec_…`). Its page shows the timeline, what the signer saw, the conformance findings and the integrity checks.
3. Link **Download evidence report** gives the PDF. Link **Evidence package** gives the ZIP that verifies offline. Button **Copy verification link** and link **Open the public verification page** give the public page. Button **Verify now** runs the integrity check.

#### Without a browser

With a `read_only` or `full_access` key: `GET /v1/records`, `GET /v1/records/{id}`, `GET /v1/records/{id}/report` for the PDF and `GET /v1/records/{id}/evidence` for the package. A `recording_access` key reads status and receipt for server-side confirmation and nothing more. See [the records reference](https://esigncomply.com/docs/api/records.md).

### Team and settings

URL: `https://esigncomply.com/dashboard/settings`

Settings pages and who works in them

| Page | What it holds | Who |
| --- | --- | --- |
| Organization | Fields **Legal name**, **Country**, **Street**, **City**, button **Save organization**. The page answers "Saved." | You |
| Usage | Live and test events against the plan, by month. | You |
| Documents | The agreements your person accepted, with their records. | You |
| Audit log | Every action with its actor and time. Yours carry your token's ID. | You |
| Data and privacy | Receipts to signers, retention, exports and erasure requests. | You |
| Notifications | Where guidance notices and usage emails go. | You |
| Team | Members, invitations and roles. | Your person |
| Billing | The plan, invoices and the upgrade. | Your person |
| Security | Second factors. | Your person |

## Without a browser: the account API, API keys, the CLI

Send the agent token as `Authorization: Bearer $ESIGNCOMPLY_AGENT_TOKEN` to `https://esigncomply.com/v1/agent`. These calls cover the account. For everything else, create an API key with them and use the normal API under `api_url`. The limit is 60 calls a minute for each token.

The account API for agents

| Call | Body | Answer |
| --- | --- | --- |
| `GET /v1/agent` | None | The organization, the domain with its DNS record, plan, usage, `locked`, `next_step`, `steps` and `api_url`. |
| `POST /v1/agent/api-keys` | `{ "mode": "test" \| "live" }` | The key, once, in `key`. A live key needs a verified domain and saved organization details. |
| `GET /v1/agent/domain` | None | The domain and the TXT record that verifies it. |
| `PUT /v1/agent/domain` | `{ "domain": "app.example.com" }` | Registers the domain and returns the TXT record to publish. |
| `POST /v1/agent/domain/verify` | None | Looks for the record now. `verified` is `true` or `false`. |
| `POST /v1/agent/go-live` | Optional `organization` object | Saves the organization details and creates the live key. The key is in `api_key.key`, once. |

Errors use the envelope of the whole API: `error.code`, `error.message` and `error.request_id`. `401` means the token is missing, wrong, expired or revoked. `403` means the step is your person's or their role does not allow it. `402` means the account is locked. `429` comes with `Retry-After`. Every request and response body is in [the agent account API reference](https://esigncomply.com/docs/api/agent.md).

With the API key in `ESIGNCOMPLY_API_KEY` you have the whole product: the REST API, the Node server SDK and the CLI `esigncomply`.

```
# A sample ceremony on a local page. Prints the record ID.
npx esigncomply@latest demo
# The conformance check of your page.
npx esigncomply@latest check --url http://localhost:3000/signup
# Publish a file as a new version of a document.
npx esigncomply@latest documents publish ./legal/terms.md --document doc_8Hq2 --label 2026-11-22
# Forward test webhook deliveries to a server on your machine.
npx esigncomply@latest webhooks listen --forward http://localhost:3000/api/esigncomply/webhook
# Verify an evidence package offline.
npx esigncomply@latest verify rec_Z4m8.zip
```

Files for agents

| File | What it is |
| --- | --- |
| [/setup.md](https://esigncomply.com/setup.md) | The runbook for building a ceremony with a test key, in order. |
| [/auth.md](https://esigncomply.com/auth.md) | How to handle the agent token, API keys and webhook secrets. |
| [/rules.md](https://esigncomply.com/rules.md) | The block to add to the project's instruction file. |
| [/llms.txt](https://esigncomply.com/llms.txt) | The index of every page, each with its Markdown version. |
| [/docs](https://esigncomply.com/docs) | The documentation: API reference, SDKs, guides. Every page has a .md version. |
| [/openapi.json](https://esigncomply.com/openapi.json) | The OpenAPI 3.1 document of the API. |

## Questions agents and their people ask

### Can an AI agent set up Esign Comply on its own?

Yes, after one step by a person. The person creates the account: they enter their email, accept the terms once and type the 6-digit code from their inbox. From there the agent does everything with an agent token: keys, documents, profiles, the build prompt, the domain and going live.

### What is an agent token?

A secret that starts with esc_agent\_ and is 53 characters long. A signed-in person creates it under Agent access in the dashboard. It acts as that person with their role, expires after 1, 7, 30 or 90 days, can be revoked at any time, and every action taken with it is in the audit log under the token's ID. Only its SHA-256 hash is stored.

### How does an AI agent log in to the dashboard?

At /agent-login. The page has one field, Agent token, and one button, Log in. The session is marked as an agent session in the sidebar and lasts as long as the token.

### Can the agent work without a browser?

Yes. The account API under /v1/agent takes the agent token as a Bearer token. GET /v1/agent returns the state of the account and the next step, POST /v1/agent/api-keys issues an API key, and three more calls register the domain, check it and go live. With the API key the agent uses the normal API, the Node SDK and the CLI.

### What does the person still do?

They create the account and accept the terms. Later they are needed only for sign-in security, new agent tokens, team members and roles, and billing. An agent without access to the DNS provider also asks them to add one TXT record.

### How many live signatures does the Free plan cover?

Free covers 10 live signatures a month. If you use all 10 in a month, the account locks until you upgrade to a paid plan. It does not unlock at the start of the next month. Past the limit, new live signatures can be refused, so upgrade before you get there.

[Pricing](https://esigncomply.com/pricing)

## Your person signs up once. You do the rest.

[Get started](https://esigncomply.com/signup) · [Documentation](https://esigncomply.com/docs)

Free plan: 10 live signatures a month and a full test mode. No card required.

---

Every page on esigncomply.com has a Markdown version at the same URL plus `.md` (the home page is `https://esigncomply.com/index.md`). https://esigncomply.com/llms.txt lists them.
