# Create Session
Source: https://docs.wassist.app/api-reference/account-link/create

api-reference/openapi.json POST /api/v1/whatsapp-link-sessions/
Creates a new WhatsApp Account Link Session

This endpoint lets you create a new WhatsApp Account Link Session.


# Expire Session
Source: https://docs.wassist.app/api-reference/account-link/expire

api-reference/openapi.json POST /whatsapp-link-sessions/{id}/expire/
Expire a WhatsApp Account Link Session

This endpoint lets you expire a WhatsApp Account Link Session.


# Get Session
Source: https://docs.wassist.app/api-reference/account-link/get

api-reference/openapi.json GET /api/v1/whatsapp-link-sessions/{id}/
Returns a WhatsApp Account Link Session from the system



# List Sessions
Source: https://docs.wassist.app/api-reference/account-link/list

api-reference/openapi.json GET /api/v1/whatsapp-link-sessions/
Returns all WhatsApp Account Link Sessions from the system



# Create BYOA
Source: https://docs.wassist.app/api-reference/agents/byoa

api-reference/openapi.json POST /api/v1/agents/byoa/
Creates a new Bring Your Own Agent (BYOA)

This endpoint lets you create a new Bring Your Own Agent (BYOA).

See [BYOA Agent](../concepts/bring-your-own-agent.mdx) for more information.


# Create Agent
Source: https://docs.wassist.app/api-reference/agents/create

api-reference/openapi.json POST /api/v1/agents/
Creates a new Agent

This endpoint lets you create a new agent.

## Tool Input Types

When defining a tool's `api_schema`, every parameter (in `path_params`, `query_params`, `request_headers`, or `request_body`) takes an `input` object that tells the platform where the value should come from at call time.

There are two input types:

<AccordionGroup>
  <Accordion title="type: description (LLM-extracted)" icon="wand-magic-sparkles">
    The agent extracts the value from the conversation based on the description you provide.

    ```json theme={null}
    "message": {
      "type": "string",
      "input": {
        "type": "description",
        "description": "The exact message sent by the customer"
      }
    }
    ```
  </Accordion>

  <Accordion title="type: value (hardcoded)" icon="lock">
    Use a literal value, or a built-in template variable that gets substituted at call time. Template variables are written as `%VARIABLE_NAME%`.

    ```json theme={null}
    "phone_number": {
      "type": "string",
      "input": {
        "type": "value",
        "value": "%PHONE_NUMBER%"
      }
    }
    ```

    You can also pass any plain string (e.g. an API key, a fixed endpoint, a constant flag):

    ```json theme={null}
    "Authorization": {
      "type": "string",
      "input": {
        "type": "value",
        "value": "Bearer sk-live-..."
      }
    }
    ```
  </Accordion>
</AccordionGroup>

## Built-in Template Variables

When an `input` of `type: "value"` contains one of the following tokens, the platform replaces it with the appropriate runtime value before the tool is invoked:

| Variable         | Replaced with                                                                                                      |
| ---------------- | ------------------------------------------------------------------------------------------------------------------ |
| `%PHONE_NUMBER%` | The customer's WhatsApp phone number for the current session                                                       |
| `%IMAGE_URL%`    | The URL of the most recent image the customer sent (if the triggering message was an image)                        |
| `%CALLBACK_URL%` | A unique callback URL for this tool invocation — POST to it to send a follow-up message back into the conversation |

Tokens are substituted anywhere they appear inside a string value, so you can interpolate them into URLs, headers, query params, and request body fields.

## Automatic Request Headers

In addition to any headers you define in `request_headers`, every tool request the platform sends includes:

| Header                      | Value                                               |
| --------------------------- | --------------------------------------------------- |
| `X-Wassist-Conversation-Id` | The ID of the conversation the tool was called from |
| `X-Wassist-Contact-Id`      | The ID of the contact on that conversation          |

These are set by the platform and cannot be overridden by your tool schema. They are omitted when the tool runs outside of a conversation.

### Example

A `forward_message` tool that posts the customer's phone number, message text, attached image, and a reply callback to your own webhook:

```json theme={null}
{
  "url": "https://your-app.example.com/webhooks/agent",
  "method": "POST",
  "path_params": {},
  "query_params": { "required": [], "properties": {} },
  "request_body": {
    "type": "object",
    "required": [],
    "properties": {
      "phone_number": {
        "type": "string",
        "input": { "type": "value", "value": "%PHONE_NUMBER%" }
      },
      "message": {
        "type": "string",
        "input": {
          "type": "description",
          "description": "The exact message sent by the customer"
        }
      },
      "image": {
        "type": "string",
        "input": { "type": "value", "value": "%IMAGE_URL%" }
      },
      "reply_callback": {
        "type": "string",
        "input": { "type": "value", "value": "%CALLBACK_URL%" }
      }
    }
  }
}
```

<Note>
  `%IMAGE_URL%` is only populated when the message that triggered the tool call was an image. For text-only messages the field is omitted from the outgoing request.
</Note>


# Delete Agent
Source: https://docs.wassist.app/api-reference/agents/delete

api-reference/openapi.json DELETE /api/v1/agents/{id}/
Deletes an agent from the system



# Get Agent
Source: https://docs.wassist.app/api-reference/agents/get

api-reference/openapi.json GET /api/v1/agents/{id}/
Returns an agent from the system



# List Agents
Source: https://docs.wassist.app/api-reference/agents/list

api-reference/openapi.json GET /api/v1/agents/
Returns all agents from the system



# Update Agent
Source: https://docs.wassist.app/api-reference/agents/update

api-reference/openapi.json PATCH /api/v1/agents/{id}/
Updates an agent in the system



# Create Conversation
Source: https://docs.wassist.app/api-reference/conversations/create

api-reference/openapi.json POST /api/v1/conversations/
Creates a new Conversation

This endpoint lets you create a new conversation.


# Retrieve Conversation
Source: https://docs.wassist.app/api-reference/conversations/get

api-reference/openapi.json GET /api/v1/conversations/{id}/
Returns a conversation from the system



# List Conversations
Source: https://docs.wassist.app/api-reference/conversations/list

api-reference/openapi.json GET /api/v1/conversations/
Returns all conversations from the system



# List Messages
Source: https://docs.wassist.app/api-reference/conversations/messages/list

api-reference/openapi.json GET /api/v1/conversations/{id}/messages/
Retrieve all messages in a conversation

Retrieve all messages in a conversation.


# Send Message
Source: https://docs.wassist.app/api-reference/conversations/messages/send

api-reference/openapi.json POST /api/v1/conversations/{id}/messages/
Sends a message to a conversation

Send a message to an existing conversation on behalf of your agent.

## Message Types

You can send two main types of messages:

* **Unified messages** — Sent rich text messages with images, videos, audio, documents, buttons, and more
* **Template messages** — Pre-approved messages that can initiate or re-engage conversations

You can additionally send cta and text speicic messages, though these are deprecated and will be removed in the future.
We will be adding support for other specific message types, such as contacts, location and call requests in the future.

<Warning>
  **Check conversation status first!** You can only send regular (non-template) messages to **active** conversations. Use the [Get Conversation](/api-reference/conversations/get) endpoint to verify the conversation is active before sending.
</Warning>

<Note>
  **Billing**: Template messages are billed by Meta according to their [pricing tiers](https://developers.facebook.com/docs/whatsapp/pricing). Regular messages within the 24-hour customer service window are free.
</Note>


# Prompt Agent
Source: https://docs.wassist.app/api-reference/conversations/prompt

api-reference/openapi.json POST /api/v1/conversations/{id}/prompt/
Prompts an agent with a custom instruction

This endpoint lets you prompt an agent with a custom instruction.


# Mark Read
Source: https://docs.wassist.app/api-reference/conversations/read

api-reference/openapi.json POST /api/v1/conversations/{id}/read/
Send a read receipt for the most recent inbound message in a conversation.

Sends a WhatsApp read receipt (the blue double-tick) for the latest inbound
message in the conversation. This is useful when a human or external system
has taken over a conversation and wants to acknowledge new messages without
sending a reply yet.

If the conversation has no inbound messages to acknowledge, the call is a
no-op and the conversation is returned unchanged.

<Note>
  Read receipts only work for messages that arrived within WhatsApp's
  acknowledgement window. Very old messages may be silently ignored by Meta.
</Note>


# Webhook Subscribe
Source: https://docs.wassist.app/api-reference/conversations/subscribe

api-reference/openapi.json POST /api/v1/conversations/{id}/subscribe/
Route a conversation to a webhook. The agent pipeline is skipped while the override is active.

Switches the conversation to `webhook` routing and sets the per-conversation
webhook override. Fires `subscription.activated` on the newly assigned
webhook unless it was already the active subscriber.

While the override is in place, every inbound user message produces a
`subscription.message.received` event sent to the assigned webhook **only** —
the agent pipeline is not run. Clear the override with
[`POST /conversations/{id}/unsubscribe/`](/api-reference/conversations/unsubscribe).

<Note>
  Webhooks themselves must be created in the [dashboard](https://wassist.app/developers/webhooks).
  There is no API for webhook creation.
</Note>


# Mark Typing
Source: https://docs.wassist.app/api-reference/conversations/typing

api-reference/openapi.json POST /api/v1/conversations/{id}/typing/
Display the WhatsApp typing indicator to the contact while a reply is being composed.

Shows the WhatsApp typing indicator ("…") to the contact, signalling that
a reply is on the way. Use this when a human agent or external system is
composing a response and you want to keep the contact engaged.

The indicator is anchored to the latest inbound message, which is also
implicitly marked as read. If the conversation has no inbound messages, the
call is a no-op and the conversation is returned unchanged.

<Note>
  WhatsApp automatically dismisses the typing indicator after a short period
  or as soon as the next outbound message is sent. To keep it visible for
  longer, call this endpoint again before it expires.
</Note>


# Unsubscribe
Source: https://docs.wassist.app/api-reference/conversations/unsubscribe

api-reference/openapi.json POST /api/v1/conversations/{id}/unsubscribe/
Clear the per-conversation routing override and fall back to the number default.

Clears the per-conversation `routing` and `webhookOverride`. The conversation
falls back to the number's `defaultRouting` for future inbound messages.

If the conversation was previously routed to a webhook, fires
`subscription.revoked` on that webhook so it knows to stop expecting traffic
for this conversation.


# API Reference
Source: https://docs.wassist.app/api-reference/introduction

Complete REST API documentation for the Wassist platform

The Wassist REST API provides programmatic access to all platform features. Build integrations, automate workflows, and manage your WhatsApp agents at scale.

## Base URL

All API requests should be made to:

```
https://backend.wassist.app/api/v1/
```

## Authentication

The Wassist API uses API key authentication. Include your API key in the `X-API-Key` header of every request:

```bash theme={null}
X-API-Key: your-api-key-here
```

### Getting Your API Token

1. Log in to [wassist.app](https://wassist.app)
2. [Navigate to **Settings** → **API Keys**](https://wassist.app/settings/)
3. Click **Create API Key**
4. Copy and securely store your token

API keys are **organisation credentials**. Requests made with a key act as the organisation, not as the member who created it, so everything the key creates or reads belongs to the organisation. Keys keep working if their creator leaves the organisation; revoke a key from **Settings → API Keys** when you no longer want it to have access.

<Warning>
  Keep your API token secret. Never expose it in client-side code or commit it to version control.
</Warning>

### Example Request

```bash theme={null}
curl -X GET https://backend.wassist.app/api/v1/agents/ \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json"
```

## Request Format

* All request bodies should be JSON
* Set `Content-Type: application/json` header
* For file uploads, use `multipart/form-data`

```bash theme={null}
curl -X POST https://backend.wassist.app/api/v1/agents/ \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"name": "My New Agent"}'
```

## Response Format

All responses are JSON. Successful responses include the requested data:

```json theme={null}
{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "name": "My Agent",
  "description": "A helpful assistant",
  ...
}
```

### Paginated Responses

List endpoints return paginated results:

```json theme={null}
{
  "count": 42,
  "next": "https://backend.wassist.app/api/v1/agents/?offset=20",
  "previous": null,
  "results": [
    { "id": "...", "name": "Agent 1" },
    { "id": "...", "name": "Agent 2" }
  ]
}
```

Use `offset` and `limit` query parameters to paginate:

```
GET /agents/?offset=20&limit=20
```

## Error Responses

Errors return appropriate HTTP status codes with a JSON body:

```json theme={null}
{
  "error": "Agent not found",
  "code": "not_found"
}
```

### Common Status Codes

| Code  | Description                          |
| ----- | ------------------------------------ |
| `200` | Success                              |
| `201` | Created                              |
| `204` | No Content (successful delete)       |
| `400` | Bad Request (validation error)       |
| `401` | Unauthorized (invalid/missing token) |
| `403` | Forbidden (insufficient permissions) |
| `404` | Not Found                            |
| `429` | Rate Limited                         |
| `500` | Server Error                         |

## Rate Limiting

API requests are rate-limited to ensure fair usage. Current limits:

* **100 requests per minute** per API token

When rate limited, you'll receive a `429` response:

```json theme={null}
{
  "error": "Rate limit exceeded",
  "retry_after": 60
}
```

## API Resources

<CardGroup>
  <Card title="Agents" icon="robot" href="/api-reference/agents/list">
    Create and manage AI agents with all their configurations.
  </Card>

  <Card title="WhatsApp Accounts" icon="whatsapp" href="/api-reference/whatsapp-account/list">
    Connect and manage WhatsApp Business accounts.
  </Card>

  <Card title="WhatsApp Linking" icon="link" href="/api-reference/account-link/create">
    Create link sessions for connecting new accounts.
  </Card>

  <Card title="Business API Proxy" icon="arrow-right-arrow-left" href="/api-reference/whatsapp-account/proxy/get">
    Access the WhatsApp Business API directly.
  </Card>
</CardGroup>

## Quick Reference

### Agents

| Method   | Endpoint        | Description     |
| -------- | --------------- | --------------- |
| `GET`    | `/agents/`      | List all agents |
| `POST`   | `/agents/`      | Create an agent |
| `GET`    | `/agents/{id}/` | Get an agent    |
| `PUT`    | `/agents/{id}/` | Update an agent |
| `DELETE` | `/agents/{id}/` | Delete an agent |

### WhatsApp Accounts

| Method | Endpoint                                | Description        |
| ------ | --------------------------------------- | ------------------ |
| `GET`  | `/whatsapp-accounts/`                   | List accounts      |
| `GET`  | `/whatsapp-accounts/{id}/`              | Get an account     |
| `POST` | `/whatsapp-accounts/{id}/deploy-agent/` | Deploy agent       |
| `POST` | `/whatsapp-accounts/{id}/add-number/`   | Add phone number   |
| `*`    | `/whatsapp-accounts/{id}/proxy/{path}`  | Business API proxy |

### WhatsApp Linking

| Method | Endpoint                        | Description         |
| ------ | ------------------------------- | ------------------- |
| `POST` | `/whatsapp-link-sessions/`      | Create link session |
| `GET`  | `/whatsapp-link-sessions/`      | List sessions       |
| `GET`  | `/whatsapp-link-sessions/{id}/` | Get session         |

## Support

Need help with the API?

<CardGroup>
  <Card title="Contact Support" icon="envelope" href="mailto:contact@wassist.app">
    Reach out to our team.
  </Card>
</CardGroup>


# Agent Subscribe
Source: https://docs.wassist.app/api-reference/phone-numbers/connect-agent

api-reference/openapi.json POST /api/v1/phone-numbers/{number}/connect-agent/
Assign an agent as the default for this number. Drops any subscribed webhook.

Sets the number's default routing to `agent` and assigns the chosen agent
as the active bot. Any webhook subscribed to the number is dropped — call
[`POST /phone-numbers/{number}/subscribe/`](/api-reference/phone-numbers/subscribe)
to route to a webhook instead.

When `applyToExisting` is `true`, the new agent is written onto every
existing conversation on this number and the in-flight session is cleared
so the new agent picks up from scratch. Phone-number routing changes do
**not** dispatch `subscription.activated` / `subscription.revoked` webhook
events.

The agent must belong to the requesting organisation.

Sandbox numbers scope the change to the requesting user's own conversation:
their `activeAgent` is set to the chosen agent and their conversation
routing is forced to `agent` so the agent flow runs for them. Other users
on the shared sandbox are unaffected.


# List Numbers
Source: https://docs.wassist.app/api-reference/phone-numbers/list

api-reference/openapi.json GET /api/v1/phone-numbers/
List out all phone numbers avaible on the account



# View Profile
Source: https://docs.wassist.app/api-reference/phone-numbers/profile

api-reference/openapi.json GET /api/v1/phone-numbers/{number}/business-profile/
View the profile information that is set on the WhatsApp Phone Number



# Webhook Subscribe
Source: https://docs.wassist.app/api-reference/phone-numbers/subscribe

api-reference/openapi.json POST /api/v1/phone-numbers/{number}/subscribe/
Route inbound messages on this number to a webhook. Drops any connected agent.

Sets the number's default routing to `webhook` and assigns `defaultWebhook` to the
given webhook. Any agent previously connected to the number is dropped — call
[`POST /phone-numbers/{number}/connect-agent/`](/api-reference/phone-numbers/connect-agent)
to put one back.

When `applyToExisting` is `true`, every existing conversation on this number is
updated so the new routing takes effect for in-flight chats: `activeAgent` is
cleared and any open session is dropped. Phone-number routing changes do **not**
fire `subscription.activated` / `subscription.revoked` webhook events — those
are reserved for the per-conversation
[subscribe](/api-reference/conversations/subscribe) /
[unsubscribe](/api-reference/conversations/unsubscribe) endpoints.

<Note>
  Webhooks themselves must be created in the [dashboard](https://wassist.app/developers/webhooks).
  There is no API for webhook creation.
</Note>

Sandbox numbers (shared system numbers with no WhatsApp Business Account)
scope the change to the requesting user's own conversation; the shared
defaults are not touched and `applyToExisting` is ignored.


# Unsubscribe
Source: https://docs.wassist.app/api-reference/phone-numbers/unsubscribe

api-reference/openapi.json POST /api/v1/phone-numbers/{number}/unsubscribe/
Clear default routing on this number entirely. Drops both the agent and the webhook.

Sets `defaultRouting` to `null` (no routing) and drops both the connected
agent and the default webhook. Incoming messages are stored on the
conversation but no agent or webhook is invoked.

When `applyToExisting` is `true`, every existing conversation on this
number has its `activeAgent` and in-flight session cleared too. Phone-
number routing changes do **not** dispatch `subscription.activated` /
`subscription.revoked` webhook events.

Sandbox numbers scope the change to the requesting user's own
conversation rather than the shared number's defaults.


# Add Number
Source: https://docs.wassist.app/api-reference/whatsapp-account/add-number

api-reference/openapi.json POST /api/v1/whatsapp-accounts/{id}/add-number/
Add a new phone number to a WhatsApp Business Account

Adds a new phone number to a WhatsApp Business Account.

You can make a request to /available-numbers/ to get a list of available phone numbers.
You must use one of thes numbers to add to the whatsapp account.


# Available Numbers
Source: https://docs.wassist.app/api-reference/whatsapp-account/available-numbers

api-reference/openapi.json GET /api/v1/available-numbers/
Returns a list of available phone numbers

Returns a list of available phone numbers.

You can use these numbers to add to a WhatsApp Business Account.


# Get Account
Source: https://docs.wassist.app/api-reference/whatsapp-account/get

api-reference/openapi.json GET /api/v1/whatsapp-accounts/{id}/
Returns a WhatsApp Business Account from the system



# List Accounts
Source: https://docs.wassist.app/api-reference/whatsapp-account/list

api-reference/openapi.json GET /api/v1/whatsapp-accounts/
Returns all WhatsApp Business Accounts linked to your account



# DELETE Request
Source: https://docs.wassist.app/api-reference/whatsapp-account/proxy/delete

api-reference/openapi.json GET /api/v1/whatsapp-accounts/{id}/proxy/{path}/
Proxy a DELETE request to the Official WhatsApp Business API

This endpoint lets you proxy a DELETE request to the Official WhatsApp Business API.
You will be authenticated to the whatsapp account you are proxying for.

Look to the [WhatsApp Business API documentation](https://developers.facebook.com/docs/whatsapp/business-api/reference) for more information on the available endpoints.


# GET Request
Source: https://docs.wassist.app/api-reference/whatsapp-account/proxy/get

api-reference/openapi.json GET /api/v1/whatsapp-accounts/{id}/proxy/{path}/
Proxy a GET request to the Official WhatsApp Business API

This endpoint lets you proxy a GET request to the Official WhatsApp Business API.
You will be authenticated to the WhatsApp account you are proxying for.

## Example: List All Message Templates

To list all WhatsApp message templates for a Business Account, use the WABA ID as the path:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET "https://backend.wassist.app/api/v1/whatsapp-accounts/{account_id}/proxy/{waba_id}/message_templates" \
    -H "X-API-Key: YOUR_API_KEY"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    `https://backend.wassist.app/api/v1/whatsapp-accounts/${accountId}/proxy/${wabaId}/message_templates`,
    {
      headers: {
        'X-API-Key': 'YOUR_API_KEY'
      }
    }
  );

  const templates = await response.json();
  console.log(templates.data);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      f"https://backend.wassist.app/api/v1/whatsapp-accounts/{account_id}/proxy/{waba_id}/message_templates",
      headers={"X-API-Key": "YOUR_API_KEY"}
  )

  templates = response.json()
  print(templates["data"])
  ```
</CodeGroup>

### Response

```json theme={null}
{
  "data": [
    {
      "name": "hello_world",
      "status": "APPROVED",
      "category": "UTILITY",
      "language": "en_US",
      "components": [
        {
          "type": "BODY",
          "text": "Hello {{1}}! Welcome to our service."
        }
      ],
      "id": "123456789"
    }
  ],
  "paging": {
    "cursors": {
      "before": "...",
      "after": "..."
    }
  }
}
```

<Note>
  Replace `{account_id}` with your WhatsApp Account ID (from the Waxle API) and `{waba_id}` with your WhatsApp Business Account ID (from Meta).

  You can find your WABA ID in the account details returned by `GET /whatsapp-accounts/{id}/`.
</Note>

## Other Common GET Requests

| Path                                          | Description                       |
| --------------------------------------------- | --------------------------------- |
| `{waba_id}/message_templates`                 | List all message templates        |
| `{waba_id}/phone_numbers`                     | List phone numbers in the account |
| `{phone_number_id}`                           | Get phone number details          |
| `{phone_number_id}/whatsapp_business_profile` | Get business profile              |

Look to the [WhatsApp Business API documentation](https://developers.facebook.com/docs/whatsapp/business-management-api/message-templates) for more information on the available endpoints.


# PATCH Request
Source: https://docs.wassist.app/api-reference/whatsapp-account/proxy/patch

api-reference/openapi.json PATCH /api/v1/whatsapp-accounts/{id}/proxy/{path}/
Proxy a PATCH request to the Official WhatsApp Business API

This endpoint lets you proxy a PATCH request to the Official WhatsApp Business API.
You will be authenticated to the whatsapp account you are proxying for.

Look to the [WhatsApp Business API documentation](https://developers.facebook.com/docs/whatsapp/business-api/reference) for more information on the available endpoints.


# POST Request
Source: https://docs.wassist.app/api-reference/whatsapp-account/proxy/post

api-reference/openapi.json POST /api/v1/whatsapp-accounts/{id}/proxy/{path}/
Proxy a POST request to the Official WhatsApp Business API

This endpoint lets you proxy a POST request to the Official WhatsApp Business API.
You will be authenticated to the whatsapp account you are proxying for.

Look to the [WhatsApp Business API documentation](https://developers.facebook.com/docs/whatsapp/business-api/reference) for more information on the available endpoints.


# PUT Request
Source: https://docs.wassist.app/api-reference/whatsapp-account/proxy/put

api-reference/openapi.json PUT /api/v1/whatsapp-accounts/{id}/proxy/{path}/
Proxy a PUT request to the Official WhatsApp Business API

This endpoint lets you proxy a PUT request to the Official WhatsApp Business API.
You will be authenticated to the whatsapp account you are proxying for.

Look to the [WhatsApp Business API documentation](https://developers.facebook.com/docs/whatsapp/business-api/reference) for more information on the available endpoints.


# Create Template
Source: https://docs.wassist.app/api-reference/whatsapp-templates/create

api-reference/openapi.json POST /api/v1/whatsapp-templates/
Creates a new Template

This endpoint lets you create a new Template.


# Delete Template
Source: https://docs.wassist.app/api-reference/whatsapp-templates/delete

api-reference/openapi.json DELETE /api/v1/whatsapp-templates/{id}/
Deletes a WhatsApp Template



# List Templates
Source: https://docs.wassist.app/api-reference/whatsapp-templates/list

api-reference/openapi.json GET /api/v1/whatsapp-templates/
Returns all WhatsApp Templates



# Publish Template
Source: https://docs.wassist.app/api-reference/whatsapp-templates/publish

api-reference/openapi.json POST /api/v1/whatsapp-templates/{id}/publish/
Publishes a WhatsApp Template

This endpoint lets you publish a WhatsApp Template to one or more WhatsApp Business Accounts.


# Unpublish Template
Source: https://docs.wassist.app/api-reference/whatsapp-templates/unpublish

api-reference/openapi.json POST /api/v1/whatsapp-templates/{id}/publish/
Unpublishes a WhatsApp Template

This endpoint lets you unpublish a WhatsApp Template from one or more WhatsApp Business Accounts.


# Update Template
Source: https://docs.wassist.app/api-reference/whatsapp-templates/update

api-reference/openapi.json PATCH /api/v1/whatsapp-templates/{id}/
Updates a WhatsApp Template

This endpoint lets you update a WhatsApp Template.


# CLI
Source: https://docs.wassist.app/cli

Drive Wassist from your terminal — send and receive WhatsApp messages, manage numbers, and stream live events while you build.

The Wassist CLI is the fastest way to test agents and webhooks without leaving your terminal. It uses your existing Wassist account and the same `/api/v1` endpoints as the dashboard.

<Note>
  The CLI requires **Node.js 22+** (it uses the built-in `WebSocket` global). See the [GitHub source](https://github.com/wassist/cli) or `@wassist/cli` on npm.
</Note>

## Install

```bash theme={null}
npm install -g @wassist/cli
```

## Authenticate

```bash theme={null}
wassist login
```

You'll be prompted for your phone number, then a 6-digit code arrives on WhatsApp from the **Wassist sandbox number** — the same number you'll send test messages to in a moment.

Confirm you're signed in:

```bash theme={null}
wassist whoami
```

After login the CLI is automatically scoped to your **sandbox conversation** — a one-on-one chat between your personal WhatsApp and the Wassist sandbox number. Sandbox mode means most commands don't need a `[to-number]` argument.

<Tip>
  Switch between sandbox and a real WhatsApp number any time with `wassist use sandbox` or `wassist use <your-number>`.
</Tip>

## Sending messages

<Note>
  WhatsApp only lets you send free-form messages inside an active 24-hour customer-care window. Before your first `messages send`, either **message the Wassist sandbox number from your phone** to open the window, or send a pre-approved **template message** (see [Outside the 24-hour window](#outside-the-24-hour-window) below).
</Note>

The `messages send` command supports the full WhatsApp message envelope — text, media, buttons, and footers — composed via flags.

<Tabs>
  <Tab title="Text">
    ```bash theme={null}
    wassist messages send "Hello from the CLI"
    ```
  </Tab>

  <Tab title="With media">
    ```bash theme={null}
    wassist messages send "Check this out" \
      --media https://picsum.photos/200/300
    ```

    Supported types: JPEG, PNG, MP4, 3GPP, AAC, MP4 audio, MPEG, AMR, OGG, PDF, DOCX, XLSX, PPTX.
  </Tab>

  <Tab title="Quick replies">
    ```bash theme={null}
    wassist messages send "Choose one" \
      --reply "Yes|confirm" \
      --reply "No|deny"
    ```

    Max 3 quick replies. The pipe separates label from the value sent back when tapped.
  </Tab>

  <Tab title="URL button">
    ```bash theme={null}
    wassist messages send "Visit us" \
      --url-button "Shop Now|https://shop.com"
    ```

    Max 1 URL button. URL and quick-reply buttons cannot be mixed in the same message.
  </Tab>
</Tabs>

### Validation rules

* **Text body** — max 1024 characters.
* **Buttons** — max 3 total, all the same type.
* **Media** — must be a publicly reachable HTTPS URL.
* **Button labels** — max 20 characters, formatted `"Label|value"`.

### Outside the 24-hour window

If the conversation's customer-care 24-hour window has lapsed (no inbound user message in the last 24 hours), the CLI prompts you to pick a pre-approved template instead — the same constraint as the WhatsApp Business API enforces directly.

## Streaming inbound messages

`messages listen` opens a WebSocket session, so every inbound WhatsApp message lands in your terminal in real time. Behind the scenes Wassist creates a **managed webhook** for this session and tunnels it through a WebSocket relay — you don't need to expose a public URL.

```bash theme={null}
wassist messages listen --interactive
```

```text theme={null}
─── wassist messages listen ──────────────────────────────
[10:24] customer +447700900200
        Hey, can I add another item to my order?
> Sure! What would you like to add?
```

In interactive mode you can reply inline. The `> ` prompt accepts the same `--media`, `--url-button`, and `--reply` flags as `messages send`:

```text theme={null}
> Here's a photo --media https://picsum.photos/300 --reply "Looks good|yes" --reply "Try another|no"
```

<Tip>
  `messages listen` is ideal when you're iterating on an agent or a webhook handler and want to see events the instant they arrive. It runs alongside your own webhooks — both fire on every inbound message.
</Tip>

## Combining the CLI with webhooks

A common dev loop:

1. Configure your own webhook in the dashboard pointing at your local dev server (via your tunneling tool of choice — ngrok, Cloudflare Tunnel, Tailscale Funnel, etc.).
2. In another terminal, run `wassist messages listen` so you can watch inbound messages while your webhook is processing them.
3. Send a test event from the dashboard ([wassist.app/developers/webhooks](https://wassist.app/developers/webhooks) → your webhook → **Send test event**) or send a real message from your phone.
4. Inspect the delivery in **Developers → Webhooks → Deliveries** for the full request/response timeline, or click **Replay** to re-send it without retyping anything on WhatsApp.

See the [developer quickstart](/quickstart-developers) for an end-to-end walkthrough.

## Moving to your own number

The sandbox is great for development. To message real contacts, connect a WhatsApp Business number:

<Steps>
  <Step title="Upgrade your plan">
    ```bash theme={null}
    wassist upgrade
    ```

    A Wassist subscription is required to connect your own number.
  </Step>

  <Step title="Link your WhatsApp Business Account">
    ```bash theme={null}
    wassist numbers add
    ```

    Opens Meta's embedded signup in your browser so you can pick (or claim) a phone number.
  </Step>

  <Step title="Switch to your number">
    ```bash theme={null}
    wassist numbers list           # see numbers you can use
    wassist use 441234567890       # set the active number
    ```
  </Step>

  <Step title="Send messages to real contacts">
    With your own number active, include the recipient's E.164 number:

    ```bash theme={null}
    wassist messages send 441234567890 "Hey, this is from my own number!"
    wassist messages read 441234567890
    ```
  </Step>
</Steps>

To switch back to the sandbox: `wassist use sandbox`.

## Command reference

### Authentication

| Command          | Description                                   |
| ---------------- | --------------------------------------------- |
| `wassist login`  | Authenticate via WhatsApp OTP.                |
| `wassist whoami` | Show the authenticated user and current plan. |

### Number management

| Command                | Description                                                                |
| ---------------------- | -------------------------------------------------------------------------- |
| `wassist use <number>` | Set the active number. Use `sandbox` to switch back to the shared sandbox. |
| `wassist numbers list` | List all WhatsApp numbers, marking the active one.                         |
| `wassist numbers add`  | Add a new WhatsApp number (Starter plan or above).                         |

### Messaging

In sandbox mode the phone-number argument is optional — the CLI resolves your single sandbox conversation automatically.

| Command                                       | Description                                                                              |
| --------------------------------------------- | ---------------------------------------------------------------------------------------- |
| `wassist messages list`                       | List conversations for the active number.                                                |
| `wassist messages read [phone-number]`        | View messages for a contact. Flags: `--limit <n>`, `--page <n>`.                         |
| `wassist messages send [to-number] [message]` | Send a message. Flags: `--footer`, `--media`, `--url-button`, `--reply` (repeatable).    |
| `wassist messages listen [phone-number]`      | Stream inbound messages over WebSocket. Flag: `-i` / `--interactive` for inline replies. |

### Billing

| Command           | Description                     |
| ----------------- | ------------------------------- |
| `wassist upgrade` | Upgrade your subscription plan. |

## Configuration

The CLI stores its auth token and active number locally via [conf](https://github.com/sindresorhus/conf). The default backend is `https://backend.wassist.app`; this can be overridden in the config file for development.

## Policies

By sending messages through the Wassist CLI you agree to:

* [WhatsApp Business Policy](https://business.whatsapp.com/policy) — opt-in, prohibited content, frequency, and platform rules.
* [Meta AI Provider pricing policy](https://developers.facebook.com/documentation/business-messaging/whatsapp/pricing/ai-providers/) — per-message pricing for AI-driven non-template messages in certain markets.

Violations may restrict your WhatsApp Business Account or Wassist account.


# Core Concepts
Source: https://docs.wassist.app/concepts

Understand the building blocks of Wassist: agents, tools, conversations, and more

This guide explains the fundamental concepts you'll encounter when building with Wassist. Whether you're using the dashboard or the API, these concepts apply universally.

## Agents

An **Agent** is an AI-powered assistant that handles conversations on WhatsApp. Each agent has its own personality, knowledge, and capabilities defined by its configuration.

<Frame>
  ```mermaid theme={null}
  flowchart LR
      User[WhatsApp User] <-->|Messages| Agent[Wassist Agent]
      Agent --> Tools[Tools & APIs]
      Agent --> Knowledge[Knowledge Base]
      Agent --> Memory[Conversation Memory]
  ```
</Frame>

### Key Agent Properties

| Property            | Description                                                                      |
| ------------------- | -------------------------------------------------------------------------------- |
| **Name**            | The display name of your agent                                                   |
| **System Prompt**   | Instructions that define how the agent behaves, its personality, and constraints |
| **First Message**   | The welcome message sent when a user starts a new conversation                   |
| **Icebreakers**     | Quick-reply buttons shown with the first message to guide users                  |
| **Profile Picture** | The avatar displayed in WhatsApp                                                 |

<Tip>
  A well-crafted system prompt is the most important factor in your agent's quality. Be specific about tone, knowledge boundaries, and how to handle edge cases.
</Tip>

## Tools

**Tools** extend your agent's capabilities by connecting it to external services. When a user asks a question that requires real-time data or an action, the agent can call a tool to fulfill the request.

### Types of Tools

<AccordionGroup>
  <Accordion title="API Tools" icon="plug">
    Connect to any REST API to fetch data or trigger actions. Define the endpoint, parameters, and how the agent should interpret responses.

    **Examples:**

    * Check order status from your e-commerce platform
    * Book appointments in your calendar system
    * Look up product inventory
  </Accordion>

  <Accordion title="Website Tools" icon="globe">
    Let your agent browse and extract information from web pages in real-time.

    **Examples:**

    * Check current prices on your website
    * Pull the latest blog posts
    * Verify stock availability
  </Accordion>

  <Accordion title="Image Generation Tools" icon="image">
    Enable your agent to create images based on user requests using AI image generation.
  </Accordion>

  <Accordion title="Handoff Tools" icon="arrow-right-arrow-left">
    Transfer conversations to other agents or human operators when specialized help is needed.
  </Accordion>

  <Accordion title="MCP Connectors" icon="server">
    Connect to Model Context Protocol (MCP) servers for advanced integrations with external systems.
  </Accordion>
</AccordionGroup>

## Conversations

A **Conversation** represents an ongoing dialogue between a user and an agent. Wassist manages conversation state, history, and context automatically.

### Conversation Properties

| Property     | Description                                                |
| ------------ | ---------------------------------------------------------- |
| **Messages** | The full history of messages exchanged                     |
| **Context**  | Structured data extracted during the conversation          |
| **Memory**   | Persistent key-value storage that survives across sessions |
| **Credits**  | If monetization is enabled, the user's remaining credits   |

### Message Types

WhatsApp supports rich message formats beyond plain text:

* **Text** — Standard text messages with emoji and formatting
* **Images** — Photos and graphics with optional captions
* **CTA Buttons** — Call-to-action buttons that link to URLs
* **List Selections** — Interactive menus for structured choices
* **Templates** — Pre-approved message templates for outbound messages

## Memory

**Memory Keys** let your agent remember information about each user across conversations. Unlike conversation context (which resets), memory persists indefinitely.

```
Memory Key: "customer_name"
Type: string
When to Update: "When the user tells you their name"
```

**Use cases:**

* Remember user preferences
* Track subscription status
* Store order history references

## Documents & Knowledge Base

Upload files to give your agent specialized knowledge. Wassist processes documents using AI embeddings, allowing your agent to search and retrieve relevant information during conversations.

**Supported formats:**

* PDF documents
* Word documents (.docx)
* Plain text files
* Markdown files

<Note>
  Documents are processed asynchronously. You'll see a status indicator while processing completes.
</Note>

## WhatsApp Business Accounts

To deploy agents to production, you connect a **WhatsApp Business Account (WABA)**. This gives you:

* **Dedicated phone numbers** — Your own business numbers
* **Business profile** — Company name, description, and verified badge
* **Message templates** — Pre-approved templates for outbound messaging
* **Higher messaging limits** — Send more messages as your reputation grows

<Frame>
  ```mermaid theme={null}
  flowchart TD
      WABA[WhatsApp Business Account]
      WABA --> Phone1[Phone Number 1]
      WABA --> Phone2[Phone Number 2]
      Phone1 --> Agent1[Agent A]
      Phone2 --> Agent2[Agent B]
  ```
</Frame>

You can deploy different agents to different phone numbers under the same business account.

## Monetization

Wassist includes built-in tools to generate revenue from your agents:

### Paywalls

Set a message limit after which users must take action:

* **Purchase Link** — Redirect to a payment page
* **Terminal** — Stop the conversation with a custom message

### Credits

A flexible token-based system where:

* Users start with initial credits
* Each message or tool use consumes credits
* Users unlock more credits with a grant password after paying on your own page

### Ads

Display promotional content within conversations (optional).

## Wake-Up Configs

**Wake-Up Configs** let your agent proactively reach out to users based on triggers. Instead of waiting for users to message first, your agent can initiate conversations.

**Example triggers:**

* "If the user hasn't responded in 24 hours, send a follow-up"
* "If a new product launches, notify interested users"

## Outbound Triggers

**Outbound Triggers** are webhooks that let external systems trigger your agent to send messages. When your backend receives an event (new order, appointment reminder, etc.), it can call Wassist to send a templated message.

***

## Next Steps

<CardGroup>
  <Card title="Create Your First Agent" icon="rocket" href="/quickstart">
    Follow the quickstart guide to build an agent in minutes.
  </Card>

  <Card title="SDK Overview" icon="code" href="/sdk/overview">
    Learn how to manage agents programmatically.
  </Card>
</CardGroup>


# Bring Your Own Agent
Source: https://docs.wassist.app/concepts/bring-your-own-agent

Connect your existing AI agent to WhatsApp through Wassist's infrastructure

Bring Your Own Agent (BYOA) mode lets you use your own AI agent while Wassist handles all the WhatsApp complexity. You get full control over the conversation logic, while we manage typing indicators, message formatting, read receipts, and the entire WhatsApp Business API integration.

## When to Use BYOA

This approach is ideal when you:

* Already have an AI agent built with your preferred framework (LangChain, CrewAI, custom, etc.)
* Want complete control over conversation flow and business logic
* Need to integrate with existing systems that your agent already connects to
* Don't want to deal with WhatsApp's messaging quirks and delivery mechanics

<Note>
  With BYOA, you focus entirely on your agent's intelligence. Wassist handles the WhatsApp side—typing indicators, message types, read receipts, delivery status, and conversational flow.
</Note>

## How It Works

<Frame>
  ```mermaid theme={null}
  sequenceDiagram
      participant User as WhatsApp Customer
      participant W as Wassist "Agent"
      participant Agent as Your Agent

      User->>W: Sends message
      W->>Agent: Webhook with message (tool call)
      Agent->>Agent: Process with your own Agent
      Agent->>W: Webhook Response (tool response)
      W->>W: Run Wassist loop
      W->>User: Deliver message
      Agent->>W: Send content to reply_callback
      W->>User: Deliver message
  ```
</Frame>

The flow is simple:

1. A customer sends a message on WhatsApp
2. Wassist receives it and calls your webhook with the message details (tool call)
3. Your agent processes the message however you want
4. Your agent responds to the webhook with the response (tool response)
5. Wassist formats and delivers the response to WhatsApp (message delivered)

If your processing takes too long, you can respond to the webhook with a intermediate message to keep the engaged, and use the reply\_callback to send more messages later.
reply\_callback is a url available for 24 hours you can use to send more messages to the customer.

## Setup

### Step 1: Create a Wassist Agent

Even in BYOA mode, you need to create a Wassist agent. This agent acts as a passthrough that routes all messages to your external agent.

<Tabs>
  <Tab title="Dashboard">
    1. Go to [Agents](https://wassist.app/agents) and click **Create Agent**
    2. Select **Bring Your Own Agent** as the creation method
    3. Configure your webhook URL (where Wassist will send incoming messages)
    4. Save and deploy
  </Tab>

  <Tab title="API">
    See [Create BYOA Agent](../api-reference/agents/byoa) for more information. The following is an example request:

    ```bash theme={null}
    curl -X POST https://wassist.app/api/v1/agents/byoa/ \
      -H "X-API-Key: YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "webhookUrl": "https://your-server.com/webhook",
      }'
    ```
  </Tab>
</Tabs>

### Step 2: Implement Your Webhook

Your webhook receives a POST request for each incoming message with the following structure:

```json theme={null}
{
  "message": "Hello, I need help with my order",
  "image": "https://media.wassist.app/...",  // null if no image
  "phone_number": "+1234567890",
  "reply_callback": "https://wassist.app/api/callback/xyz789"
}
```

| Field            | Type           | Description                                 |
| ---------------- | -------------- | ------------------------------------------- |
| `message`        | string         | The text content of the customers's message |
| `image`          | string \| null | URL to the image if the customers sent one  |
| `phone_number`   | string         | The customers's WhatsApp phone number       |
| `reply_callback` | string         | One-time URL to send your response          |

### Step 3: Handle the Response

After your agent processes the message, you have two options for responding:

<Tabs>
  <Tab title="Webhook Response">
    Send the response to the webhook with the response (tool response)
    For example:

    ```json theme={null}
    {
      "type": "message",
      "content": "I found your order #12345. It shipped yesterday and should arrive by Friday."
    }
    ```

    Wassist will send this message directly to the WhatsApp customer.

    We accept any content in the response, including any json object.

    You can also instruct the agent to not reply with the response:

    ```json theme={null}
    {
      "content": "No CUSTOMER message reply"
    }
    ```
  </Tab>

  <Tab title="Reply Callback">
    The reply callback is URL that you can use to send more messages to the custoemr at any future point within 24 hours.

    Much like the webhook response, you can send any content to the reply callback, including any json object.

    ```bash theme={null}
    curl -X POST "https://wassist.app/api/callback/xyz789" \
      -H "Content-Type: application/json" \
      -d '{
        "content": "I found your order #12345. It shipped yesterday and should arrive by Friday."
      }'
    ```
  </Tab>
</Tabs>

### Step 4: Test Your Integration

You can test your integration by sending a message to the Wassist agent and checking the response.
When creating the agent, `connectUrl` will be provided in the agent object.
Visit this url to test your integration in the Wassist sandbox number.

This can also be viewed in the agent's overview page. To see this:

* Go to [Agents](https://wassist.app/agents) and click on the agent you created
* Click on the agent name to view the overview page
* On the left sidebar, click on the "Test Agent" button

## Rich Content Responses

All messages will be formatted specially for WhatsApp. Including:

* Image messages
  * Send an image url
* Video messages
  * Send a video url
* Audio messages
  * Send an audio url
* Document messages
  * Send a document url
* Contact cards
  * Send a contact name and phone number
* Location messages
  * Send a latitude and longitude

## Accessing Conversation History

Your agent can retrieve the full conversation context using the Conversations API:

<Card title="Conversations API" icon="comments" href="/api-reference/conversations/list">
  Retrieve full conversation history for context.
</Card>

## Example Implementation

Here's a complete example using Python and Flask:

```python theme={null}
from flask import Flask, request, jsonify
import requests
from your_agent import process_message  # Your agent implementation

app = Flask(__name__)

@app.route("/webhook", methods=["POST"])
def handle_webhook():
    data = request.json
    
    message = data["message"]
    customer = data["phone_number"]

    # Process with your agent
    response = process_message(
        message=message,
        customer=customer,
    )
    
    return jsonify(response)

if __name__ == "__main__":
    app.run(port=8000)
```

## Best Practices

<AccordionGroup>
  <Accordion title="Respond Quickly" icon="bolt">
    WhatsApp customers expect fast responses. Aim to respond to the webhook within 5s.
  </Accordion>
</AccordionGroup>

## What Wassist Handles For You

When you use BYOA, Wassist automatically manages:

| Feature                | Description                                       |
| ---------------------- | ------------------------------------------------- |
| **Typing Indicators**  | Shows "typing..." while your agent processes      |
| **Read Receipts**      | Marks messages as read at the right time          |
| **Message Formatting** | Converts your responses to proper WhatsApp format |
| **Media Handling**     | Uploads and hosts images, documents, audio        |
| **Delivery Status**    | Tracks sent, delivered, and read status           |
| **Rate Limiting**      | Respects WhatsApp's messaging limits              |
| **Error Recovery**     | Retries failed message deliveries                 |
| **Session Management** | Handles 24-hour messaging windows                 |

You focus on the intelligence. We focus on WhatsApp.

***

## Next Steps

<CardGroup>
  <Card title="Conversations API" icon="comments" href="/api-reference/conversations/list">
    Learn how to fetch and manage conversation history.
  </Card>

  <Card title="Message Types" icon="message" href="/api-reference/conversations/messages/send">
    Explore all supported message formats.
  </Card>
</CardGroup>


# Webhooks
Source: https://docs.wassist.app/concepts/webhooks

Receive real-time WhatsApp events on your own infrastructure with signed, retried, idempotent deliveries.

Webhooks let your code react to events from your WhatsApp numbers in real time. Every delivery is signed, retried, and recorded so you can debug from the dashboard.

<Note>
  The Webhooks dashboard lives at [wassist.app/developers/webhooks](https://wassist.app/developers/webhooks). Create one there, copy the signing secret, and you're done.
</Note>

## How a delivery works

```mermaid theme={null}
sequenceDiagram
    participant W as Wassist
    participant Q as Delivery queue
    participant You as Your endpoint

    W->>Q: dispatch event (writes WebhookDelivery row)
    Q->>You: POST with X-Wassist-Signature + Delivery ID
    You-->>Q: 2xx
    Note over Q: 4xx → no retry; 5xx/network → retry with backoff
    Q->>W: update delivery + record attempt
```

Behind the scenes:

1. The event is committed to our outbox as a `WebhookDelivery` with a stable UUID.
2. A worker POSTs the JSON body to your URL.
3. We record an attempt row with status code, duration, and response body.
4. On `5xx` or network errors we retry up to **3 times** with exponential backoff
   (10s, 30s, 90s).
5. After **20 consecutive failures** the webhook is auto-disabled and you get a banner in the dashboard.

## Headers

| Header                | Purpose                                                                               |
| --------------------- | ------------------------------------------------------------------------------------- |
| `Content-Type`        | Always `application/json`.                                                            |
| `User-Agent`          | `Wassist-Webhook/1.0`                                                                 |
| `X-Wassist-Event`     | The event name, e.g. `message.received`.                                              |
| `X-Wassist-Delivery`  | Stable UUID. **Use this as your idempotency key.** It does not change across retries. |
| `X-Wassist-Timestamp` | Unix seconds. The time we signed the request.                                         |
| `X-Wassist-Signature` | `t=<ts>,v1=<hex hmac sha256>` — Stripe-style.                                         |

## Verifying signatures

Compute `HMAC-SHA256` over the string `<timestamp>.<raw body>` using the webhook's signing secret and compare it in constant time to the `v1` component.

<Tabs>
  <Tab title="Node.js">
    ```ts theme={null}
    import crypto from "node:crypto";

    app.post("/webhooks/wassist", express.raw({ type: "application/json" }), (req, res) => {
      const header = req.header("x-wassist-signature") ?? "";
      const parts = Object.fromEntries(header.split(",").map((p) => p.split("=")));
      const signedPayload = `${parts.t}.${req.body.toString("utf-8")}`;
      const expected = crypto
        .createHmac("sha256", process.env.WASSIST_WEBHOOK_SECRET!)
        .update(signedPayload)
        .digest("hex");

      const ok = crypto.timingSafeEqual(
        Buffer.from(parts.v1, "hex"),
        Buffer.from(expected, "hex"),
      );
      if (!ok) return res.status(400).send("bad signature");

      // Replay protection: reject events more than 5 minutes old.
      if (Math.abs(Date.now() / 1000 - Number(parts.t)) > 300) {
        return res.status(400).send("stale");
      }

      // Idempotency: drop duplicate deliveries.
      const deliveryId = req.header("x-wassist-delivery")!;
      if (await alreadyProcessed(deliveryId)) return res.status(200).send("ok");

      await handle(JSON.parse(req.body.toString("utf-8")));
      await markProcessed(deliveryId);
      res.status(200).send("ok");
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    import hmac, hashlib, time

    def verify(request, secret: str) -> bool:
        header = request.headers.get("X-Wassist-Signature", "")
        parts = dict(p.split("=", 1) for p in header.split(","))
        ts, received = parts.get("t", ""), parts.get("v1", "")
        signed = f"{ts}.".encode() + request.body
        expected = hmac.new(secret.encode(), signed, hashlib.sha256).hexdigest()
        if not hmac.compare_digest(received, expected):
            return False
        return abs(time.time() - int(ts)) <= 300
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    func verify(r *http.Request, secret string) bool {
        body, _ := io.ReadAll(r.Body)
        header := r.Header.Get("X-Wassist-Signature")
        var ts, sig string
        for _, p := range strings.Split(header, ",") {
            kv := strings.SplitN(p, "=", 2)
            if len(kv) == 2 {
                if kv[0] == "t" { ts = kv[1] }
                if kv[0] == "v1" { sig = kv[1] }
            }
        }
        mac := hmac.New(sha256.New, []byte(secret))
        mac.Write([]byte(ts + "."))
        mac.Write(body)
        expected := hex.EncodeToString(mac.Sum(nil))
        if !hmac.Equal([]byte(sig), []byte(expected)) {
            return false
        }
        epoch, _ := strconv.ParseInt(ts, 10, 64)
        return time.Now().Unix()-epoch <= 300
    }
    ```
  </Tab>
</Tabs>

## Event catalog

### `message.received`

Fired when a customer sends a message to one of your numbers.

```json theme={null}
{
  "event": "message.received",
  "timestamp": "2026-06-23T16:48:00.000Z",
  "phoneNumber": "+447700900100",
  "from": "+447700900200",
  "contact": { "name": "Alex", "phoneNumber": "+447700900200" },
  "message": {
    "id": "01HXYZ...",
    "waId": "wamid.HBgL...",
    "body": "Hey, can I add another item to my order?",
    "media": [],
    "buttons": []
  },
  "conversationId": "5a3f...e2"
}
```

### `test.ping`

Triggered by the dashboard **Send test event** button. Same envelope as a real event with a stub payload — use it to validate signature verification in CI.

## Best practices

* **Idempotency.** Store the `X-Wassist-Delivery` ID and reject duplicates. We use the same ID across all retries.
* **Respond fast.** Send a `2xx` within 10 seconds and do real work asynchronously. We treat slow responses as failures and retry.
* **Replay protection.** Reject events where `X-Wassist-Timestamp` is more than 5 minutes from now.
* **Rotate secrets.** From the dashboard, **Rotate secret** generates a new secret. The old one stops working immediately.
* **Local development.** Use the CLI: `wassist listen` tunnels real events to `localhost` without exposing a public URL.

## Replaying deliveries

Every delivery is stored with its full payload. From the dashboard you can:

* Filter deliveries by status (all / failed / succeeded).
* Open a delivery to see request headers, response body, and the timeline of every retry attempt.
* Click **Replay** to send a fresh copy of the same payload (it gets a new `X-Wassist-Delivery` ID).

You can also replay programmatically via [`POST /api/v1/webhook-deliveries/{id}/replay/`](/api-reference/webhooks/replay-delivery).


# Analytics
Source: https://docs.wassist.app/guides/analytics

Monitor your agent's performance, user engagement, and business metrics

Track how your agent is performing with built-in analytics. Understand user behavior, identify improvement opportunities, and measure business impact.

## Dashboard Overview

Your agent dashboard provides at-a-glance metrics:

<CardGroup>
  <Card title="Total Messages" icon="message">
    Total messages sent and received across all conversations.
  </Card>

  <Card title="Total Sessions" icon="users">
    Number of unique conversation sessions.
  </Card>

  <Card title="Active Conversations" icon="comments">
    Currently active conversation threads.
  </Card>

  <Card title="Response Time" icon="clock">
    Average time for your agent to respond.
  </Card>
</CardGroup>

## Key Metrics

### Engagement Metrics

| Metric                   | Description                        | Why It Matters           |
| ------------------------ | ---------------------------------- | ------------------------ |
| **Messages per Session** | Average messages in a conversation | Higher = more engagement |
| **Session Duration**     | How long conversations last        | Indicates value delivery |
| **Return Users**         | Users who start multiple sessions  | Measures stickiness      |
| **Icebreaker Usage**     | Which quick replies are clicked    | Shows user interests     |

### Performance Metrics

| Metric            | Description                    | Why It Matters          |
| ----------------- | ------------------------------ | ----------------------- |
| **Response Time** | Time to generate response      | Affects user experience |
| **Error Rate**    | Failed tool calls or responses | Identifies issues       |
| **Tool Usage**    | Which tools are called most    | Guides optimization     |
| **Handoff Rate**  | Conversations transferred      | Shows automation limits |

### Business Metrics

| Metric              | Description           | Why It Matters        |
| ------------------- | --------------------- | --------------------- |
| **Conversion Rate** | Free → paid users     | Measures monetization |
| **Revenue**         | Total earnings        | Bottom line           |
| **Credits Used**    | Credit consumption    | Usage patterns        |
| **Paywall Hits**    | Users reaching limits | Pricing optimization  |

## Viewing Analytics

<Steps>
  <Step title="Access Dashboard">
    Click on your agent from the [main dashboard](https://wassist.app/agents).
  </Step>

  <Step title="Navigate to Analytics">
    Click the **Analytics** tab in the agent view.
  </Step>

  <Step title="Select Time Range">
    Choose a date range to analyze:

    * Today
    * Last 7 days
    * Last 30 days
    * Custom range
  </Step>

  <Step title="Explore Metrics">
    Use the dashboard to explore different metric categories.
  </Step>
</Steps>

## Conversation Logs

Review actual conversations to understand user behavior:

<Steps>
  <Step title="Go to Conversations">
    In your agent, click the **Conversations** tab.
  </Step>

  <Step title="Filter Conversations">
    Filter by:

    * Date range
    * Status (active/inactive)
    * Country
    * User
  </Step>

  <Step title="View Details">
    Click any conversation to see:

    * Complete message history
    * Tool calls made
    * Context and memory
    * User information
  </Step>
</Steps>

## Understanding User Behavior

### Common Patterns to Look For

<AccordionGroup>
  <Accordion title="Drop-off Points" icon="door-open">
    Where do users stop responding?

    * After a specific question type
    * When a tool fails
    * At the paywall

    **Action:** Improve these friction points.
  </Accordion>

  <Accordion title="Popular Topics" icon="fire">
    What do users ask about most?

    * Most common first messages
    * Frequently used icebreakers
    * Repeated question patterns

    **Action:** Optimize for popular use cases.
  </Accordion>

  <Accordion title="Failed Interactions" icon="circle-xmark">
    When does your agent struggle?

    * "I don't understand" responses
    * Tool errors
    * Handoff triggers

    **Action:** Add training data or tools for these scenarios.
  </Accordion>

  <Accordion title="High-Value Sessions" icon="star">
    What leads to conversions?

    * Session length before purchase
    * Tools used by converting users
    * Common paths to payment

    **Action:** Optimize the conversion funnel.
  </Accordion>
</AccordionGroup>

## Improving Based on Analytics

### Low Engagement

**Symptoms:** Short sessions, few return users

**Solutions:**

* Make the welcome message more engaging
* Add better icebreakers
* Improve response quality
* Reduce response time

### High Drop-off at Paywall

**Symptoms:** Many users hit paywall but don't convert

**Solutions:**

* Increase free message limit
* Lower pricing
* Improve value demonstration before paywall
* Test different CTA messages

### Tool Errors

**Symptoms:** High error rate on specific tools

**Solutions:**

* Check API endpoint health
* Improve error handling
* Add fallback behaviors
* Update tool descriptions

### Slow Response Times

**Symptoms:** Response time > 5 seconds

**Solutions:**

* Optimize tool API performance
* Reduce document size
* Simplify system prompt
* Check for infinite loops

## Exporting Data

Export analytics for further analysis:

1. Go to **Analytics**
2. Click **Export**
3. Choose format (CSV, JSON)
4. Select date range
5. Download file

## SDK Analytics Access

Retrieve metrics programmatically:

```typescript theme={null}
// List conversations with filters
const conversations = await client.conversations.list({
  botId: agentId,
  active: true,
});

// Get conversation details
const conversation = await client.conversations.get(conversationId);

console.log(`Credits remaining: ${conversation.credits}`);
console.log(`Messages: ${(await client.conversations.getMessages(conversationId)).length}`);
```

## Setting Up Alerts

Get notified of important events:

1. Go to **Settings** → **Notifications**
2. Configure alert thresholds:
   * Error rate exceeds X%
   * Response time exceeds X seconds
   * Daily message volume below/above threshold
3. Choose notification method (email, webhook)

## Best Practices

<AccordionGroup>
  <Accordion title="Review Weekly" icon="calendar-week">
    Set aside time each week to review analytics. Look for trends, not just snapshots.
  </Accordion>

  <Accordion title="Compare Periods" icon="arrows-left-right">
    Compare this week to last week. Did changes improve metrics?
  </Accordion>

  <Accordion title="Read Conversations" icon="book-open-reader">
    Numbers tell part of the story. Reading actual conversations reveals the full picture.
  </Accordion>

  <Accordion title="Test Changes" icon="flask">
    When you make changes, give them time to show impact. Wait at least a week before judging.
  </Accordion>
</AccordionGroup>

## What's Next

<CardGroup>
  <Card title="Optimize Your Agent" icon="sliders" href="/guides/configure-tools">
    Use insights to improve performance.
  </Card>

  <Card title="Tune Monetization" icon="dollar-sign" href="/guides/monetization">
    Optimize your pricing strategy.
  </Card>
</CardGroup>


# CLI
Source: https://docs.wassist.app/guides/cli

Drive Wassist from your terminal — send and receive WhatsApp messages, manage numbers, and stream live events while you build.

The Wassist CLI is the fastest way to test agents and webhooks without leaving your terminal. It uses your existing Wassist account and the same `/api/v1` endpoints as the dashboard.

<Note>
  The CLI requires **Node.js 22+** (it uses the built-in `WebSocket` global). See the [GitHub source](https://github.com/wassist/cli) or `@wassist/cli` on npm.
</Note>

## Install

```bash theme={null}
npm install -g @wassist/cli
```

## Authenticate

```bash theme={null}
wassist login
```

You'll be prompted for your phone number, then a 6-digit code arrives on WhatsApp from the **Wassist sandbox number** — the same number you'll send test messages to in a moment.

Confirm you're signed in:

```bash theme={null}
wassist whoami
```

After login the CLI is automatically scoped to your **sandbox conversation** — a one-on-one chat between your personal WhatsApp and the Wassist sandbox number. Sandbox mode means most commands don't need a `[to-number]` argument.

<Tip>
  Switch between sandbox and a real WhatsApp number any time with `wassist use sandbox` or `wassist use <your-number>`.
</Tip>

## Sending messages

<Note>
  WhatsApp only lets you send free-form messages inside an active 24-hour customer-care window. Before your first `messages send`, either **message the Wassist sandbox number from your phone** to open the window, or send a pre-approved **template message** (see [Outside the 24-hour window](#outside-the-24-hour-window) below).
</Note>

The `messages send` command supports the full WhatsApp message envelope — text, media, buttons, and footers — composed via flags.

<Tabs>
  <Tab title="Text">
    ```bash theme={null}
    wassist messages send "Hello from the CLI"
    ```
  </Tab>

  <Tab title="With media">
    ```bash theme={null}
    wassist messages send "Check this out" \
      --media https://picsum.photos/200/300
    ```

    Supported types: JPEG, PNG, MP4, 3GPP, AAC, MP4 audio, MPEG, AMR, OGG, PDF, DOCX, XLSX, PPTX.
  </Tab>

  <Tab title="Quick replies">
    ```bash theme={null}
    wassist messages send "Choose one" \
      --reply "Yes|confirm" \
      --reply "No|deny"
    ```

    Max 3 quick replies. The pipe separates label from the value sent back when tapped.
  </Tab>

  <Tab title="URL button">
    ```bash theme={null}
    wassist messages send "Visit us" \
      --url-button "Shop Now|https://shop.com"
    ```

    Max 1 URL button. URL and quick-reply buttons cannot be mixed in the same message.
  </Tab>
</Tabs>

### Validation rules

* **Text body** — max 1024 characters.
* **Buttons** — max 3 total, all the same type.
* **Media** — must be a publicly reachable HTTPS URL.
* **Button labels** — max 20 characters, formatted `"Label|value"`.

### Outside the 24-hour window

If the conversation's customer-care 24-hour window has lapsed (no inbound user message in the last 24 hours), the CLI prompts you to pick a pre-approved template instead — the same constraint as the WhatsApp Business API enforces directly.

## Streaming inbound messages

`messages listen` opens a WebSocket session, so every inbound WhatsApp message lands in your terminal in real time. Behind the scenes Wassist creates a **managed webhook** for this session and tunnels it through a WebSocket relay — you don't need to expose a public URL.

```bash theme={null}
wassist messages listen --interactive
```

```text theme={null}
─── wassist messages listen ──────────────────────────────
[10:24] customer +447700900200
        Hey, can I add another item to my order?
> Sure! What would you like to add?
```

In interactive mode you can reply inline. The `> ` prompt accepts the same `--media`, `--url-button`, and `--reply` flags as `messages send`:

```text theme={null}
> Here's a photo --media https://picsum.photos/300 --reply "Looks good|yes" --reply "Try another|no"
```

<Tip>
  `messages listen` is ideal when you're iterating on an agent or a webhook handler and want to see events the instant they arrive. It runs alongside your own webhooks — both fire on every inbound message.
</Tip>

## Combining the CLI with webhooks

A common dev loop:

1. Configure your own webhook in the dashboard pointing at your local dev server (via your tunneling tool of choice — ngrok, Cloudflare Tunnel, Tailscale Funnel, etc.).
2. In another terminal, run `wassist messages listen` so you can watch inbound messages while your webhook is processing them.
3. Send a test event from the dashboard ([wassist.app/developers/webhooks](https://wassist.app/developers/webhooks) → your webhook → **Send test event**) or send a real message from your phone.
4. Inspect the delivery in **Developers → Webhooks → Deliveries** for the full request/response timeline, or click **Replay** to re-send it without retyping anything on WhatsApp.

See the [developer quickstart](/quickstart-developers) for an end-to-end walkthrough.

## Moving to your own number

The sandbox is great for development. To message real contacts, connect a WhatsApp Business number:

<Steps>
  <Step title="Upgrade your plan">
    ```bash theme={null}
    wassist upgrade
    ```

    A Wassist subscription is required to connect your own number.
  </Step>

  <Step title="Link your WhatsApp Business Account">
    ```bash theme={null}
    wassist numbers add
    ```

    Opens Meta's embedded signup in your browser so you can pick (or claim) a phone number.
  </Step>

  <Step title="Switch to your number">
    ```bash theme={null}
    wassist numbers list           # see numbers you can use
    wassist use 441234567890       # set the active number
    ```
  </Step>

  <Step title="Send messages to real contacts">
    With your own number active, include the recipient's E.164 number:

    ```bash theme={null}
    wassist messages send 441234567890 "Hey, this is from my own number!"
    wassist messages read 441234567890
    ```
  </Step>
</Steps>

To switch back to the sandbox: `wassist use sandbox`.

## Command reference

### Authentication

| Command          | Description                                   |
| ---------------- | --------------------------------------------- |
| `wassist login`  | Authenticate via WhatsApp OTP.                |
| `wassist whoami` | Show the authenticated user and current plan. |

### Number management

| Command                | Description                                                                |
| ---------------------- | -------------------------------------------------------------------------- |
| `wassist use <number>` | Set the active number. Use `sandbox` to switch back to the shared sandbox. |
| `wassist numbers list` | List all WhatsApp numbers, marking the active one.                         |
| `wassist numbers add`  | Add a new WhatsApp number (Starter plan or above).                         |

### Messaging

In sandbox mode the phone-number argument is optional — the CLI resolves your single sandbox conversation automatically.

| Command                                       | Description                                                                              |
| --------------------------------------------- | ---------------------------------------------------------------------------------------- |
| `wassist messages list`                       | List conversations for the active number.                                                |
| `wassist messages read [phone-number]`        | View messages for a contact. Flags: `--limit <n>`, `--page <n>`.                         |
| `wassist messages send [to-number] [message]` | Send a message. Flags: `--footer`, `--media`, `--url-button`, `--reply` (repeatable).    |
| `wassist messages listen [phone-number]`      | Stream inbound messages over WebSocket. Flag: `-i` / `--interactive` for inline replies. |

### Billing

| Command           | Description                     |
| ----------------- | ------------------------------- |
| `wassist upgrade` | Upgrade your subscription plan. |

## Configuration

The CLI stores its auth token and active number locally via [conf](https://github.com/sindresorhus/conf). The default backend is `https://backend.wassist.app`; this can be overridden in the config file for development.

## Policies

By sending messages through the Wassist CLI you agree to:

* [WhatsApp Business Policy](https://business.whatsapp.com/policy) — opt-in, prohibited content, frequency, and platform rules.
* [Meta AI Provider pricing policy](https://developers.facebook.com/documentation/business-messaging/whatsapp/pricing/ai-providers/) — per-message pricing for AI-driven non-template messages in certain markets.

Violations may restrict your WhatsApp Business Account or Wassist account.


# Configure Tools
Source: https://docs.wassist.app/guides/configure-tools

Connect your agent to external APIs and services for real-time data and actions

Tools let your agent interact with external systems—checking inventory, booking appointments, processing payments, or anything your API can do.

## How Tools Work

When a user asks a question that requires external data, your agent:

1. Recognizes the need to call a tool
2. Extracts relevant parameters from the conversation
3. Calls your API endpoint
4. Interprets the response
5. Replies to the user

<Frame>
  ```mermaid theme={null}
  sequenceDiagram
      participant User
      participant Agent
      participant Tool as External API
      
      User->>Agent: "What's my order status?"
      Agent->>Agent: Identify: need order_lookup tool
      Agent->>Tool: GET /orders/12345
      Tool->>Agent: {"status": "shipped", "eta": "Dec 28"}
      Agent->>User: "Your order has shipped and should arrive by Dec 28!"
  ```
</Frame>

## Types of Tools

<AccordionGroup>
  <Accordion title="API Tools" icon="code">
    Connect to any REST API. You define the endpoint, parameters, and how to interpret responses.

    **Examples:**

    * Order lookup
    * Appointment booking
    * Inventory check
    * CRM updates
  </Accordion>

  <Accordion title="Website Tools" icon="globe">
    Let your agent fetch and read web pages in real-time.

    **Examples:**

    * Check current pricing
    * Read latest blog posts
    * Verify stock on your website
  </Accordion>

  <Accordion title="Image Generation Tools" icon="image">
    Generate images based on user requests using AI.

    **Examples:**

    * Create custom graphics
    * Generate product mockups
  </Accordion>

  <Accordion title="Handoff Tools" icon="arrow-right-arrow-left">
    Transfer the conversation to another agent or human.

    **Examples:**

    * Escalate to support
    * Transfer to sales
    * Route to specialist
  </Accordion>

  <Accordion title="MCP Connectors" icon="server">
    Connect to Model Context Protocol servers for complex integrations.

    **Examples:**

    * Database access
    * File system operations
    * Custom business logic
  </Accordion>
</AccordionGroup>

## Creating an API Tool

<Steps>
  <Step title="Open Your Agent">
    Go to your agent and navigate to the **Tools** section.
  </Step>

  <Step title="Add New Tool">
    Click **Add Tool** and select **API Tool**.
  </Step>

  <Step title="Define the Tool">
    Fill in the tool configuration:

    | Field           | Description                                | Example                                                       |
    | --------------- | ------------------------------------------ | ------------------------------------------------------------- |
    | **Name**        | A clear, descriptive name                  | `check_order_status`                                          |
    | **Description** | When should the agent use this tool?       | "Use this tool when a customer asks about their order status" |
    | **API Schema**  | OpenAPI-style schema defining the endpoint | See below                                                     |
  </Step>

  <Step title="Configure the Schema">
    Define your API endpoint using a JSON schema:

    ```json theme={null}
    {
      "type": "object",
      "properties": {
        "endpoint": {
          "type": "string",
          "const": "https://api.yourstore.com/orders/{order_id}"
        },
        "method": {
          "type": "string",
          "const": "GET"
        },
        "parameters": {
          "type": "object",
          "properties": {
            "order_id": {
              "type": "string",
              "description": "The customer's order number"
            }
          },
          "required": ["order_id"]
        },
        "headers": {
          "type": "object",
          "properties": {
            "Authorization": {
              "type": "string",
              "const": "Bearer your-api-key"
            }
          }
        }
      }
    }
    ```
  </Step>

  <Step title="Test the Tool">
    Use the test panel to verify the tool works:

    1. Enter sample parameter values
    2. Click **Test**
    3. Review the API response
  </Step>

  <Step title="Save and Enable">
    Toggle the tool to **Active** and save your agent.
  </Step>
</Steps>

## Tool Best Practices

<AccordionGroup>
  <Accordion title="Write Clear Descriptions" icon="pencil">
    The description tells the AI when to use the tool. Be specific:

    **Good:**

    > "Use this tool when the customer wants to know the status of their order. Requires an order number in format ORD-XXXXX."

    **Less effective:**

    > "Order lookup"
  </Accordion>

  <Accordion title="Handle Errors Gracefully" icon="triangle-exclamation">
    Your API should return clear error messages. In your system prompt, add instructions for handling failures:

    > "If an order lookup fails, apologize and ask the customer to verify their order number. If it fails again, offer to connect them with support."
  </Accordion>

  <Accordion title="Secure Your API" icon="lock">
    * Use API keys or OAuth tokens
    * Implement rate limiting
    * Validate input parameters
    * Never expose sensitive data in responses
  </Accordion>

  <Accordion title="Keep Responses Simple" icon="compress">
    Return only what the agent needs. Large, complex responses slow down the conversation and may confuse the AI.

    **Good response:**

    ```json theme={null}
    {
      "order_id": "ORD-12345",
      "status": "shipped",
      "eta": "2024-12-28",
      "tracking_url": "https://..."
    }
    ```
  </Accordion>
</AccordionGroup>

## Creating a Website Tool

Website tools let your agent read web pages in real-time:

<Steps>
  <Step title="Add Website Tool">
    In the **Tools** section, click **Add Tool** → **Website Tool**.
  </Step>

  <Step title="Configure the Tool">
    | Field      | Description                      |
    | ---------- | -------------------------------- |
    | **URL**    | The page to fetch                |
    | **Prompt** | Instructions for what to extract |
  </Step>

  <Step title="Example Configuration">
    ```
    URL: https://yourstore.com/products/widget

    Prompt: Extract the current price, availability status, 
    and key features from this product page.
    ```
  </Step>
</Steps>

## Creating an Image Generation Tool

<Steps>
  <Step title="Add Image Tool">
    Click **Add Tool** → **Image Generation**.
  </Step>

  <Step title="Configure the Tool">
    | Field               | Description                      |
    | ------------------- | -------------------------------- |
    | **Name**            | Tool name (e.g., `create_logo`)  |
    | **Description**     | When to use it                   |
    | **Prompt Template** | Base prompt for image generation |
    | **Credit Cost**     | How many credits this uses       |
  </Step>
</Steps>

## Creating a Handoff Tool

Transfer conversations to other agents or humans:

<Steps>
  <Step title="Add Handoff Tool">
    Click **Add Tool** → **Handoff**.
  </Step>

  <Step title="Configure the Tool">
    | Field           | Description                  |
    | --------------- | ---------------------------- |
    | **Child Agent** | The agent to transfer to     |
    | **Description** | When to initiate the handoff |
  </Step>

  <Step title="Example Use Cases">
    * General agent → Billing specialist
    * Sales agent → Technical support
    * Bot → Human operator
  </Step>
</Steps>

## Connecting MCP Servers

For advanced integrations, connect Model Context Protocol servers:

<Steps>
  <Step title="Add Connector">
    Go to **Settings** → **Integrations** → **Add Connector**.
  </Step>

  <Step title="Enter Server URL">
    Provide the MCP server URL:

    ```
    https://your-mcp-server.com
    ```
  </Step>

  <Step title="Authenticate (if required)">
    Some MCP servers require authentication. Complete any OAuth flow or enter credentials.
  </Step>

  <Step title="Add to Agent">
    In your agent's **Tools** section:

    1. Click **Add Tool** → **MCP Connector**
    2. Select the connector
    3. Choose which tools to enable (whitelist)
  </Step>
</Steps>

## Tool Credits

Some tools cost credits to use:

| Field           | Purpose                            |
| --------------- | ---------------------------------- |
| **Credit Cost** | Credits deducted when tool is used |

Configure credit costs per tool in the tool settings. Users with monetization enabled will have credits deducted automatically.

## SDK Alternative

Manage tools programmatically:

```typescript theme={null}
// Update agent with tools
const updatedAgent = await client.agents.update(agentId, {
  tools: [
    {
      name: 'check_order_status',
      description: 'Look up order status by order number',
      apiSchema: {
        type: 'object',
        properties: {
          endpoint: {
            type: 'string',
            const: 'https://api.yourstore.com/orders/{order_id}'
          },
          method: { type: 'string', const: 'GET' },
          parameters: {
            type: 'object',
            properties: {
              order_id: { type: 'string', description: 'Order number' }
            },
            required: ['order_id']
          }
        }
      },
      active: true,
      creditCost: 0
    }
  ]
});
```

## What's Next

<CardGroup>
  <Card title="Set Up Monetization" icon="dollar-sign" href="/guides/monetization">
    Charge credits for tool usage.
  </Card>

  <Card title="View Analytics" icon="chart-line" href="/guides/analytics">
    Monitor tool usage and performance.
  </Card>
</CardGroup>


# Connect Your WhatsApp Business Account
Source: https://docs.wassist.app/guides/connect-whatsapp

Link your WhatsApp Business account to deploy agents on your own phone numbers

To deploy agents to production with your own phone numbers and business branding, you need to connect a WhatsApp Business Account (WABA).

## Why Connect Your Own Account?

| Feature           | Test Mode             | Your WABA                       |
| ----------------- | --------------------- | ------------------------------- |
| Phone number      | Shared Wassist number | Your dedicated number(s)        |
| Business name     | Generic               | Your company name               |
| Verified badge    | No                    | Possible (via Meta)             |
| Message templates | Limited               | Full access                     |
| Messaging limits  | Low                   | Scales with reputation          |
| Business profile  | None                  | Custom logo, description, hours |

## Getting Started

You have several options for connecting WhatsApp to your agents:

<CardGroup>
  <Card title="Connect Your Own Account" icon="building">
    Bring your existing WhatsApp Business Account or create a new one through Meta's signup flow.
  </Card>

  <Card title="Use WhatsApp Business App" icon="mobile">
    Migrate from the WhatsApp Business App to the API platform.
  </Card>

  <Card title="Free Test Number" icon="flask">
    Get a free test number while waiting for Meta approval—perfect for development.
  </Card>

  <Card title="Wassist UK Line" icon="phone">
    Use a Wassist-provided dedicated UK phone number—no setup required.
  </Card>
</CardGroup>

## Prerequisites

To connect your own WhatsApp Business Account, you need:

* A **Facebook account** (personal account is fine—you can create a Business account during signup)

That's it! The WhatsApp Accounts page in Wassist guides you through creating or connecting everything else.

<Tip>
  Don't have your own phone number to use? Choose a **Wassist UK Line** or start with a **Free Test Number** to get started immediately.
</Tip>

## Connecting Your Own Account

<Steps>
  <Step title="Go to WhatsApp Accounts">
    In your Wassist dashboard, navigate to **WhatsApp Accounts** from the sidebar.
  </Step>

  <Step title="Choose Connection Method">
    Click **Connect WhatsApp Account** and select your preferred option:

    * **Connect existing WABA** — If you already have a WhatsApp Business Account
    * **Create new account** — Start fresh with Meta's Embedded Signup
    * **Migrate from Business App** — Move from WhatsApp Business App to the API
  </Step>

  <Step title="Log into Facebook">
    Sign in with your Facebook account. If you don't have a Facebook Business account yet, you can create one during this process.
  </Step>

  <Step title="Configure Your Business">
    For new accounts, enter:

    * Business display name
    * Business category
    * Business description

    For existing accounts, select your WhatsApp Business Account from the list.
  </Step>

  <Step title="Add a Phone Number">
    Choose how to get your number:

    * **Your own number** — Enter and verify via SMS or voice call
    * **Free test number** — Get a temporary number for development
    * **Wassist UK line** — Use a dedicated UK number we provide
  </Step>

  <Step title="Complete Setup">
    Once connected, you're redirected back to Wassist. Your WhatsApp account appears in the list, ready to deploy agents.
  </Step>
</Steps>

## Using a Wassist-Provided Number

If you don't want to use your own phone number, Wassist offers dedicated UK lines:

1. Go to **WhatsApp Accounts**
2. Click **Get a Wassist Number**
3. Select an available UK number
4. Your number is instantly ready—no verification needed

<Note>
  Wassist-provided numbers have the same capabilities as your own numbers. They're ideal for getting started quickly or for businesses that don't need a specific phone number.
</Note>

## Using a Free Test Number

While waiting for Meta to approve your business, you can use a free test number:

1. During the connection flow, select **Use test number**
2. You'll receive a temporary number for development
3. Once approved, you can migrate to your permanent number

Test numbers have some limitations:

* Can only message numbers you've registered as testers
* Limited messaging volume
* Not suitable for production use

## Understanding WhatsApp Business Account Structure

<Frame>
  ```mermaid theme={null}
  flowchart TD
      FBBusiness[Facebook Business Account]
      FBBusiness --> WABA[WhatsApp Business Account]
      WABA --> Phone1[Phone Number 1]
      WABA --> Phone2[Phone Number 2]
      Phone1 --> Agent1[Agent A]
      Phone2 --> Agent2[Agent B]
  ```
</Frame>

* **Facebook Business Account** — Your company's presence on Facebook
* **WhatsApp Business Account (WABA)** — Container for your WhatsApp presence
* **Phone Numbers** — Individual numbers under your WABA
* **Agents** — You can deploy different agents to different numbers

## Adding More Phone Numbers

Once connected, you can add additional phone numbers:

1. Go to **Settings** → **WhatsApp Accounts**
2. Click on your connected account
3. Click **Add Phone Number**
4. Follow the verification process

<Tip>
  You can have multiple phone numbers under one WABA—useful for different departments, regions, or products.
</Tip>

## Using Pre-Verified Numbers

If you have phone numbers pre-verified through Twilio or another provider, you can add them without the verification step:

1. Go to **Settings** → **WhatsApp Accounts**
2. Click **Add Pre-Verified Number**
3. Select from available pre-verified numbers
4. Choose which WABA to add it to

## Business Verification

Meta may require business verification for higher messaging limits and the verified badge. This involves:

1. Submitting official business documents
2. Meta reviewing your business
3. Approval (typically 2-10 business days)

You can start this process from:

* Meta Business Suite → Settings → Business Verification
* Or follow prompts in Wassist when limits are reached

## Setting Up Your Business Profile

After connecting, customize your WhatsApp Business Profile:

1. Go to **Settings** → **WhatsApp Accounts**
2. Click on your account
3. Click **Edit Profile**
4. Fill in:
   * **About** — Short description (max 139 characters)
   * **Address** — Your business location
   * **Email** — Contact email
   * **Website** — Your website URLs
   * **Category** — Business category
   * **Profile Picture** — Your logo (recommended: 640x640px)

<Note>
  Changes to your business profile may take up to 24 hours to appear on all users' devices.
</Note>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Connection failed or was interrupted" icon="triangle-exclamation">
    If the connection process fails:

    1. Clear your browser cookies
    2. Try a different browser
    3. Ensure pop-ups are allowed for the Wassist site
    4. Try again from **WhatsApp Accounts**
  </Accordion>

  <Accordion title="Want to use your own number but it's on WhatsApp" icon="phone-slash">
    If you want to use a number that's already active on WhatsApp or WhatsApp Business:

    1. Open WhatsApp on that phone
    2. Delete your WhatsApp account (Settings → Account → Delete my account)
    3. Wait 24 hours
    4. Try connecting again

    Alternatively, use a **Wassist UK line** or **free test number** to get started immediately.
  </Accordion>

  <Accordion title="Verification code not received" icon="envelope-open-text">
    If you don't receive the SMS/call when verifying your own number:

    1. Check the number is correct (including country code)
    2. Ensure the phone can receive SMS/calls
    3. Try the alternative verification method
    4. Wait a few minutes and request a new code
  </Accordion>

  <Accordion title="Business verification required" icon="building">
    For higher messaging limits and the verified badge, Meta requires business verification. This is separate from phone verification and requires official documents. You can still use your agent while verification is pending.
  </Accordion>

  <Accordion title="Which option should I choose?" icon="circle-question">
    * **Just testing?** → Use a free test number
    * **Ready for production but no number?** → Get a Wassist UK line
    * **Have an existing WhatsApp Business Account?** → Connect your existing WABA
    * **Using WhatsApp Business App?** → Migrate to the API platform
    * **Want your own branded number?** → Connect your own account with your number
  </Accordion>
</AccordionGroup>

## SDK Alternative

Create a WhatsApp link session programmatically:

```typescript theme={null}
// Create a link session
const session = await client.whatsappLinkSessions.create({
  successUrl: 'https://yourapp.com/whatsapp/success',
  returnUrl: 'https://yourapp.com/whatsapp/return',
});

// Redirect user to the link URL
window.location.href = session.linkUrl;

// After redirect, check status
const updatedSession = await client.whatsappLinkSessions.get(session.id);
if (updatedSession.status === 'SUCCESS') {
  // Account connected successfully
}
```

## What's Next

<CardGroup>
  <Card title="Deploy Your Agent" icon="rocket" href="/guides/deploy-agent">
    Assign an agent to your connected phone number.
  </Card>

  <Card title="Message Templates" icon="file-lines" href="/api-reference/whatsapp-account/proxy/post">
    Create templates for outbound messaging.
  </Card>
</CardGroup>


# Create Agent from an Idea
Source: https://docs.wassist.app/guides/create-agent-idea

Turn a simple text description into a fully-functional WhatsApp AI agent

The fastest way to create an agent is to describe what you want in plain language. Wassist uses AI to generate a complete agent configuration from your description.

## When to Use This Method

This approach works best when you:

* Have a clear concept but no existing content
* Want to quickly prototype an idea
* Are building a simple conversational agent

## Step-by-Step Guide

<Steps>
  <Step title="Navigate to New Agent">
    From your [dashboard](https://wassist.app/agents), click the **New Agent** button in the top right corner.
  </Step>

  <Step title="Select 'Start from an Idea'">
    You'll see several options for creating your agent. Choose **Start from an Idea**.
  </Step>

  <Step title="Describe Your Agent">
    Write a detailed description of what you want your agent to do. The more specific you are, the better the results.

    **Good example:**

    > "A concierge agent for The Grand Hotel. It should help guests with:
    >
    > * Room service orders (available 6am-11pm)
    > * Spa appointment bookings
    > * Restaurant reservations at our three restaurants
    > * Local attraction recommendations
    >
    > The tone should be warm and professional. The hotel is located in downtown Seattle."

    **Less effective example:**

    > "A hotel helper bot"
  </Step>

  <Step title="Review and Edit">
    Wassist generates:

    * **System Prompt** — The instructions that guide your agent's behavior
    * **First Message** — The welcome message users see
    * **Icebreakers** — Suggested conversation starters

    Review each section and edit as needed. You can always refine these later.
  </Step>

  <Step title="Create Agent">
    Click **Create Agent** to save your configuration. You'll be taken to the agent editor where you can test and further customize.
  </Step>
</Steps>

## Tips for Better Results

<AccordionGroup>
  <Accordion title="Be specific about scope" icon="bullseye">
    Clearly define what your agent should and shouldn't handle. This helps set user expectations and keeps conversations focused.

    > "This agent only handles billing questions. For technical support, it should direct users to call 1-800-SUPPORT."
  </Accordion>

  <Accordion title="Include key facts" icon="list-check">
    Any information the agent needs to know should be in your description: hours, locations, prices, policies.

    > "We're open Monday-Friday 9am-5pm EST. Shipping is free on orders over \$50."
  </Accordion>

  <Accordion title="Define the personality" icon="face-smile">
    Describe the tone and communication style you want.

    > "Friendly and casual, using emojis occasionally. Never use corporate jargon."
  </Accordion>

  <Accordion title="Specify language" icon="language">
    If your agent should respond in a specific language or handle multiple languages, mention it.

    > "Respond in Spanish. If the user writes in English, politely respond in Spanish."
  </Accordion>
</AccordionGroup>

## Example Descriptions

<Tabs>
  <Tab title="Customer Support">
    ```
    A customer support agent for TechGadgets Inc., an electronics retailer.

    Key responsibilities:
    - Answer questions about our return policy (30 days, original packaging required)
    - Help track orders using order numbers (format: TG-XXXXX)
    - Explain warranty coverage (1 year manufacturer warranty on all items)
    - Escalate complex issues to human support

    Tone: Professional but approachable. Patient with frustrated customers.
    Hours: We have support staff available M-F 9am-6pm PST.
    ```
  </Tab>

  <Tab title="Restaurant">
    ```
    A reservation assistant for Bella Italia restaurant.

    We're a family-owned Italian restaurant in Chicago, open for dinner
    Tuesday-Sunday from 5pm-10pm. We're closed Mondays.

    The agent should help with:
    - Table reservations (we can seat up to 60 guests)
    - Menu questions (we have vegetarian and gluten-free options)
    - Directions (we're at 456 Oak Street, valet parking available)

    Tone: Warm and welcoming, like talking to a friendly host.
    ```
  </Tab>

  <Tab title="Personal Brand">
    ```
    I'm a fitness coach named Alex. This agent represents me when I'm not available.

    It should:
    - Share my workout philosophy (functional fitness, sustainable habits)
    - Provide sample exercises from my free content
    - Direct serious inquiries to book a consultation at alexfitness.com/book
    - Never give specific medical or nutrition advice

    Tone: Motivating and energetic, like a personal trainer cheering you on.
    Use first person as if I'm speaking directly.
    ```
  </Tab>
</Tabs>

## What's Next

After creating your agent, you can:

<CardGroup>
  <Card title="Test Your Agent" icon="flask" href="/quickstart#step-2-test-your-agent">
    Send test messages to see how it responds.
  </Card>

  <Card title="Add Knowledge" icon="book" href="/guides/create-agent-knowledge-base">
    Upload documents for more detailed responses.
  </Card>

  <Card title="Connect Tools" icon="plug" href="/guides/configure-tools">
    Let your agent call external APIs.
  </Card>

  <Card title="Deploy to WhatsApp" icon="whatsapp" href="/guides/deploy-agent">
    Get a dedicated phone number for your agent.
  </Card>
</CardGroup>

## SDK Alternative

Create an agent from an idea programmatically:

```typescript theme={null}
const agent = await client.onboarding.createFromIdea({
  idea: `A customer support agent for TechGadgets Inc...`,
});
```

<Card title="SDK Documentation" icon="code" href="/sdk/overview">
  Learn more about the TypeScript SDK.
</Card>


# Create Agent from Shopify
Source: https://docs.wassist.app/guides/create-agent-shopify

Build a WhatsApp shopping assistant for your Shopify store in minutes

Connect your Shopify store to create an AI agent that knows your products, handles customer questions, and can check orders in real-time.

## What You Get

A Shopify-connected agent can:

* **Answer product questions** — Details, availability, pricing
* **Help with orders** — Check order status, shipping updates
* **Handle returns** — Explain your return policy, initiate return requests
* **Provide recommendations** — Suggest products based on customer needs
* **Share collection links** — Direct customers to relevant product pages

## Prerequisites

Before you begin:

* A Shopify store with products listed
* Admin access to your Shopify account
* A Wassist account ([sign up free](https://wassist.app/login))

## Step-by-Step Guide

<Steps>
  <Step title="Navigate to New Agent">
    From your [dashboard](https://wassist.app/agents), click **New Agent**.
  </Step>

  <Step title="Select 'Connect Shopify'">
    Choose the **Connect Shopify** option.
  </Step>

  <Step title="Enter Your Store URL">
    Provide your Shopify store URL:

    ```
    https://your-store.myshopify.com
    ```

    or your custom domain:

    ```
    https://www.yourstore.com
    ```
  </Step>

  <Step title="Authorize Wassist">
    You'll be redirected to Shopify to authorize Wassist. Grant the requested permissions so we can:

    * Read your product catalog
    * Access order information (for order status queries)
    * Read customer data (for personalized support)

    <Note>
      Wassist only reads data from your store. We never modify your products, orders, or customer records.
    </Note>
  </Step>

  <Step title="Wait for Sync">
    Wassist imports your:

    * Products and variants
    * Collections
    * Store policies (shipping, returns, etc.)
    * Store information

    This typically takes 2-5 minutes depending on catalog size.
  </Step>

  <Step title="Customize Your Agent">
    Review the generated agent and customize:

    * Adjust the welcome message
    * Add specific instructions for your brand voice
    * Configure which features to enable (order lookup, etc.)
  </Step>
</Steps>

## Agent Capabilities

<AccordionGroup>
  <Accordion title="Product Discovery" icon="magnifying-glass">
    Customers can ask natural language questions about your products:

    * "Do you have any red dresses under \$100?"
    * "What sizes is the Classic T-shirt available in?"
    * "Show me your best-selling items"

    The agent searches your catalog and returns relevant products with images and links.
  </Accordion>

  <Accordion title="Order Tracking" icon="truck">
    Customers can check their order status:

    * "Where is my order?"
    * "What's the status of order #1234?"

    The agent looks up order details and provides shipping updates.

    <Note>
      Customers must verify their identity (usually via the phone number they ordered with) before accessing order details.
    </Note>
  </Accordion>

  <Accordion title="Policy Questions" icon="file-contract">
    Your store policies are automatically imported:

    * "What's your return policy?"
    * "How long does shipping take?"
    * "Do you ship internationally?"
  </Accordion>

  <Accordion title="Collection Browsing" icon="layer-group">
    Direct customers to relevant collections:

    * "Show me your summer collection"
    * "What's new this week?"
  </Accordion>
</AccordionGroup>

## Configuring Order Lookup

To enable order status queries:

1. Go to your agent's **Tools** section
2. Enable **Order Lookup**
3. Configure verification method:
   * **Phone Number Match** — The customer's WhatsApp number must match the order
   * **Order Number + Email** — Customer provides order number and email

<Warning>
  Always require verification before sharing order details. This protects your customers' privacy.
</Warning>

## Keeping Products Synced

Your Shopify catalog updates automatically every 24 hours. For immediate sync:

1. Go to your agent's **Settings**
2. Click **Sync Now** under Shopify Integration

<Tip>
  Major catalog updates (new collections, sales events) should trigger a manual sync to ensure your agent has the latest information.
</Tip>

## Customizing Product Responses

Control how your agent presents products:

```
System Prompt Addition:

When showing products:
- Always mention if an item is on sale
- Include available sizes and colors
- Offer to check inventory for specific sizes
- End product recommendations with "Would you like me to send you the link to purchase?"
```

## Example Conversations

<Tabs>
  <Tab title="Product Search">
    **Customer:** I'm looking for a gift for my mom. She likes gardening.

    **Agent:** I'd love to help you find the perfect gift! We have several items that gardeners love:

    🌱 **Garden Tool Set** - \$45.00
    Premium stainless steel tools with ergonomic handles

    🌸 **Floral Apron** - \$28.00
    Water-resistant with deep pockets

    🪴 **Indoor Herb Kit** - \$35.00
    Grow basil, mint, and cilantro at home

    Would you like more details on any of these?
  </Tab>

  <Tab title="Order Status">
    **Customer:** Where's my order? I ordered 3 days ago.

    **Agent:** I'd be happy to check on that for you! I can see you're messaging from the phone number associated with a recent order.

    📦 **Order #1847**
    Status: Shipped
    Carrier: USPS
    Tracking: 9400111899223847562

    It's currently in transit and expected to arrive by Friday. Would you like me to send you the tracking link?
  </Tab>
</Tabs>

## SDK Alternative

Create a Shopify agent programmatically:

```typescript theme={null}
const agent = await client.onboarding.createFromShopify({
  shopifyUrl: 'https://your-store.myshopify.com',
});
```

## What's Next

<CardGroup>
  <Card title="Add Custom Tools" icon="plug" href="/guides/configure-tools">
    Connect additional APIs like loyalty programs or reviews.
  </Card>

  <Card title="Set Up Monetization" icon="dollar-sign" href="/guides/monetization">
    Offer premium support tiers.
  </Card>

  <Card title="Deploy to WhatsApp" icon="rocket" href="/guides/deploy-agent">
    Go live with your shopping assistant.
  </Card>
</CardGroup>


# Create Agent from a Website
Source: https://docs.wassist.app/guides/create-agent-website

Import your website content to create an AI agent that knows your business

If you have an existing website, Wassist can crawl it to automatically create an agent that understands your business, products, and services.

## When to Use This Method

This approach is ideal when you:

* Have a content-rich website with product/service information
* Want your agent to answer questions based on existing web content
* Need a quick way to bootstrap an agent with accurate information

## Step-by-Step Guide

<Steps>
  <Step title="Navigate to New Agent">
    From your [dashboard](https://wassist.app/agents), click **New Agent**.
  </Step>

  <Step title="Select 'Import from Website'">
    Choose the **Import from Website** option.
  </Step>

  <Step title="Enter Your Website URL">
    Provide your website's URL. Wassist will crawl the site to extract content.

    ```
    https://www.yourcompany.com
    ```

    <Note>
      The crawler follows links from your homepage. For best results, ensure your site has clear navigation to important pages.
    </Note>
  </Step>

  <Step title="Wait for Processing">
    Wassist crawls your website and uses AI to:

    * Extract key information about your business
    * Identify products, services, and FAQs
    * Generate a system prompt based on your content

    This typically takes 1-3 minutes depending on site size.
  </Step>

  <Step title="Review and Customize">
    Once processing completes, review the generated agent:

    * **System Prompt** — Check that it accurately represents your business
    * **First Message** — Ensure the welcome message is appropriate
    * **Knowledge** — Verify the extracted content is correct

    Edit anything that needs adjustment.
  </Step>
</Steps>

## What Gets Imported

<AccordionGroup>
  <Accordion title="Text Content" icon="file-lines">
    All readable text from your pages, including headings, paragraphs, and lists. This becomes the agent's knowledge base.
  </Accordion>

  <Accordion title="Product Information" icon="box">
    If you have product pages, Wassist extracts names, descriptions, and details so your agent can answer product questions.
  </Accordion>

  <Accordion title="Contact Details" icon="address-card">
    Business hours, locations, phone numbers, and email addresses are captured so your agent can provide accurate contact information.
  </Accordion>

  <Accordion title="FAQs" icon="circle-question">
    If your site has an FAQ section, those questions and answers are prioritized in the agent's knowledge.
  </Accordion>
</AccordionGroup>

## Improving Import Quality

<Tabs>
  <Tab title="Before Import">
    **Optimize your website for better results:**

    * Ensure important pages are linked from your homepage
    * Use clear, descriptive headings
    * Keep content up-to-date
    * Include an FAQ page if you have common questions
  </Tab>

  <Tab title="After Import">
    **Refine your agent:**

    * Edit the system prompt to add context the crawler might have missed
    * Remove any irrelevant content from the knowledge base
    * Add specific instructions for edge cases
    * Test with real questions your customers ask
  </Tab>
</Tabs>

## Handling Dynamic Content

<Warning>
  Wassist crawls static HTML content. If your site relies heavily on JavaScript to load content, some information may not be captured. Consider:

  * Using the [Knowledge Base](/guides/create-agent-knowledge-base) method to upload content directly
  * Adding missing information to the system prompt manually
</Warning>

## Example Use Cases

<CardGroup>
  <Card title="E-commerce Store" icon="cart-shopping">
    Import your product catalog so customers can ask about items, shipping, and returns.
  </Card>

  <Card title="SaaS Documentation" icon="book">
    Create a support agent from your docs site to answer technical questions.
  </Card>

  <Card title="Service Business" icon="briefcase">
    Import your services page so prospects can learn about what you offer.
  </Card>

  <Card title="Restaurant/Venue" icon="utensils">
    Pull in your menu, hours, and event information automatically.
  </Card>
</CardGroup>

## Keeping Content Fresh

Website content changes over time. To update your agent's knowledge:

1. Go to your agent's **Documents** section
2. Click **Refresh from Website**
3. Wassist re-crawls your site and updates the knowledge base

<Tip>
  Set a reminder to refresh your agent's knowledge monthly, or whenever you make significant website updates.
</Tip>

## SDK Alternative

Create an agent from a website URL programmatically:

```typescript theme={null}
const agent = await client.onboarding.createFromWebsite({
  websiteUrl: 'https://www.yourcompany.com',
});

console.log(`Agent created: ${agent.name}`);
```

## What's Next

<CardGroup>
  <Card title="Add More Knowledge" icon="file-arrow-up" href="/guides/create-agent-knowledge-base">
    Supplement with additional documents.
  </Card>

  <Card title="Configure Tools" icon="plug" href="/guides/configure-tools">
    Connect APIs for real-time data.
  </Card>

  <Card title="Deploy to WhatsApp" icon="rocket" href="/guides/deploy-agent">
    Make your agent live.
  </Card>
</CardGroup>


# Deploy Your Agent
Source: https://docs.wassist.app/guides/deploy-agent

Make your agent live on a WhatsApp phone number

Once you've created and tested your agent, deploy it to a phone number so users can start real conversations.

## Deployment Options

<CardGroup>
  <Card title="Test Number" icon="flask">
    **Free, shared Wassist number**

    * Great for testing and demos
    * No setup required
    * Shared with other Wassist users
    * Limited features
  </Card>

  <Card title="Dedicated Number" icon="phone">
    **Your own WhatsApp Business number**

    * Your brand, your number
    * Full WhatsApp Business features
    * Message templates
    * Business profile
  </Card>
</CardGroup>

## Using the Test Number

Every agent has access to Wassist's shared test number. To use it:

1. Open your agent in the editor
2. Click **Test Agent** in the top right
3. Scan the QR code with WhatsApp
4. Start chatting

<Note>
  The test number is shared across all Wassist users and doesn't support business profiles or templates. For production use, connect your own WhatsApp Business Account.
</Note>

## Deploying to Your Number

<Steps>
  <Step title="Connect WhatsApp (if needed)">
    If you haven't already, [connect your WhatsApp Business Account](/guides/connect-whatsapp).
  </Step>

  <Step title="Open Your Agent">
    Go to your [dashboard](https://wassist.app/agents) and click on the agent you want to deploy.
  </Step>

  <Step title="Go to Deployment Settings">
    Click the **Deploy** tab or button in the agent editor.
  </Step>

  <Step title="Select Phone Number">
    Choose which phone number to deploy to:

    * See all available numbers from your connected WABAs
    * Each number can only have one active agent

    <Warning>
      If a number already has an agent, deploying a new agent will replace it.
    </Warning>
  </Step>

  <Step title="Confirm Deployment">
    Click **Deploy** to make your agent live. The change takes effect immediately.
  </Step>
</Steps>

## What Happens After Deployment

Once deployed:

1. **New conversations** — Anyone messaging your number will chat with your agent
2. **Existing conversations** — Active conversations continue with the new agent
3. **Webhook updates** — All WhatsApp webhooks route to your deployed agent

## Managing Deployments

### Viewing Active Deployments

To see where your agents are deployed:

1. Go to **Settings** → **WhatsApp Accounts**
2. Click on an account to see its phone numbers
3. Each number shows which agent (if any) is deployed

Or view from the agent side:

1. Open any agent
2. The **Deployment** section shows connected numbers

### Changing Deployments

To swap which agent is on a number:

1. Open the new agent you want to deploy
2. Deploy it to the number
3. The old agent is automatically undeployed

### Undeploying an Agent

To remove an agent from a number without replacing it:

1. Go to **Settings** → **WhatsApp Accounts**
2. Click on the account and number
3. Click **Remove Agent**

The number will no longer respond to messages until you deploy another agent.

## Deployment Checklist

Before going live, verify:

<AccordionGroup>
  <Accordion title="Agent Configuration" icon="gear">
    * [ ] System prompt is complete and accurate
    * [ ] First message is welcoming and clear
    * [ ] Icebreakers are helpful
    * [ ] Profile picture is set
  </Accordion>

  <Accordion title="Testing Complete" icon="check-double">
    * [ ] Tested common user questions
    * [ ] Verified tool integrations work
    * [ ] Checked edge cases and error handling
    * [ ] Tested on mobile device
  </Accordion>

  <Accordion title="Business Profile" icon="building">
    * [ ] Business name is correct
    * [ ] Description is complete
    * [ ] Contact information is accurate
    * [ ] Profile picture is professional
  </Accordion>

  <Accordion title="Monetization (if applicable)" icon="dollar-sign">
    * [ ] Paywall settings configured
    * [ ] Credit limits set appropriately
    * [ ] Payment links working
  </Accordion>
</AccordionGroup>

## Promoting Your Agent

Once deployed, share your agent with the world:

### QR Code

Every phone number has a WhatsApp QR code. When scanned, it opens a chat with your agent.

1. Go to your agent's **Deploy** section
2. Click **Get QR Code**
3. Download for use in marketing materials

### Direct Link

Share a click-to-chat link:

```
https://wa.me/1234567890?text=Hello!
```

Replace `1234567890` with your phone number (no plus sign or spaces).

### WhatsApp Button

Add a WhatsApp button to your website:

```html theme={null}
<a href="https://wa.me/1234567890?text=Hi%20there!" 
   target="_blank"
   style="background: #25D366; color: white; padding: 12px 24px; border-radius: 8px; text-decoration: none;">
  Chat on WhatsApp
</a>
```

## Monitoring Your Deployment

After deployment, monitor your agent through:

* **Dashboard analytics** — Message volume, response times
* **Conversation logs** — Review actual conversations
* **Error alerts** — Get notified of issues

See [Analytics](/guides/analytics) for detailed monitoring options.

## SDK Alternative

Deploy an agent to a phone number programmatically:

```typescript theme={null}
// Deploy agent to a phone number
const updatedAgent = await client.agents.deploy(agentId, {
  phoneNumberId: 'phone-number-uuid',
});

console.log(`Deployed to: ${updatedAgent.phoneNumbers[0].phoneNumber}`);

// Or deploy via WhatsApp account
await client.whatsappAccounts.deployAgent(wabaId, {
  agentId: agentId,
  phoneNumberId: 'phone-number-uuid',
});
```

## What's Next

<CardGroup>
  <Card title="Set Up Analytics" icon="chart-line" href="/guides/analytics">
    Monitor your agent's performance.
  </Card>

  <Card title="Configure Monetization" icon="dollar-sign" href="/guides/monetization">
    Start generating revenue.
  </Card>
</CardGroup>


# Monetization
Source: https://docs.wassist.app/guides/monetization

Generate revenue from your WhatsApp agent with message-limit paywalls, purchase links, and credit grants

Wassist includes built-in tools to monetize your agent. Wassist does not process payments itself: you take payment on your own page (Stripe, Gumroad, Shopify, etc.) and the paywall sends users there. Free credit grants let you unlock access for users who have paid.

## Monetization Models

<CardGroup>
  <Card title="Freemium" icon="gift">
    **Free tier + paid upgrade**

    Users get limited free messages, then follow a purchase link to continue.
  </Card>

  <Card title="Credits" icon="coins">
    **Pay-per-use**

    Users start with free credits that are consumed with each interaction, and unlock more with a grant password after paying on your page.
  </Card>
</CardGroup>

## Setting Up a Paywall

Paywalls limit how much users can interact before requiring payment.

<Steps>
  <Step title="Open Agent Settings">
    Go to your agent and find the **Monetization** or **Paywall** section.
  </Step>

  <Step title="Enable Paywall">
    Toggle on **Enable Paywall**.
  </Step>

  <Step title="Set Message Limit">
    Define how many free messages users get:

    | Setting           | Description                                |
    | ----------------- | ------------------------------------------ |
    | **Message Limit** | Number of messages before paywall triggers |

    <Tip>
      Start with a generous limit (10-20 messages) so users can experience value before hitting the paywall.
    </Tip>
  </Step>

  <Step title="Choose Paywall Action">
    What happens when the limit is reached:

    | Action            | Description                         |
    | ----------------- | ----------------------------------- |
    | **Purchase Link** | Redirect to your payment page       |
    | **Terminal**      | End the conversation with a message |
  </Step>

  <Step title="Customize Messages">
    Configure the paywall experience:

    | Field                | Description                          |
    | -------------------- | ------------------------------------ |
    | **CTA Button Text**  | Button label (e.g., "Upgrade Now")   |
    | **Terminal Message** | Message shown when conversation ends |
  </Step>
</Steps>

## Paywall Actions Explained

<AccordionGroup>
  <Accordion title="Purchase Link" icon="arrow-up-right-from-square">
    Direct users to your own payment page (Stripe, Gumroad, etc.).

    **Configuration:**

    * Enter your payment URL
    * URL can include parameters like `?user_id={user_id}`

    **Best for:**

    * One-time purchases and subscriptions you run yourself
    * Existing payment systems
    * Complex pricing tiers
  </Accordion>

  <Accordion title="Terminal" icon="stop">
    Conversation ends with a custom message—no payment option.

    **Best for:**

    * Demo/trial agents
    * Limiting free tier usage
    * Gathering leads before sales contact
  </Accordion>
</AccordionGroup>

## Credit-Based Monetization

Credits provide fine-grained control over usage and monetization.

### How Credits Work

1. Users start with **initial credits** (configurable)
2. Each message or tool use consumes credits
3. When credits run out, the paywall triggers
4. Users unlock more credits with a grant password you give them after they pay on your own page

### Configuring Credits

<Steps>
  <Step title="Enable Credit System">
    In your agent's **Monetization** section, enable **Credit System**.
  </Step>

  <Step title="Set Initial Credits">
    How many credits new users receive:

    ```
    Initial Credits: 50
    ```
  </Step>

  <Step title="Configure Credit Costs">
    Set costs for different actions:

    | Action           | Default Cost          |
    | ---------------- | --------------------- |
    | Regular message  | 1 credit              |
    | Tool calls       | Configurable per tool |
    | Image generation | 5+ credits            |
  </Step>

  <Step title="Set Up Credit Grants">
    Allow users to get more credits:

    | Field                     | Description                         |
    | ------------------------- | ----------------------------------- |
    | **Credit Grant Password** | Secret phrase that grants credits   |
    | **Credit Grant Amount**   | Credits given when password is used |

    <Note>
      Share the password on your payment confirmation page or email.
    </Note>
  </Step>
</Steps>

### Credit Grant Flow

1. User purchases credits on your payment page
2. Confirmation page shows the secret phrase
3. User sends phrase to your agent
4. Credits are added to their account

```
User: PREMIUM2024
Agent: Thanks! 100 credits have been added to your account. 
       You now have 150 credits available.
```

## Advertising

Generate revenue by displaying ads in conversations.

### Configuring Ads

<Steps>
  <Step title="Enable Advertising">
    In the **Monetization** section, toggle on **Enable Ads**.
  </Step>

  <Step title="Configure Ad Settings">
    | Field                   | Description               |
    | ----------------------- | ------------------------- |
    | **Conversation Offset** | Messages before first ad  |
    | **Ad Frequency**        | Messages between ads      |
    | **Force Ad**            | Require ad acknowledgment |
  </Step>
</Steps>

<Warning>
  Use ads sparingly. Too many ads degrade user experience and can drive users away.
</Warning>

## Best Practices

<AccordionGroup>
  <Accordion title="Demonstrate Value First" icon="star">
    Give users enough free interactions to understand your agent's value before hitting a paywall. A frustrated user who hits a paywall too soon won't convert.

    **Recommendation:** 10-20 free messages or one complete interaction flow.
  </Accordion>

  <Accordion title="Clear Communication" icon="message">
    Be transparent about limitations:

    * Mention limits in your welcome message
    * Warn users as they approach the limit
    * Make the upgrade path clear and simple

    ```
    First Message:
    "Hi! I can help you with... You have 10 free messages 
    to try me out, then you can upgrade for unlimited access."
    ```
  </Accordion>

  <Accordion title="Fair Pricing" icon="scale-balanced">
    Research competitors and test different price points. Consider:

    * Value delivered per interaction
    * Your target audience's budget
    * Subscription vs. one-time pricing psychology
  </Accordion>

  <Accordion title="Easy Upgrade Path" icon="stairs">
    Make payment as frictionless as possible:

    * One-click payment links
    * Mobile-optimized checkout
    * Multiple payment methods
  </Accordion>
</AccordionGroup>

## Tracking Revenue

Monitor your monetization performance in **Analytics**:

* Paywall hits and purchase-link clicks
* Conversion rates (free → paid)
* Credit usage and grant redemptions

## SDK Alternative

Configure monetization programmatically:

```typescript theme={null}
await client.agents.update(agentId, {
  paywallConfig: {
    messageLimit: 10,
    paywallAction: 'purchase_link',
    paywallUrl: 'https://your-payment-page.com?user={user_id}',
    ctaButtonText: 'Upgrade to Premium',
    terminalStateMessage: 'Thanks for trying our agent!'
  },
  creditSettings: {
    initialCredits: 50,
    creditGrantPassword: 'PREMIUM2024',
    creditGrantAmount: 100
  }
});
```

## What's Next

<CardGroup>
  <Card title="View Analytics" icon="chart-line" href="/guides/analytics">
    Track your monetization performance.
  </Card>

  <Card title="Configure Tools" icon="plug" href="/guides/configure-tools">
    Set credit costs for tool usage.
  </Card>
</CardGroup>


# Conversation Routing
Source: https://docs.wassist.app/guides/webhooks/routing

Route inbound WhatsApp messages to your agent, your own webhook, or nothing — per number and per conversation.

Every Wassist phone number has a **default routing mode**, and every
conversation can optionally override it. The resolved mode — the
**effective routing** — decides what happens when a customer sends a
message.

## The routing modes

| Mode      | What happens on inbound                                                | When to use it                                            |
| --------- | ---------------------------------------------------------------------- | --------------------------------------------------------- |
| `agent`   | The connected agent replies as normal                                  | Default for numbers wired to an agent.                    |
| `webhook` | The message is forwarded to a single webhook; the agent is **not** run | When you want to handle replies in your own service.      |
| `null`    | The message is stored, nothing else happens                            | Pause routing without disconnecting the agent or webhook. |
| `sandbox` | Internal sandbox flow (shared system number)                           | System-managed only — see the note below.                 |

<Note>
  "No routing" is represented as **`null`** on the wire — there is no `"none"`
  string value. A number or conversation with `defaultRouting: null` (or
  `routing: null` on the conversation) simply stores incoming messages and
  does nothing else.
</Note>

<Note>
  `sandbox` is a system-managed mode for shared Wassist test numbers (numbers
  with no WhatsApp Business Account). It lets you chat with yourself for
  testing. You cannot set `sandbox` from the API or dashboard; any attempt to
  do so returns `400`. Sandbox numbers also ignore per-conversation routing
  overrides.
</Note>

## How effective routing is resolved

```mermaid theme={null}
flowchart LR
    Conv[Conversation.routing] -->|set| Effective[Effective routing]
    Conv -->|null| Num[WhatsappNumber.defaultRouting]
    Num --> Effective
    Sandbox{Number is sandbox?} -.->|yes| Forced[Effective = sandbox]
```

In code terms:

1. If the number is a sandbox number → `sandbox`, full stop.
2. Otherwise, if the conversation has its own non-null `routing`, use it.
3. Otherwise, fall back to the number's `defaultRouting` (which itself may
   be `null` — meaning "no routing").

The same precedence applies to the webhook itself:
`conversation.webhookOverride` wins over `whatsappNumber.defaultWebhook`.

## Subscription lifecycle events

Whenever a conversation's effective `(routing, webhook)` pair transitions
to or away from a webhook, Wassist fires lifecycle events to the affected
webhook:

| Transition              | Event                                                        |
| ----------------------- | ------------------------------------------------------------ |
| not-webhook → webhook W | `subscription.activated` on W                                |
| webhook W → not-webhook | `subscription.revoked` on W                                  |
| webhook W1 → webhook W2 | `subscription.revoked` on W1, `subscription.activated` on W2 |
| same → same             | (none)                                                       |

The triggers are:

* [`POST /conversations/{id}/subscribe/`](/api-reference/conversations/subscribe),
  [`/unsubscribe/`](/api-reference/conversations/unsubscribe),
  [`/routing/`](/api-reference/conversations/routing)

<Note>
  Phone-number-level routing changes (the
  [`/phone-numbers/{n}/subscribe`](/api-reference/phone-numbers/subscribe),
  [`/connect-agent`](/api-reference/phone-numbers/connect-agent), and
  [`/unsubscribe`](/api-reference/phone-numbers/unsubscribe) endpoints) do
  **not** fire subscription lifecycle events, even when `applyToExisting` is
  true. Number-wide changes are bulk admin actions — if your service needs
  to know about every conversation, subscribe to it individually.
</Note>

## Inbound message dispatch

Once a conversation is in `webhook` routing:

* `subscription.message.received` is dispatched **only** to the assigned
  webhook (no fan-out).
* The agent pipeline is skipped entirely.
* The legacy `message.received` event still fan-outs to every active
  webhook subscribed to it, so existing integrations keep working.

## Service window lifecycle

WhatsApp's 24-hour customer service window is tracked per conversation in
`webhook` mode:

* `subscription.service_window.expiring` fires roughly 1 hour before the
  window closes for a given conversation, once per window.
* `subscription.service_window.closed` fires when the window has closed.
* The tracker resets the moment a new inbound user message lands.

## Event payloads

All `subscription.*` events use the same envelope as
[`message.received`](/concepts/webhooks#message-received), with two extra
fields:

```json theme={null}
{
  "event": "subscription.message.received",
  "timestamp": "2026-06-23T16:48:00.000Z",
  "phoneNumber": "+447700900100",
  "from": "+447700900200",
  "contact": { "name": "Alex", "phoneNumber": "+447700900200" },
  "message": { /* same shape as message.received */ },
  "conversationId": "5a3f...e2",
  "routing": "webhook",
  "webhookId": "9c1c...a0"
}
```

For lifecycle events (`subscription.activated`, `.revoked`, the service
window pair) the `message` field is `null` — only conversation context is
sent.

## Setting routing from your code

```ts theme={null}
import { WassistClient } from "@wassist/sdk";

const client = new WassistClient({ apiKey: process.env.WASSIST_API_KEY! });

// Subscribe a single conversation to a webhook
await client.conversations.subscribe(conversationId, { webhookId });

// Clear the override (falls back to the number's defaultRouting)
await client.conversations.unsubscribe(conversationId);

// Or use the general-purpose endpoint
await client.conversations.setRouting(conversationId, { mode: "agent" });

// Pass null (or "inherit") to clear the override
await client.conversations.setRouting(conversationId, { mode: null });
```

To change the number-wide default, do it from the dashboard or via the
three dedicated phone-number endpoints. Each one atomically sets the
routing mode and clears the unrelated FK (agent vs. webhook), so the
number can't end up in an inconsistent state:

```ts theme={null}
// Route the number to a webhook (drops any connected agent)
await client.phoneNumbers.subscribe("447700900100", {
  webhookId,
  applyToExisting: true,
});

// Connect an agent (drops any subscribed webhook)
await client.phoneNumbers.connectAgent("447700900100", {
  agentId,
  applyToExisting: true,
});

// Disable routing entirely (drops both)
await client.phoneNumbers.unsubscribe("447700900100", {
  applyToExisting: true,
});
```

`applyToExisting: true` materialises the change onto every existing
conversation on this number — `activeAgent` is overwritten with the new
default (or cleared, for `subscribe` / `unsubscribe`) and any in-flight
session is dropped. No subscription lifecycle events are dispatched.

<Note>
  **Webhooks must be created in the [dashboard](https://wassist.app/developers/webhooks).**
  There is no API for webhook creation — the routing endpoints only let you
  point conversations at webhooks that already exist.
</Note>

## Validation rules

* `mode='sandbox'` is rejected on every public endpoint.
* Any routing change on a sandbox number is rejected (the number is shared
  and system-managed).
* `webhookId` must reference a webhook owned by the requesting user.
* `webhookId` is required when (and only when) `mode === 'webhook'`.


# Welcome to Wassist
Source: https://docs.wassist.app/index

Build and deploy AI-powered WhatsApp agents in minutes

## What is Wassist?

Wassist is a platform that lets you create, test and publish intelligent AI agents that live natively on WhatsApp. With over 3 billion WhatsApp users worldwide, your agent can reach customers where they already spend their time, no app downloads or clunky web interfaces required.

Whether you're a business owner looking to automate customer support, a developer building conversational AI products, or a creator monetizing your expertise, Wassist provides everything you need.

## Get Started

<CardGroup>
  <Card title="Wassist Platform" icon="play" href="/quickstart">
    Build your first agent in minutes using our no-code dashboard. Perfect for beginners.
  </Card>

  <Card title="Developer API" icon="code" href="/api-reference/introduction">
    Full programmatic control via our REST API and TypeScript SDK. Ideal for developers.
  </Card>

  <Card title="BYO Agent" icon="robot" href="/concepts/bring-your-own-agent">
    Connect your existing AI agent to WhatsApp using our infrastructure. Maximum flexibility.
  </Card>
</CardGroup>

## How it works

## What can you build?

<CardGroup>
  <Card title="Customer Support Agent" icon="headset">
    Answer FAQs, handle inquiries, and escalate to humans when needed—24/7.
  </Card>

  <Card title="E-commerce Assistant" icon="cart-shopping">
    Help customers browse products, check orders, and get personalized recommendations.
  </Card>

  <Card title="Knowledge Base Bot" icon="book">
    Let users query your documentation, guides, or internal knowledge instantly.
  </Card>

  <Card title="Voice-Enabled Agent" icon="microphone">
    Connect ElevenLabs to handle voice messages with natural-sounding responses.
  </Card>
</CardGroup>

## Key Features

<AccordionGroup>
  <Accordion title="Multiple Ways to Create Agents" icon="rocket">
    Start from a text description, import from your website, connect your Shopify store, or upload documents. Wassist handles the AI configuration automatically.
  </Accordion>

  <Accordion title="Tool & API Integration" icon="plug">
    Connect your agent to any external API. Book appointments, check inventory, process payments—anything your business needs.
  </Accordion>

  <Accordion title="Built-in Monetization" icon="dollar-sign">
    Set up paywalls, subscription tiers, or credit-based access. Wassist handles payments so you can focus on your content.
  </Accordion>

  <Accordion title="WhatsApp Business Integration" icon="whatsapp">
    Use your own WhatsApp Business account or get started with a Wassist-provided number. Full access to templates, business profiles, and analytics.
  </Accordion>

  <Accordion title="Enterprise-Ready SDK" icon="terminal">
    Fully typed TypeScript SDK with comprehensive REST API documentation for custom integrations.
  </Accordion>
</AccordionGroup>

## Choose Your Path

<Columns>
  <Card title="Quickstart" icon="play" href="/quickstart">
    Build your first agent in 5 minutes with our guided tutorial.
  </Card>

  <Card title="Concepts" icon="lightbulb" href="/concepts">
    Understand how agents, tools, and conversations work together.
  </Card>

  <Card title="API Reference" icon="book-open" href="/api-reference/introduction">
    Explore the complete REST API documentation.
  </Card>
</Columns>

## Get Help

<CardGroup>
  <Card title="Contact Support" icon="envelope" href="mailto:contact@wassist.app">
    Reach out to our team for personalized assistance.
  </Card>

  <Card title="Dashboard" icon="grid-2" href="https://wassist.app/agents">
    Access your agents and manage your account.
  </Card>
</CardGroup>


# Quickstart
Source: https://docs.wassist.app/quickstart

Create and test your first WhatsApp AI agent in under 5 minutes

## Before You Begin

You'll need:

* A Wassist account ([sign up free](https://wassist.app/login))
* A smartphone with WhatsApp installed (for testing)

<Note>
  No credit card required. You can test your agent immediately using Wassist's shared test number.
</Note>

## Step 1: Create Your Agent

<Steps>
  <Step title="Log in to Wassist">
    Go to [wassist.app/login](https://wassist.app/login) and sign in with your phone number. You'll receive a verification code via WhatsApp.
  </Step>

  <Step title="Start a new agent">
    Click the **New Agent** button on your dashboard. You'll see several options for creating your agent.
  </Step>

  <Step title="Describe your idea">
    Choose **"Start from an idea"** and describe what you want your agent to do. For example:

    > "A friendly customer support agent for my coffee shop that can answer questions about our menu, hours, and location. We're open 7am-6pm Monday through Saturday at 123 Main Street."

    Click **Create Agent** and Wassist will automatically generate:

    * A system prompt that defines your agent's personality
  </Step>
</Steps>

## Step 2: Test Your Agent

<Steps>
  <Step title="Open the test chat">
    After creation, you'll see your agent's configuration page. Click the **Test Agent** menu item on the left sidebar.
  </Step>

  <Step title="Send the connection message">
    WhatsApp will open with a pre-written connection message ready to send. Click **Send** to start a conversation with your agent.
  </Step>

  <Step title="Have a conversation">
    Try asking questions like:

    * "What time do you open?"
    * "Do you have oat milk?"
    * "Where are you located?"

    Your agent will respond based on the information you provided.
  </Step>
</Steps>

<Tip>
  The test uses Wassist's shared phone number. To get a dedicated number for your agent, see [Deploy Your Agent](/guides/deploy-agent).
</Tip>

## Step 3: Customize Your Agent

Now that you've seen your agent in action, you can fine-tune it:

<AccordionGroup>
  <Accordion title="Edit the System Prompt" icon="pencil">
    The system prompt controls how your agent behaves. Click into the **System Prompt** field to:

    * Add more details about your business
    * Define the agent's tone (formal, casual, playful)
    * Set boundaries on what topics it should handle
  </Accordion>

  <Accordion title="Connect to a Website" icon="message">
    You can connect your agent to a website to answer questions about the content of the website.

    * Click the **capabilities** menu item on the left sidebar
    * Add a **Website Tool** and enter the URL of the website
    * Describe how the agent should use the website, for example to answer questions about the products or services offered.
    * Click **Save** to apply the changes.
  </Accordion>
</AccordionGroup>

## What's Next?

<CardGroup>
  <Card title="Add Knowledge" icon="book" href="/guides/create-agent-knowledge-base">
    Upload documents so your agent can answer questions about your content.
  </Card>

  <Card title="Connect Tools" icon="plug" href="/guides/configure-tools">
    Let your agent call external APIs to book appointments, check orders, and more.
  </Card>

  <Card title="Connect WhatsApp" icon="whatsapp" href="/guides/connect-whatsapp">
    Use your own WhatsApp Business account for a professional presence.
  </Card>

  <Card title="Monetize" icon="dollar-sign" href="/guides/monetization">
    Set up paywalls and subscriptions to generate revenue from your agent.
  </Card>
</CardGroup>

***

## For Developers

If you prefer to work programmatically, you can create agents using the SDK:

```typescript theme={null}
import { createWassistClient } from '@wassist/sdk';

const client = createWassistClient({
  baseUrl: 'https://backend.wassist.app/api/v1/',
  authToken: 'your-auth-token',
});

// Create an agent from an idea
const agent = await client.onboarding.createFromIdea({
  idea: 'A customer support agent for my coffee shop...',
});

console.log(`Agent created: ${agent.name}`);
console.log(`Test URL: ${agent.connectUrl}`);
```

<Card title="SDK Documentation" icon="code" href="/sdk/overview">
  Learn more about the TypeScript SDK and all available methods.
</Card>