`. **This is the default.** |
| `mask` | Replaces the detected value with `****` |
| `redact` | Removes the detected value entirely |
| `hash` | Hashes the detected value (one-way) |
### Prerequisites
Before configuring PII redaction, ensure:
* OTEL log shipping is enabled for your organization
* The `jsonl_to_otel_json` transformation is applied
* Your Enterprise plan includes PII redaction (contact your Account Manager)
### Configuration
| Field | Type | Required | Description |
| ----------------- | --------- | -------- | ------------------------------------------------------------------------------------------- |
| `enabled` | boolean | Yes | Enable or disable PII redaction |
| `action` | string | Yes | Action to take on detected PII. Options: `"replace"`, `"redact"`, `"mask"`, or `"hash"` |
| `entities` | string\[] | No | Specific PII entity types to target. If omitted, all supported entities are used |
| `target_fields` | string\[] | No | Specific data fields to scan for PII |
| `score_threshold` | float | No | Minimum confidence level for PII detection (0.0–1.0). Higher values require more confidence |
There is currently no self-serve UI to toggle PII redaction. It is configured at the organization level by the Relevance AI team. Contact your Account Manager to have it enabled.
***
## Prompt injection detection (Enterprise feature)
Prompt injection detection is an org-level feature that scans incoming user input for prompt injection attempts. When an attempt is detected, the result is recorded on the agent's execution trace so you can monitor and alert on it in your own observability stack.
Detection runs as a post-processing scan that is independent of the underlying LLM model. It flags and records attempts; it does not block or rewrite the user's message.
Prompt injection detection requires event streaming to be enabled, because results surface only on the OTEL traces delivered to your S3 bucket. It is a contractual Enterprise feature with no self-serve UI — contact your Account Manager to enable it for your organization.
### Where it surfaces
Detection results are added as attributes on the [`invoke_agent`](#invoke_agent) span:
| Attribute | Type | Description |
| ------------------------------------------ | ------- | ----------------------------------------------------------------- |
| `relevance_ai.prompt_injection.detected` | boolean | Whether a prompt injection attempt was detected in the user input |
| `relevance_ai.prompt_injection.confidence` | double | Confidence score for the detection (0.0–1.0) |
These attributes are only present when prompt injection detection is enabled for your organization. Query them in your observability tool the same way you would any other span attribute.
***
## Delivery format
**Format**: Gzipped JSON following the OpenTelemetry JSON specification.
**File path pattern**:
```
{prefix}/customer-otel-{type}-formatted/org_id={org_id}/dt={YYYY-MM-DD}/year={YYYY}/month={MM}/day={DD}/hour={HH}/minute={MM}/{type}_{org_id}_{timestamp}_{uuid}.json.gz
```
**Event types**:
* `logs` - Audit logs for administrative and lifecycle events
* `traces` - Execution traces for agents, workforces, and LLM completions
***
## Logs
Audit logs provide a complete record of activity across your organization for security monitoring, compliance reporting, and operational visibility. Events capture who did what, when, and from where. Enterprise customers can enable PII redaction to automatically protect sensitive information in logs.
We're actively expanding our event coverage. If there are specific operations or attributes you'd like to see, let your Account Manager know.
### Structure
```json theme={null}
{
"resourceLogs": [{
"scopeLogs": [{
"logRecords": [...]
}]
}]
}
```
### Base attributes
Included on all log records:
| Attribute | Type | Required | Description |
| ------------------------------ | ------ | -------- | -------------------------------------- |
| `relevance_ai.organization_id` | string | Yes | Organization ID |
| `relevance_ai.project_id` | string | Yes | Project ID |
| `relevance_ai.user_id` | string | No | User ID that performed the action |
| `relevance_ai.user_email` | string | No | Email of the user |
| `relevance_ai.user_type` | string | No | Type of user (`user`, `api_key`, etc.) |
| `relevance_ai.ip_address` | string | No | IP address of the request |
| `relevance_ai.device_info` | string | No | User agent / device information |
### Log record properties
| Property | Type | Description |
| ------------------ | ------ | -------------------------------------------- |
| `timeUnixNano` | int64 | Timestamp in nanoseconds since Unix epoch |
| `severityNumber` | int | OTEL severity level (9 = Info) |
| `severityText` | string | `"Info"` |
| `body.stringValue` | string | The event name |
| `attributes` | array | Key-value pairs with base + event attributes |
### Supported events
### Agent events
**`agent_created`** - Emitted when a new agent is created (from scratch, cloned, or duplicated).
| Attribute | Type | Required | Description |
| ------------------------------------------- | ------ | -------- | ----------------------------- |
| `relevance_ai.event.agent_id` | string | Yes | ID of the newly created agent |
| `relevance_ai.event.cloned_from_agent_id` | string | No | Source agent ID if cloned |
| `relevance_ai.event.cloned_from_region` | string | No | Source region if cloned |
| `relevance_ai.event.cloned_from_project_id` | string | No | Source project if cloned |
**`agent_updated`** - Emitted when an agent's configuration is updated directly (outside draft/publish workflow).
| Attribute | Type | Required | Description |
| ----------------------------- | ------ | -------- | ----------------------- |
| `relevance_ai.event.agent_id` | string | Yes | ID of the updated agent |
**`agent_deleted`** - Emitted when an agent is permanently deleted.
| Attribute | Type | Required | Description |
| ----------------------------- | ------ | -------- | ----------------------- |
| `relevance_ai.event.agent_id` | string | Yes | ID of the deleted agent |
**`agent_draft_saved`** - Emitted when work-in-progress changes are saved to an agent.
| Attribute | Type | Required | Description |
| ------------------------------- | ------ | -------- | ----------------------------- |
| `relevance_ai.event.agent_id` | string | Yes | ID of the agent being edited |
| `relevance_ai.event.version_id` | string | Yes | ID of the draft version saved |
**`agent_published`** - Emitted when agent changes are published to make them live.
| Attribute | Type | Required | Description |
| ------------------------------- | ------ | -------- | ------------------------------- |
| `relevance_ai.event.agent_id` | string | Yes | ID of the agent being published |
| `relevance_ai.event.version_id` | string | Yes | ID of the version now live |
### Tool events
**`tool_created`** - Emitted when a new tool is created (from scratch or cloned).
| Attribute | Type | Required | Description |
| ------------------------------------------- | ------ | -------- | ---------------------------- |
| `relevance_ai.event.tool_id` | string | Yes | ID of the newly created tool |
| `relevance_ai.event.cloned_from_tool_id` | string | No | Source tool ID if cloned |
| `relevance_ai.event.cloned_from_region` | string | No | Source region if cloned |
| `relevance_ai.event.cloned_from_project_id` | string | No | Source project if cloned |
**`tool_deleted`** - Emitted when a tool is permanently deleted.
| Attribute | Type | Required | Description |
| ---------------------------- | ------ | -------- | ---------------------- |
| `relevance_ai.event.tool_id` | string | Yes | ID of the deleted tool |
**`tool_draft_saved`** - Emitted when work-in-progress changes are saved to a tool.
| Attribute | Type | Required | Description |
| ------------------------------- | ------ | -------- | ----------------------------- |
| `relevance_ai.event.tool_id` | string | Yes | ID of the tool being edited |
| `relevance_ai.event.version_id` | string | No | ID of the draft version saved |
**`tool_published`** - Emitted when tool changes are published to make them live.
| Attribute | Type | Required | Description |
| ------------------------------- | ------ | -------- | ------------------------------ |
| `relevance_ai.event.tool_id` | string | Yes | ID of the tool being published |
| `relevance_ai.event.version_id` | string | Yes | ID of the version now live |
### Workforce events
**`workforce_created`** - Emitted when a new workforce is created (from scratch, cloned, or duplicated).
| Attribute | Type | Required | Description |
| --------------------------------------------- | ------ | -------- | --------------------------------- |
| `relevance_ai.event.workforce_id` | string | Yes | ID of the newly created workforce |
| `relevance_ai.event.cloned_from_workforce_id` | string | No | Source workforce ID if cloned |
| `relevance_ai.event.cloned_from_region` | string | No | Source region if cloned |
| `relevance_ai.event.cloned_from_project_id` | string | No | Source project if cloned |
**`workforce_deleted`** - Emitted when a workforce is permanently deleted.
| Attribute | Type | Required | Description |
| --------------------------------- | ------ | -------- | --------------------------- |
| `relevance_ai.event.workforce_id` | string | Yes | ID of the deleted workforce |
**`workforce_draft_saved`** - Emitted when work-in-progress changes are saved to a workforce.
| Attribute | Type | Required | Description |
| --------------------------------- | ------ | -------- | -------------------------------- |
| `relevance_ai.event.workforce_id` | string | Yes | ID of the workforce being edited |
| `relevance_ai.event.version_id` | string | No | ID of the draft version saved |
**`workforce_published`** - Emitted when workforce changes are published to make them live.
| Attribute | Type | Required | Description |
| --------------------------------- | ------ | -------- | ----------------------------------- |
| `relevance_ai.event.workforce_id` | string | Yes | ID of the workforce being published |
| `relevance_ai.event.version_id` | string | No | ID of the version now live |
### Permission events
**`project_user_role_updated`** - Emitted when a user's role within a project is updated. This occurs when an admin changes another user's access level in the project settings.
| Attribute | Type | Required | Description |
| ----------------------------------- | ------ | -------- | ----------------------------------------- |
| `relevance_ai.event.target_user_id` | string | Yes | ID of the user whose role was changed |
| `relevance_ai.event.project_role` | string | Yes | The new project role assigned to the user |
**`organization_user_role_updated`** - Emitted when a user's role within an organization is updated. This occurs when an admin changes another user's organization-level access.
| Attribute | Type | Required | Description |
| -------------------------------------- | ------ | -------- | ---------------------------------------------- |
| `relevance_ai.event.target_user_id` | string | Yes | ID of the user whose role was changed |
| `relevance_ai.event.organization_role` | string | Yes | The new organization role assigned to the user |
### Example log record
```json theme={null}
{
"resourceLogs": [{
"scopeLogs": [{
"logRecords": [{
"timeUnixNano": 1768742472616000000,
"severityNumber": 9,
"severityText": "Info",
"body": { "stringValue": "agent_deleted" },
"attributes": [
{ "key": "relevance_ai.organization_id", "value": { "stringValue": "f6fb76a4-..." }},
{ "key": "relevance_ai.project_id", "value": { "stringValue": "3acde218-..." }},
{ "key": "relevance_ai.user_id", "value": { "stringValue": "941afb4d-..." }},
{ "key": "relevance_ai.user_email", "value": { "stringValue": "user@example.com" }},
{ "key": "relevance_ai.user_type", "value": { "stringValue": "user" }},
{ "key": "relevance_ai.ip_address", "value": { "stringValue": "119.18.1.156" }},
{ "key": "relevance_ai.device_info", "value": { "stringValue": "Mozilla/5.0..." }},
{ "key": "relevance_ai.event.agent_id", "value": { "stringValue": "3d47a9f5-..." }}
],
"droppedAttributesCount": 0,
"traceId": "",
"spanId": ""
}]
}]
}]
}
```
***
## Traces
Traces track execution flows for agents, workforces, and LLM completions. Use traces to understand performance, debug issues, and analyze agent behavior.
We're actively expanding our trace coverage. If there are specific spans or attributes you'd like to see, let your Account Manager know.
### Structure
```json theme={null}
{
"resourceSpans": [{
"scopeSpans": [{
"spans": [...]
}]
}]
}
```
### Resource attributes
Resource attributes identify the service producing telemetry data. These attributes are attached to all spans and logs exported from Relevance AI.
| Attribute | Type | Value | Description |
| -------------- | ------ | ---------------- | ----------------------------------------------- |
| `service.name` | string | `"Relevance AI"` | Logical name of the service producing telemetry |
This attribute is applied to all spans - `chat`, `invoke_agent`, `multi_agent_system_trigger`, and `condition_trigger`. In your observability tool, you can filter all Relevance activity with a single query like `service.name = "Relevance AI"`, cleanly separating Relevance spans from your own services.
**Example structure:**
```json theme={null}
{
"resourceSpans": [{
"resource": {
"attributes": [
{ "key": "service.name", "value": { "stringValue": "Relevance AI" } }
]
},
"scopeSpans": [{ "spans": [...] }]
}]
}
```
### Base attributes
Included on all spans:
| Attribute | Type | Required | Description |
| ------------------------------ | ------ | -------- | ------------------------------ |
| `relevance_ai.organization_id` | string | Yes | Organization ID |
| `relevance_ai.project_id` | string | Yes | Project ID |
| `relevance_ai.user_id` | string | No | User ID that triggered the run |
| `relevance_ai.user_email` | string | No | Email of the user |
### Span properties
| Property | Type | Description |
| ------------------- | ------ | ----------------------------------------- |
| `traceId` | string | 32-character hex trace identifier |
| `spanId` | string | 16-character hex span identifier |
| `parentSpanId` | string | Parent span ID (if child span) |
| `name` | string | Span name (e.g., `invoke_agent My Agent`) |
| `kind` | int | Span kind (3 = CLIENT) |
| `startTimeUnixNano` | int64 | Start time in nanoseconds |
| `endTimeUnixNano` | int64 | End time in nanoseconds |
| `attributes` | array | Key-value pairs with span details |
| `status.code` | int | 1 = OK, 2 = ERROR |
### Trace hierarchy
Spans share `traceId` and link via `parentSpanId`:
```
multi_agent_system_trigger
├── condition_trigger
└── invoke_agent
├── chat
└── invoke_agent (sub-agent)
└── chat
```
### Supported spans
### `invoke_agent`
Records a complete agent conversation/invocation.
**Name**: `invoke_agent` or `invoke_agent {agent_name}`
| Attribute | Type | Required | Description |
| ------------------------------------------ | ------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `gen_ai.operation.name` | string | Yes | `"invoke_agent"` |
| `gen_ai.agent.id` | string | Yes | Agent UUID |
| `gen_ai.agent.name` | string | No | Agent name |
| `gen_ai.agent.description` | string | No | Agent description |
| `gen_ai.conversation.id` | string | Yes | Conversation/task UUID |
| `relevance_ai.agent.relevance_model` | string | Yes | Relevance model ID |
| `relevance_ai.agent.runtime` | string | Yes | `"default"` or `"phone_call"` |
| `relevance_ai.agent.metadata` | object | Yes | Custom metadata key-value pairs |
| `relevance_ai.agent.knowledge_used` | array | Yes | Knowledge set IDs used |
| `relevance_ai.agent.escalation.reason` | string | No | Escalation reason |
| `relevance_ai.agent.escalation.context` | string | No | Escalation context |
| `relevance_ai.agent.version_id` | string | No | The active version ID of the agent at invocation time. Use this to compare performance across agent versions |
| `relevance_ai.prompt_injection.detected` | boolean | No | Whether a prompt injection attempt was detected in the user input. Only present when [prompt injection detection](#prompt-injection-detection-enterprise-feature) is enabled |
| `relevance_ai.prompt_injection.confidence` | double | No | Confidence score (0.0–1.0) for the prompt injection detection. Only present when prompt injection detection is enabled |
### `chat`
Records a single LLM inference call.
**Name**: `chat {model_name}`
This span was previously named `llm_completion`. If you have existing dashboards or queries filtering on `gen_ai.operation.name = "llm_completion"` or span names containing `llm_completion`, update them to use `"chat"`. The rename aligns with the [OpenTelemetry GenAI semantic conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/).
| Attribute | Type | Required | Description |
| -------------------------------- | ------ | -------- | ----------------------------------------------------------------------------------- |
| `gen_ai.operation.name` | string | Yes | `"chat"` |
| `gen_ai.request.model` | string | Yes | Requested model ID |
| `gen_ai.request.temperature` | int | No | Temperature setting |
| `gen_ai.request.max_tokens` | int | No | Max tokens setting |
| `gen_ai.system_instructions` | string | No | System prompt |
| `gen_ai.input.messages` | string | Yes | JSON-stringified input messages |
| `gen_ai.tool.definitions` | string | Yes | JSON-stringified tool definitions (use `JSON.parse()` to access as structured data) |
| `gen_ai.response.id` | string | Yes | Provider's response ID |
| `gen_ai.response.model` | string | Yes | Actual model used |
| `gen_ai.response.finish_reasons` | array | Yes | Finish reasons (e.g., `["stop"]`) |
| `gen_ai.output.messages` | string | Yes | JSON-stringified output messages |
| `gen_ai.usage.input_tokens` | int | Yes | Input tokens used |
| `gen_ai.usage.output_tokens` | int | Yes | Output tokens generated |
**Attribute**: `gen_ai.tool.definitions`
`gen_ai.tool.definitions` was previously an array type (`arrayValue`). It is now a JSON string (`stringValue`). If you consume this field in your pipeline or queries, you need to call `JSON.parse()` on the value to work with the tool definitions as structured data. The content is identical - the same tool definitions are present, just serialized as a string for better compatibility across OTEL exporters and backends.
### `multi_agent_system_trigger`
Records a complete workforce execution.
**Name**: `multi_agent_system_trigger`
| Attribute | Type | Required | Description |
| ------------------------------------------ | ------ | -------- | ----------------------------------------------------------------------------------------------------------------- |
| `gen_ai.operation.name` | string | Yes | `"multi_agent_system_trigger"` |
| `relevance_ai.workforce.workforce_id` | string | Yes | Workforce UUID |
| `relevance_ai.workforce.workforce_task_id` | string | Yes | Task UUID (for correlation) |
| `relevance_ai.workforce.type` | string | Yes | `"chat"` or `"default"` |
| `relevance_ai.workforce.metadata` | object | Yes | Custom metadata |
| `relevance_ai.workforce.status` | string | Yes | Final status |
| `relevance_ai.workforce.version_id` | string | No | The active version ID of the workforce at trigger time. Use this to compare performance across workforce versions |
### `condition_trigger`
Records a condition node evaluation in a workforce.
**Name**: `condition_trigger`
| Attribute | Type | Required | Description |
| --------------------------------------------- | ------ | -------- | -------------------------------- |
| `gen_ai.operation.name` | string | Yes | `"condition_trigger"` |
| `relevance_ai.condition.workforce_node_id` | string | Yes | Node ID in workforce |
| `relevance_ai.condition.workforce_node_label` | string | No | Node label/name |
| `relevance_ai.condition.input` | string | Yes | JSON-stringified condition input |
| `relevance_ai.condition.decisions` | array | Yes | Decision objects (see below) |
| `relevance_ai.condition.reasoning` | string | No | LLM reasoning |
**Decision object**:
```json theme={null}
{ "node": { "id": "node-id", "name": "Node Name" }, "will_run": true }
```
***
## Attribute value types
| Type | JSON Format |
| ------- | ------------------------------------------------------------------ |
| String | `{ "stringValue": "text" }` |
| Integer | `{ "intValue": 123 }` |
| Double | `{ "doubleValue": 1.23 }` |
| Boolean | `{ "boolValue": true }` |
| Array | `{ "arrayValue": { "values": [...] }}` |
| Object | `{ "kvlistValue": { "values": [{ "key": "k", "value": {...} }] }}` |
***
## Resources
### Understanding OpenTelemetry
* [What is OpenTelemetry?](https://opentelemetry.io/docs/what-is-opentelemetry/) - Official introduction to OTEL concepts
### Compatible observability platforms
OTEL is supported by most major observability platforms. See the [OpenTelemetry Registry](https://opentelemetry.io/ecosystem/registry/) for a full list of compatible vendors and integrations.
For a detailed example of ingesting OTEL data, see [Honeycomb's OpenTelemetry guide](https://docs.honeycomb.io/send-data/opentelemetry/).
### Querying OTEL data directly
OTEL JSON files in S3 can be queried directly using SQL tools like [AWS Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html).
# User Level Authentication
Source: https://relevanceai.com/docs/enterprise/user-level-authentication
Enable agents to use individual user authentication for secure, private access to integrations
User Level Authentication is an Enterprise-only feature that is being rolled out. If you don't have access yet, please reach out to your sales representative.
User Level Authentication enables agents to operate using each user's individual authentication accounts for integrations, allowing multiple users to safely and privately use the same shared agent (especially in Chat) while only accessing their own data. Builders can configure this behavior per agent, and users only need to authenticate once per tool.
## How User Level Authentication works
User Level Authentication changes how authentication works when multiple people use the same agent. Instead of everyone using a single shared account to access integrations (like Google Drive, Slack, or HubSpot), each user connects their own individual work accounts.
Choose which tool inputs require user level authentication using simple toggles
Connect once per tool when first using the agent - credentials are saved for future use
Authentication is automatically remembered and reused for all future agent runs
Set preferred accounts for each integration that auto-populate in new agents
This means that when multiple team members use the same agent, each person only sees and accesses their own data within the connected integrations.
## Why use User Level Authentication
Each user accesses integrations with their own credentials and permissions, reducing the security risks of shared accounts.
Users only see their own data. When an agent queries Google Drive or searches through emails, it only accesses the data that user has permission to see.
Users can only access what they're authorized to see in the external integration, based on their own account permissions rather than a shared account's permissions.
No need to manage shared credentials or worry about what happens when team members leave. Each user manages their own connections.
Actions taken by agents are attributed to individual user accounts in external integrations, making it easier to track who did what.
## Requirements for User Level Authentication
User Level Authentication works with tools that use **OAuth authentication only**.
**Supported:**
* Tool steps with OAuth account inputs (e.g., Google Sheets, Slack, HubSpot, Notion, Trello)
* Any integration that uses OAuth to connect user accounts
**Not supported:**
* Tools that use API key authentication
* Python code steps (even when using OAuth via the Integration helper class)
* Custom API calls with API key or bearer token authentication
If your tool uses API key authentication or Python steps, you'll need to use a shared account instead of User Level Authentication.
## Where User Level Authentication works
User Level Authentication is supported in the following contexts:
Users are prompted to connect their own account when an agent requests an authenticated action
Same experience when running an agent directly in the agent builder
When a workforce delegates to an agent with user level authentication configured, the user is prompted to authenticate
### Limitations
**Embedded chat is NOT currently supported.** Users who embed agents on external sites via the embed widget cannot use user level authentication. For embedded agents, you'll need to use a shared account for those integrations instead.
## Setting up user level authentication
As a builder, you can configure User Level Authentication at the agent level.
To enable User Level Authentication:
1. Head into your Agent and click Tools.
2. Head to the Tool you want to set User Level Authentication on, and find the Input for the OAuth account. From here, click the agent input setting, which is currently set to 'Set manually'.
3. Then, set this to 'Per-user authentication'.
When this is enabled, any agent using this tool will require each user to authenticate with their own account for this integration.
If you have [asset-level authentication controls](/docs/enterprise/rbac#permissions) enabled through RBAC, users can also choose from project-level shared accounts instead of authorizing their individual accounts.
When dynamic authentication is enabled on a shared agent, all team members — not just admins — can add their own OAuth accounts. Members can only manage their own private accounts and cannot view or modify project-level shared accounts, which remain admin-managed.
## User experience in Chat
When users interact with an agent in Chat that has User Level Authentication enabled, the authentication flow is seamless and intuitive.
### First-time authentication
All team members — not just admins — will see the authentication prompt when using an agent with dynamic authentication enabled for the first time.
When you run an agent that requires User Level Authentication for the first time, a pop-up appears with the guidance "Connect your account to use this tool."
Click the **Select connected account** dropdown to choose an account. If your project has shared accounts available, they appear here alongside your personal options.
Click **Add account** to start the OAuth login flow for that integration.
Follow the on-screen steps to log in. Your credentials are saved automatically for future runs.
Members can only add and manage their own private accounts. Project-level shared accounts are managed by project admins and cannot be modified by members.
### Subsequent uses
After the first authentication:
* The agent automatically uses the user's saved credentials
* No interruption to the agent's execution
* Users can change their default credentials in project settings if needed
### Multiple tools
Authentication is required per tool, not per integration. If an agent uses two Google Drive tools, for example, you'll be prompted to authenticate each tool separately on the first run. After initial setup, all credentials are remembered and reused automatically.
## Managing default authentication
Users can manage their default authentication accounts for each integration at the project level, making it easy to control which accounts are used by agents.
### Setting integration defaults
To set or change your default account for an integration:
1. Click on 'Integrations & API Keys' in the sidebar
2. Click on the integration you want to configure
Integration defaults pre-populate when you create new assets or use assets for the first time, saving you time and ensuring consistency across your agent interactions.
### Privacy and account visibility
All team members — not just admins — can add their own OAuth accounts when dynamic authentication is enabled on an agent. Members can connect their own private credentials without needing admin intervention, and can only see and manage their own private accounts. They cannot view or modify project-level shared accounts.
To protect privacy and security:
* **Private accounts are hidden** - Your personal accounts won't be visible to other users
* **Auths are private by default** - When you connect a new account, it's automatically set as private
* **Shared accounts** - If your organization has shared project-level accounts, you'll see those as options alongside your personal accounts
## Frequently asked questions (FAQs)
If you need to change your authentication credentials, you can do so easily. During Chat, you'll receive modal prompts that allow you to select existing credentials, add new ones, or mark a new credential as default. You can also manage your default credentials by going to Integrations & API Keys in the sidebar and selecting the integration you want to reconfigure.
Yes, if you have asset-level authentication controls enabled. When User Level Authentication is configured, you will see both your individual accounts and any shared project-level accounts available for selection. This gives you flexibility to choose the appropriate account based on the context.
User Level Authentication works with all integrations that support OAuth authentication in Relevance AI. This includes popular integrations like Google Drive, Gmail, Slack, HubSpot, Salesforce, and many others.
Yes, User Level Authentication is an Enterprise-only feature. If you would like access to this feature, please reach out to your sales representative.
User Level Authentication works in Chat, the Run tab (when running agents directly in the agent builder), and in Workforces (when a workforce delegates to an agent with user level authentication configured). However, it is NOT currently supported in embedded chat widgets on external websites.
User Level Authentication only works with OAuth-based integrations. If you don't see the option to set 'Per-user authentication' on your agent input setting, it's likely because:
* Your tool uses API key authentication instead of OAuth
* Your tool uses a Python code step
To use User Level Authentication, you need to use a tool that supports OAuth authentication (like Google Sheets, Slack, HubSpot, etc.). For tools that use API keys or Python steps, you'll need to use a shared account instead.
No. User Level Authentication only supports OAuth-based integrations. If your integration uses API key authentication, Python code steps, or custom API calls with bearer tokens, you'll need to use a shared account instead. Only integrations that use OAuth to connect user accounts (like Google Sheets, Slack, HubSpot, Notion, etc.) are compatible with User Level Authentication.
Yes. When dynamic authentication is enabled on a shared agent, all team members can add their own OAuth accounts — this is not limited to admins. Members see an "Add account" button with the guidance "Connect your account to use this tool." Members can only manage their own private accounts; they cannot view or modify project-level shared accounts, which remain admin-managed.
# Deep Researcher
Source: https://relevanceai.com/docs/get-started/chat/chat-agents/deep-researcher
Conduct comprehensive research on any topic using the Deep Researcher agent in Chat
Deep Researcher is a built-in Agent in Chat that conducts comprehensive research on a topic. Mention it with `@Deep Researcher` in any conversation to get started.
## How it works
1. Provide a research topic or question.
2. Deep Researcher searches the web and synthesizes findings into a detailed report.
3. Review the results and ask follow-up questions or request deeper investigation in the same conversation.
You can combine Deep Researcher with other agents in the same chat. For example, have Deep Researcher gather information on a topic, then pass the results to [Slide Builder](/docs/get-started/chat/slide-builder) to create a presentation or [Website Builder](/docs/get-started/chat/chat-agents/website-builder) to build a landing page.
## Credit cost
Deep Researcher typically costs 100+ credits per run. Credit usage varies based on the breadth and depth of the research.
## Frequently asked questions (FAQs)
Mention `@Deep Researcher` in any Chat conversation and describe the topic or question you want researched.
Yes. You can @ mention Deep Researcher alongside your own agents or other built-in agents in the same conversation.
Deep Researcher produces a comprehensive report with sourced findings. You can ask follow-up questions to explore specific areas in more depth.
# Image Generator
Source: https://relevanceai.com/docs/get-started/chat/chat-agents/image-generator
Generate images from text prompts using the Image Generator agent in Chat
Image Generator is a built-in Agent in Chat that creates images from text prompts. Mention it with `@Image Generator` in any conversation to get started.
## How it works
1. Describe the image you want — include details about subject, style, composition, and mood.
2. Image Generator creates an image based on your prompt.
3. Review the result and ask for changes or variations in the same conversation.
You can combine Image Generator with other agents in the same chat. For example, use an agent to draft marketing copy, then ask Image Generator to create matching visuals.
## Credit cost
Image Generator typically costs 10+ credits per run.
## Frequently asked questions (FAQs)
Mention `@Image Generator` in any Chat conversation and describe the image you want to create.
Yes. You can @ mention Image Generator alongside your own agents or other built-in agents in the same conversation.
Yes. You can keep prompting Image Generator in the same conversation to create additional images or variations.
# Website Builder
Source: https://relevanceai.com/docs/get-started/chat/chat-agents/website-builder
Build websites from a prompt or description using the Website Builder agent in Chat
Website Builder is a built-in Agent in Chat that generates complete websites from a text prompt or description. Mention it with `@Website Builder` in any conversation to get started.
## How it works
1. Describe the website you want — include details about layout, content, style, and purpose.
2. Website Builder generates a complete website based on your prompt.
3. Review the result and ask for changes in the same conversation.
You can combine Website Builder with other agents in the same chat. For example, use [Deep Researcher](/docs/get-started/chat/chat-agents/deep-researcher) to gather content on a topic, then ask Website Builder to turn it into a site.
## Credit cost
Website Builder typically costs 100+ credits per run. Credit usage varies based on the complexity and length of the generated site.
## Frequently asked questions (FAQs)
Mention `@Website Builder` in any Chat conversation and describe the website you want to create.
Yes. You can @ mention Website Builder alongside your own agents or other built-in agents in the same conversation.
Yes. After Website Builder generates a site, you can ask it to make changes in the same conversation — update copy, adjust layout, change colors, and so on.
# Chat
Source: https://relevanceai.com/docs/get-started/chat/introduction
Use AI Agents and Workforces in a chat interface on desktop, mobile, and browser
Chat is where you interact with your AI Agents and Workforces. @ mention any Agent, combine multiple Agents in one conversation, or use pre-built Agents for tasks like generating images, deep research, and building slides — all from [chat.relevanceai.com](https://chat.relevanceai.com), on desktop and mobile.
Once you build an Agent or clone one from the Marketplace, you can use it in Chat — and [control which Agents are visible](/docs/get-started/chat/using-agents#agent-visibility) to your team.
## What you can do with Chat
Mention any Agent in your project to bring its capabilities into a conversation
Reusable prompt templates shared across your team
Pre-built Agents for research, images, and slides
## Getting started
Navigate to [chat.relevanceai.com](https://chat.relevanceai.com) to start chatting. Chat works on desktop and mobile browsers, and is also available as a desktop app. Native [Android and iOS apps](/docs/get-started/chat/mobile-app) are also available.
### Selecting an LLM
You can choose which LLM to use for your conversation, or select **Auto** to let Chat pick the best model for your request.
Once you've selected your model, you can [run Agents and Workforces](/docs/get-started/chat/using-agents) in your Chat conversations.
## Supported file types
Upload documents, images, and data files to give your conversations context, or generate new files from Agent responses. The following extensions are fully supported — other file types can still be uploaded but may not be processed reliably.
Chat can preview 70+ file types directly in the conversation. Pasting from clipboard is limited to images only.
pdf, doc, docx, ppt, pptx, xls, xlsx, csv, txt, md, xml, json, abw
png, jpg, jpeg, webp, gif, svg, avif, bmp
**Audio:** mp3, wav, ogg, m4a, aac, aiff, flac
**Video:** mp4, mpeg, mov, webm, avi, flv, mpg, wmv
zip, bin, arc
### File capabilities by provider
Each provider supports different file types for reading (uploading files as context) and creating/exporting (generating new files from Chat responses).
File export is not supported for organizations in the AU region.
**Size limits:** 32 MiB per file, 50 MiB combined per message
**Document files:**
* `.docx` — read and create/export
* `.docx` with images — create/export only
* `.xlsx` — read (converted to text) and create/export
* `.csv` — read and create/export
* `.pdf` — read and create/export
* `.pdf` with images — read and create/export
* `.txt` — read and create/export
* `.md` — read only (create/export available on request)
**Image files:**
* `.png` — read and create/export
* `.jpg` / `.jpeg` — read and create/export (exported as PNG)
**Not supported:** `.pptx`
**Size limits:** 32 MiB per file, 32 MiB combined per message
**Document files:**
* `.docx` — read and create/export
* `.docx` with images — create/export only
* `.xlsx` — read (converted to text) and create/export
* `.csv` — read and create/export
* `.pdf` — read and create/export
* `.pdf` with images — read and create/export
* `.txt` — read and create/export
* `.md` — read (limited) only (create/export available on request)
**Image files:**
* `.png` — read and create/export
* `.jpg` / `.jpeg` — read and create/export (exported as PNG)
**Not supported:** `.pptx`
**Size limits:** 32 MiB per file, 50 MiB combined per message
**Document files:**
* `.docx` — read and create/export
* `.docx` with images — create/export only
* `.xlsx` — read (converted to text) and create/export
* `.csv` — read and create/export
* `.pdf` — read and create/export
* `.pdf` with images — read and create/export
* `.txt` — read and create/export
* `.md` — read only (create/export available on request)
**Image files:**
* `.png` — read and create/export
* `.jpg` / `.jpeg` — read and create/export (exported as PNG)
**Video and audio (Gemini Pro only):**
* Video: `.mp4`, `.mpeg`, `.mov`, `.avi`, `.flv`, `.mpg`, `.webm`, `.wmv`
* Audio: `.wav`, `.mp3`, `.aiff`, `.aac`, `.ogg`, `.flac`
**Not supported:** `.pptx`
Video and audio files are only supported with Gemini. If you attach a video using an Anthropic or OpenAI model, the send button is blocked.
## Frequently asked questions (FAQs)
Chat credit usage will show up in the **Plan & Billing** credit monitoring section as **'Chat Orchestrator'**.
You'll be charged credits based on:
* The LLM model you're using in Chat
* How much you use Chat (number of messages and interactions)
Built-in agents like [Slide Builder](/docs/get-started/chat/slide-builder) will also appear on this page when you use them in Chat.
To monitor your Chat credit usage, navigate to **Settings > Plan & Billing** to see a detailed breakdown of your credit expenses. Learn more about [Plans and credits](/docs/admin/subscriptions/plans).
Yes, you can select the LLM you want to use in Chat by following these steps:
1. Click on the cog icon in the top right of your screen
2. Choose the 'Chat Model' on the pop-up that appears
You can also add to the System Prompt for your Chat from this screen.
Yes. Relevance Chat is available as a native [Android and iOS app](/docs/get-started/chat/mobile-app), and you can also use it in any mobile browser at [chat.relevanceai.com](https://chat.relevanceai.com). The main Relevance AI platform ([app.relevanceai.com](https://app.relevanceai.com)) is not available on mobile — the mobile apps are Chat-only.
Yes! Chat Memory allows Relevance Chat to remember and reference your recent conversations. You can ask questions like "What did I ask about earlier?" or "Who did I compare X against recently?" and get contextual answers based on your chat history.
**Important limitations:** Chat Memory only remembers history within the same project, and you can only access your own chat history, not other users' conversations in the same project. This is different from Agent memory, which is conversation-specific memory within individual Agent interactions.
You can switch between projects using the project selector in the bottom left of the Chat interface. You can also use **Cmd + K** (Mac) or **Ctrl + K** (Windows) for quick access. When you switch projects, you'll have access to all agents available in that project.
For more details, see [Learn how to switch projects in Chat](/docs/admin/project-management/switch-projects#switching-projects-in-chat).
Edge regions (US Edge, AU Edge, and EU Edge) are available in the Chat browser extension and desktop app. If your project is in an Edge region, it will appear in the project switcher labeled with **(Edge)** — for example, **US (Edge)**.
To select an Edge region project, open the project switcher and look for the **(Edge)** label next to the region name. For detailed instructions, see [how to switch projects in Chat](/docs/admin/project-management/switch-projects#selecting-an-edge-region-in-chat).
Edge regions aren't available in the [Android and iOS apps](/docs/get-started/chat/mobile-app).
Chat supports the following keyboard shortcuts:
| Action | Mac | Windows |
| -------------------------------- | ------ | ------- |
| Toggle left panel (chat history) | Cmd+\\ | Ctrl+\\ |
| Toggle right panel (Super GTM) | Cmd+B | Ctrl+B |
| Switch projects | Cmd+K | Ctrl+K |
You'll be able to select the project you want to use Chat on in the bottom left. You'll be able to use all of the Agents you have access to in this project. If you want to access Agents in another project, you'll need to switch to that project in the bottom left.
Not at this time, but we hope to add this feature soon!
Not at this time, but we hope to add this feature soon!
# Mobile app
Source: https://relevanceai.com/docs/get-started/chat/mobile-app
Use Relevance Chat on Android and iOS
Take your Agents and Workforces on the go. Dictate messages with voice-to-text, attach photos straight from the camera, share content into Chat from any app on your device, and @ mention any Agent in the conversation.
Most features work the same as on [chat.relevanceai.com](https://chat.relevanceai.com), so workflows you've already set up keep working on mobile. This page covers what's different, including [mobile-only features](#mobile-only-features) and [features that aren't available yet](#not-available-in-the-mobile-app).
## Where to download the Chat mobile app
Get Relevance Chat on Google Play
Get Relevance Chat on the App Store
## How to sign in to the mobile app
Launch the app on your Android or iOS device.
The sign-in page opens inside the app.
Sign in with email and password, SSO, Google, or Apple.
## What's available on mobile
Dictate directly into the chat input instead of typing
Attach photos straight from the camera, alongside files and gallery images
Use the Android or iOS share sheet from any app to start a new chat with the shared text, image, or one or more files
Share a chat message or slide deck out through the OS share sheet
Follow the system theme, or override it in Settings
Choose Off, Standard, or Extended thinking for the model under Settings → Preferences
The mobile apps share the core Chat experience with the web app, so workflows you've already set up keep working on the go.
Bring any Agent into a conversation with @ mentions
Reuse prompt templates shared across your team
Generate slide decks from a chat conversation
Pick the model used for new conversations
Attach files to messages from your device
Generate images directly inside a chat
Run Agents, Tools, and Workforces from chat
Rate responses to improve future replies
Move between projects without signing out
Messages render formatted markdown the same as on web
## How to navigate the mobile app
Two parts of the screen do most of the work — the **action bar** next to the chat input (for what you can do *inside* a conversation), and the **side menu** (for moving *between* conversations and reaching your account).
Tap the **+** next to the message input to open the action menu. From there, browse the drop-down to pick a pre-built Agent, the slide builder, or the image generator. Tap the microphone to dictate instead of typing.
Tap the menu icon to open the side panel. Start a new conversation with **New chat**, tap a previous chat to reopen it, or jump to your account from the same menu.
## How to sign out of the Relevance Chat app
Tap the menu icon in the top corner of the chat screen.
Open the **Account** section to see the user you're signed in as.
Confirm to sign out of the app.
## FAQ
Get Relevance Chat on [Google Play](https://play.google.com/store/apps/details?id=com.relevanceai.android\&hl=en) for Android or the [App Store](https://apps.apple.com/au/app/relevance/id6757512568) for iOS.
Tap **Enterprise login** on the sign-in page, then sign in with email and password, SSO, Google, or Apple.
Open settings and go to **Workspace** to switch projects. You'll also see your organization and region there (read-only).
Open settings and go to **Chat** to pick the model used for new conversations.
Open settings and go to **Preferences** to set the thinking level (Off, Standard, Extended) and choose a light, dark, or system theme.
Open the settings menu to manage your account and customize Chat. It groups options into **Account** (signed-in user, sign out), **Workspace** (project, organization, region), **Chat** (model), **Preferences** (thinking level, theme), and **About** (app version and links).
Open settings and go to **About** to see the installed app version and reference links.
A few features aren't in the mobile apps yet — Edge regions, browser extension page-aware actions, keyboard shortcuts, and clipboard paste for files and images. Use the Chat browser extension or desktop app if you need them.
No. US Edge, AU Edge, and EU Edge are only available in the [Chat browser extension and desktop app](/docs/admin/project-management/switch-projects#selecting-an-edge-region-in-chat).
No. Page-aware actions that rely on the browser extension itself aren't available in the mobile apps.
No. The shortcuts listed in the Chat overview don't apply on mobile.
No. Use the camera or attachment picker instead.
# Saved prompts
Source: https://relevanceai.com/docs/get-started/chat/saved-prompts
Create, use, and manage reusable prompt templates in Chat
Saved prompts are currently in limited availability and being rolled out to select customers.
Saved prompts are reusable prompt templates that help standardize common queries across your team. They allow you to create, manage, and share frequently-used prompts with everyone in your project, ensuring consistency and saving time on repetitive tasks.
## Saving a prompt
Save any prompt from your Chat conversations to make it available to all users in your project through the @ menu.
Enter the prompt you want to save.
After sending your prompt, click the bookmark icon that appears under it.
Give the prompt a descriptive name and click **Save**.
For Enterprise customers, the ability to create and manage saved prompts can be controlled through role-based access controls (RBAC). Learn more about [RBAC and user permissions](/docs/enterprise/rbac).
## Using saved prompts
All users in the project can access and use saved prompts in their Chat conversations. Saved prompts appear alongside Agents in the @ menu, making it easy to reuse standardized prompt templates.
1. Type @ in the chat input field to open the menu
2. Click 'Prompts' in the pop-up that appears
3. Select the saved prompt you want to use from the list
## Deleting a saved prompt
To delete a saved prompt:
1. Type @ in the chat and click 'Prompts' in the pop-up
2. Click the 'X' button next to the prompt you want to remove
3. Click 'Delete' on the confirmation pop-up to confirm deletion
Combine saved prompts with @ mentioned Agents for workflows that use both reusable templates and specialized AI capabilities.
# Slide Builder
Source: https://relevanceai.com/docs/get-started/chat/slide-builder
Use Slide Builder in Chat to create AI-generated slide decks
Slide Builder is a built-in Agent in Chat that allows you to generate slides based on your prompt. Slide Builder first creates a presentation outline showing all planned slides, allowing you to review and refine the structure before building. You can give Slide Builder a simple prompt, use built-in Agents like Deep Researcher to find info on a topic and then generate slides, or use your Agents and Workforces to produce an output that Slide Builder can then turn into slides.
## Key features
Tell Slide Builder what you want, and it will create a slide deck based on your prompts or instructions.
Review a complete presentation outline with slide titles and descriptions before any slides are built.
Ask Slide Builder to modify or update your slides.
Share your pre-existing text, slides, notes and Slide Builder will use your information in the slides.
Work with your Relevance AI agents or Workforces to research or generate content.
Your slides can look and feel exactly like your brand.
Export your slides in multiple formats including PDF, Images, PPTX, and JSON to re-use them in a new chat or share with others.
## Getting started
1. **Navigate to Slides**: In [Relevance Chat](https://chat.relevanceai.com/chat/start), select the Slides feature.
2. **Plan your content and slide design**: Look at [Generating content and designing slides](/docs/get-started/chat/slide-builder#generating-content-and-designing-slides) for tips.
3. **Review and refine**: Review the generated slides and prompt Slide Builder to make changes.
4. **Present and share**: Use the slides directly in Slide Builder, share with others, or export them using the Export button.
### Generating content and designing slides
Tell Slide Builder what content you want on your slide deck. Alternatively, use `@` to integrate your Relevance AI agent or Workforce.
Upload a PDF or file with the information you want and Slide Builder will display it on your slides.
Upload screenshots of the branding or design you want displayed on the slides and Slide Builder will match your style.
Use the Remix feature to instantly refresh your slide designs while keeping all your content intact. Ask Slide Builder to "remix" your slides to explore different visual styles and layouts.
Request to see the outline first, then build slides one at a time or all at once. Example: "Create 10 slides about frogs, but only build slide 1" lets you preview before completing the full deck.
## BrandKits and Templates
Slide Builder includes two features to help you create consistent, professional presentations: **BrandKits** and **Templates**.
### BrandKits
A BrandKit ensures your slides are on-brand every time. It defines the visual identity of your presentations, including colors, typography, logos, and even the tone and voice of your content.
Slide Builder comes with **two default BrandKits** to get you started, but you can also create your own custom BrandKit.
#### What's included in a BrandKit
Visual references that set the overall aesthetic
The colors that represent your brand
Typography for headers and body text
Your brand logos to include in slides
The personality of your brand (e.g., professional, friendly, bold)
How your brand communicates (e.g., formal, conversational)
Specific instructions for preferred layouts or slide styles
#### Creating a BrandKit
You can create a BrandKit in two ways:
1. **From brand images**: Upload existing brand assets and let AI extract your colors, tone, and font styles automatically.
2. **From scratch**: Manually define each element of your brand, giving you complete control over every detail.
#### How to create a BrandKit
1. Open Slide Builder and click **New BrandKit**, then select **From scratch** to manually build your BrandKit.
2. Upload moodboard images that represent your brand's visual style using the upload icon.
3. Add brand colors using the plus icon under **Colors**, select your desired colors, and click **Done** to confirm.
4. Select font styles for your slide headers and body content.
5. Add your logo by clicking the logo area or dragging and dropping your company image file.
6. Enter brand tone and voice in the provided text fields to define how your brand communicates.
7. Click the **Slide instructions** tab and enter your slide design guidelines.
8. Click **Done** to complete your BrandKit configuration.
9. Select your BrandKit from the list, enter your presentation topic and content, then click send to generate your slides.
### Templates
A Template captures the structure and formula of slides you've already created, allowing you to replicate successful presentations or use them as inspiration for new ones. This makes them perfect for standardizing recurring presentations like weekly reports, pitch decks, or training materials.
#### Creating a Template
Templates are created from existing slides. Once you've built a slide deck you're happy with, you can save it as a Template to reuse later.
#### How to create a Template
1. Click the **Convert to template** button on a previously created slide deck.
2. Enter a template name in the input field, then click **Convert to template** to save your slides as a reusable template.
3. In a new chat, click **Slide Builder** and select your template from the **Templates** section.
4. Enter your presentation topic along with any content to include, then click **Send** to generate your slides.
You can use BrandKits and Templates together. Set your BrandKit first to define your visual identity, then apply a Template to structure your slides. Slide Builder will combine both for a consistent, on-brand presentation.
## Exporting slides
You can export your slides in multiple formats to share, present, or reuse them in other contexts. Slide Builder supports four export formats:
* **PDF**: Export your entire slide deck as a single PDF file, perfect for sharing or printing.
* **Images**: Download each slide as an individual image file, useful for embedding slides in other documents or presentations.
* **PPTX**: Export your slides as a PowerPoint presentation file, compatible with Microsoft PowerPoint and other presentation software.
* **JSON**: Export the slide data structure to upload into a new chat session, allowing you to recreate slides or use them as a reference for future presentations.
### How to export slides
Follow these steps to export your slides:
1. **Open your slides in Relevance Chat**: Navigate to your slide deck in [Relevance Chat](https://chat.relevanceai.com/chat/start).
2. **Click Export**: In the top right of the slides pane, click the **Export** button.
3. **Select the desired format**: Choose from PDF, Images, PPTX, or JSON export options.
### Export limitations and notes
* **Animations and moving elements**: When presenting slides in chat, they may include animations or moving elements. However, when exported, these dynamic elements will be lost. Exported slides will show the static final state of each slide.
## Frequently asked questions (FAQs)
Just tell Slide Builder what changes you want to make. It's AI-generated!
Yes! You can upload your own files and documents, or integrate your Relevance AI agents to help populate the slides with your own content.
Yes! Slide Builder creates a presentation outline first, showing all planned slide titles and descriptions. You can request changes to the outline before building the actual slides.
Yes! You can request to build slides incrementally, such as "Create a 10-slide presentation but only build the first 3 slides." This helps you preview the style before completing the full deck.
Choose the format based on your needs: Use **PDF** for sharing or printing complete presentations, **Images** for embedding individual slides in other documents, or **JSON** to save and recreate your slides in a new chat session.
To use the Slide Builder feature, you will need to sign up and create an account.
## Follow along on YouTube
We also have a number of YouTube tutorials you can use to follow along with and learn how to use Slide Builder.
# File system
Source: https://relevanceai.com/docs/get-started/chat/super-gtm/file-system
Persistent storage for documents and reference material that the agent can access across all conversations
The file system is the agent's persistent storage. It holds shared documents, reference material, deliverables, and working files that the agent can read from or write to as instructed. It's completely separate from your integration connections (HubSpot, Gmail, Slack, etc.) — the agent works with those directly.
Think of the file system as a shared drive for your project. Anything you want the agent (or your team) to have access to across conversations lives here.
## Where to find files
You can view and manage your files in the **Files** tab. From here you can browse all project files, upload new documents, and see what the agent has saved.
## Key areas
Persistent storage shared across your project. This is where shared knowledge lives — company context, reference documents, templates, and anything the team needs access to across conversations.
To add something to project files, just ask the agent:
> "Save this report to the project files"
> "Create a document in project files called Q3 Campaign Brief"
You can also ask the agent to read, search, or update anything already stored there:
> "What's in the project files?"
> "Find the competitive analysis in project files"
> "Update the onboarding checklist with the new step"
Project files are managed by project admins.
Workspace scoped to a conversation. The agent uses this for working files — exploration results, execution plans, and task lists. Session files persist across sessions in a folder matching the conversation ID, but they're separate from shared project files.
You generally don't need to interact with session files directly. The agent manages them as part of its workflow.
## How skills use the file system
Skills can optionally pull context from the file system. Each skill can have its own `/references` or `/assets` folder for skill-specific context, or reference shared project files when the same document is relevant across multiple skills.
When a skill runs, the agent fetches the relevant files at that moment — you can update a reference file once and all skills that use it pick up the new version automatically.
This is useful for storing things like:
* Templates that skills use as a starting point
* Reference documents (brand guidelines, process docs, competitive intel)
* Deliverables the agent produces that should persist across conversations
* Ways of working that the whole team should follow
# Integrations
Source: https://relevanceai.com/docs/get-started/chat/super-gtm/integrations
Connect your GTM tools to Super GTM via OAuth, API key, or built-in integrations
Super GTM connects to your go-to-market tech stack so the agent can read data and take actions across your tools. Integrations are managed from the Super GTM settings panel.
## Connecting integrations
Click the gear icon next to the Super GTM toggle.
Navigate to the **Integrations** section and locate the tool you want to connect.
Click **Connect account** (OAuth) or **Add API key** (API key integrations) and follow the prompts.
### Connection methods
You click **Connect**, log in to the third-party service, and Relevance securely stores your tokens. No manual key management needed.
1. Click **Connect** on the integration
2. A modal opens and redirects you to the third-party login (e.g. Google, HubSpot)
3. Authorize the requested scopes
4. The integration shows as connected and is immediately available
Each user must connect their own OAuth integrations individually. For per-user OAuth setup at the organizational level, see [user-level authentication](/docs/enterprise/user-level-authentication).
You paste in a key from the third-party platform's settings page.
Enter API keys via the integrations settings page — accessible from the Super GTM settings panel (click the external link icon on the integration) or from your project's Integrations page directly.
A project admin can configure API key integrations at the project level (e.g. a shared Gong API key for the whole team), so individual users don't need to connect personally — they inherit the project's credentials. Admins can manage these in the builders app under [Integrations & API Keys](/docs/get-started/core-concepts/api-integration).
Depending on how your organization has configured each external application, you may need to request admin access to enable OAuth or to obtain an API key. Check with your IT team or the admin of the external application.
### Managing connections
All active integrations are visible in the Super GTM settings panel. Each integration has one of three states:
Integration is active and the agent can use it
Credentials exist but you've toggled it off in your settings
No credentials stored — a "Connect" button is shown
### Write approval
Every integration action is classified as either a read or a write (create, update, delete). You control how the agent handles writes.
The agent pauses and asks for your approval before writing to any integration — e.g. "I'm about to create a contact in HubSpot — approve?"
The agent executes writes automatically without asking for confirmation.
Override write approval on a per-integration basis from the settings modal. For example: auto-approve Slack posts but always require approval for HubSpot CRM updates.
Certain built-in Agents (like Explorer) are hardcoded to read-only — they can query and search integrations but cannot write anything, regardless of your approval settings.
### Setup details
**Connection method:** OAuth
Gives Super GTM read and write access to your HubSpot CRM — search contacts, companies, and deals; create and update records; manage sequences and pipelines; pull activity history.
HubSpot requests a broad set of optional scopes (contacts, companies, deals, files, tickets, automation sequences, sales email, pipeline management). This is intentional to enable the full range of Super GTM workflows. You can review and approve scopes during the OAuth flow.
**How to connect:**
1. In the Super GTM settings panel, find **HubSpot** under Integrations
2. Click **Connect account**
3. Sign in to HubSpot and authorize access when prompted
4. Select the HubSpot portal to connect if you have multiple
**Things to know:**
* Each user must authorize their own HubSpot connection
* If your HubSpot portal restricts app installations, a HubSpot admin needs to enable App Marketplace access for your user — see [Troubleshooting](#troubleshooting) below
* The agent respects your HubSpot user permissions — it can only access records you have permission to see
**Connection method:** OAuth
**Additional field:** **Sandbox account** checkbox — enable this if you're connecting a Salesforce sandbox (test/staging) environment. Routes login to test.salesforce.com instead of login.salesforce.com.
Connects Super GTM to your Salesforce org — full API access with read and write CRM data, SOQL queries, and actions across Salesforce objects.
**How to connect:**
1. In the Super GTM settings panel, find **Salesforce** under Integrations
2. If you're connecting a sandbox (test/staging) environment, check **Sandbox account** before proceeding — this routes login to test.salesforce.com instead of login.salesforce.com
3. Click **Connect account**
4. Sign in to Salesforce and authorize the connection
5. If your org requires admin approval for connected apps, request access from your Salesforce admin
**Things to know:**
* Salesforce organizations often require admin approval for new OAuth apps — see [Troubleshooting](#troubleshooting) below if the connection fails
* The agent operates within your Salesforce user permissions and sharing rules
* Custom objects and fields are accessible if they're visible to your user profile
**Connection method:** API key
Gives Super GTM access to Apollo's sales intelligence database — search and enrich contact and company data, find contact information, pull prospect details.
**How to connect:**
1. Log in to Apollo and navigate to Settings > Integrations > API
2. Generate an API key
3. In the Super GTM settings panel, find **Apollo** under Integrations
4. Click **Add API key** and paste your Apollo API key
**Things to know:**
* Apollo API keys are scoped to your Apollo account — each user needs their own key, or an admin can add a shared project-level key
* API usage counts against your Apollo plan's API limits
**Connection method:** API key
Connects Super GTM to Gong call recordings and transcripts — pull call data, surface key moments, incorporate conversation intelligence into deal briefings.
**How to connect:**
1. In Gong, navigate to Settings > Ecosystem > API
2. Generate an API key (requires Gong admin access)
3. In the Super GTM settings panel, find **Gong** under Integrations
4. Click **Add API key** and enter your Gong API credentials
**Things to know:**
* Gong API access typically requires Technical Admin permissions in Gong — check with your Gong admin
* The agent can only access calls that are already processed and indexed in Gong
**Connection method:** API key
Connects Super GTM to your Salesloft account for sales engagement workflows.
**How to connect:**
1. Log in to Salesloft and navigate to your API settings
2. Generate an API key
3. In the Super GTM settings panel, find **Salesloft** under Integrations
4. Click **Add API key** and paste your Salesloft API key
**Connection method:** OAuth
Connects Super GTM to your Slack workspace — read and post messages, search conversations, list users, manage channels, add reactions.
**How to connect:**
1. In the Super GTM settings panel, find **Slack** under Integrations
2. Click **Connect account**
3. Select your Slack workspace and authorize the requested permissions
4. If your workspace restricts app installations, request approval from your Slack admin
**Things to know:**
* Slack workspace admins can restrict which apps users can install — if the authorization fails, you may need admin approval
* The agent can only read messages in channels it has been added to, and public channels
* Posting to channels requires the agent to have access to those channels
**Connection method:** OAuth (via GSuite)
Connects Super GTM to your Gmail account — compose, read, send, and draft emails, manage labels, modify settings.
**How to connect:**
1. In the Super GTM settings panel, find **GSuite** under Integrations
2. Click **Connect account** and sign in with your Google account
3. Grant the requested Gmail permissions
4. If your Google Workspace organization restricts third-party app access, contact your Google Workspace admin
**Things to know:**
* Gmail access is part of the GSuite integration, which also covers Google Calendar, Google Docs, Google Drive, and Google Sheets
* Google Workspace organizations often have policies restricting which apps can access Gmail — your admin may need to approve the connection
* Sent emails appear in your Gmail Sent folder as normal
**Connection method:** OAuth
Connects Super GTM to your Microsoft Outlook account — read, send, and draft emails, manage labels and mailbox settings.
**How to connect:**
1. In the Super GTM settings panel, find **Microsoft Outlook** under Integrations
2. Click **Connect account**
3. Sign in with your Microsoft account and grant the requested permissions
4. If your Microsoft 365 tenant restricts app consent, your IT admin may need to grant admin consent
**Things to know:**
* Microsoft 365 organizations often require admin consent for third-party OAuth apps — contact your IT admin if the authorization fails
* The connection covers your personal Outlook mailbox; shared mailboxes may require additional configuration
**Connection method:** OAuth
Gives Super GTM access to your Microsoft Teams environment — read and send chat and channel messages, read meeting transcripts, manage online meetings.
**How to connect:**
1. In the Super GTM settings panel, find **Microsoft Teams** under Integrations
2. Click **Connect account**
3. Sign in with your Microsoft account and authorize the connection
4. Admin consent is typically required for Teams app integrations — work with your IT admin
**Things to know:**
* Teams API access almost always requires Microsoft 365 admin consent — plan for this when setting up
* Meeting transcript access requires that transcription is enabled in your Teams tenant
**Connection method:** OAuth (via GSuite)
Connects Super GTM to your Google Calendar — check availability, create events, get scheduling context.
**How to connect:**
Google Calendar access is included with the GSuite integration. Connect via the **GSuite** option in the Integrations section.
**Things to know:**
* Calendar access is part of the GSuite integration alongside Gmail, Google Docs, Google Drive, and Google Sheets
* The agent can only create events on calendars you have write access to
* Meeting invitations sent by the agent will come from your Google account
**Connection method:** OAuth
Connects Super GTM to Microsoft Calendar (via Microsoft 365) — create and manage calendar events, including shared calendars.
**How to connect:**
1. In the Super GTM settings panel, find **Microsoft Calendar** under Integrations
2. Click **Connect account**
3. Sign in with your Microsoft account and authorize the connection
**Things to know:**
* Microsoft Calendar access is separate from Microsoft Outlook — you can connect either or both
* Shared calendar access depends on your Microsoft 365 permissions
**Connection method:** OAuth (via GSuite)
Connects Super GTM to Google Docs — read and edit documents, pull content from existing docs, create new documents.
**How to connect:**
Google Docs access is included with the GSuite integration. Connect via the **GSuite** option in the Integrations section.
**Things to know:**
* Google Docs access is part of the GSuite integration alongside Gmail, Google Calendar, Google Drive, and Google Sheets
* The agent can only access documents shared with or owned by your Google account
**Connection method:** OAuth (via GSuite)
Connects Super GTM to Google Drive — read and write files, search across your Drive.
**How to connect:**
Google Drive access is included with the GSuite integration. Connect via the **GSuite** option in the Integrations section.
**Things to know:**
* Google Drive access is part of the GSuite integration
* The agent can only access files shared with or owned by your Google account
**Connection method:** OAuth (via GSuite)
Connects Super GTM to Google Sheets — read and write spreadsheet data.
**How to connect:**
Google Sheets access is included with the GSuite integration. Connect via the **GSuite** option in the Integrations section.
**Things to know:**
* Google Sheets access is part of the GSuite integration
* The agent can only access spreadsheets shared with or owned by your Google account
**Connection method:** OAuth
Connects Super GTM to your Notion workspace — read and create pages, query and create databases, create comments, manage blocks, search.
**How to connect:**
1. In the Super GTM settings panel, find **Notion** under Integrations
2. Click **Connect account**
3. Sign in to Notion and select which pages and databases to share with the integration
4. Notion requires you to explicitly grant access to each page or database — the agent can only see what you've shared
**Things to know:**
* Notion's permission model is selective: you must share specific pages or databases during the OAuth flow. The agent cannot see anything you haven't explicitly shared.
* If you want the agent to access new Notion pages in the future, you'll need to update the connection to include them
**Connection method:** OAuth or API key
Linear is the only integration that supports both OAuth and API key. You can choose whichever you prefer — both methods work interchangeably. If either is configured, the integration shows as connected.
Connects Super GTM to Linear — read, create, update, and archive issues, manage comments, read projects and labels.
**How to connect:**
*OAuth (per user):*
1. In the Super GTM settings panel, find **Linear** under Integrations
2. Click **Connect account** and authorize via your Linear account
*API key (project-level):*
1. In Linear, navigate to Settings > Security & access > Personal API keys
2. Create a new API key
3. In the Super GTM settings panel, find **Linear** under Integrations
4. Click **Add API key** and paste your Linear API key
**Connection method:** API key
Connects Super GTM to Ashby for recruiting and ATS workflows.
**How to connect:**
1. Log in to Ashby and navigate to your API settings
2. Generate an API key
3. In the Super GTM settings panel, find **Ashby** under Integrations
4. Click **Add API key** and paste your Ashby API key
**Connection method:** API key
Connects Super GTM to Avoma for meeting intelligence — access call recordings, transcripts, and meeting notes.
**How to connect:**
1. Log in to Avoma and navigate to your API settings
2. Generate an API key
3. In the Super GTM settings panel, find **Avoma** under Integrations
4. Click **Add API key** and paste your Avoma API key
**Connection method:** API key
Connects Super GTM to Firmable for company data enrichment.
**How to connect:**
1. Log in to Firmable and navigate to your API settings
2. Generate an API key
3. In the Super GTM settings panel, find **Firmable** under Integrations
4. Click **Add API key** and paste your Firmable API key
**Connection method:** API key
Connects Super GTM to ZoomInfo for contact and company intelligence. ZoomInfo is the only integration that requires three separate fields instead of a single API key.
**Required fields:**
* **ZoomInfo Email** — your ZoomInfo account email address
* **ZoomInfo Client ID** — your ZoomInfo API client ID
* **ZoomInfo Private Key** — your ZoomInfo private key (this is a multi-line key, pasted into a larger text area)
**How to connect:**
1. Log in to ZoomInfo and navigate to your account settings
2. Locate your **Email**, **Client ID**, and **Private Key**
3. In the Super GTM settings panel, find **ZoomInfo** under Integrations
4. Enter all three values
**Connection method:** API key
Connects Super GTM to Cursor — list, launch, and stop agents, view conversation history, send follow-up prompts.
**How to connect:**
1. In Cursor, navigate to your account settings and find the API section
2. Generate an API key
3. In the Super GTM settings panel, find **Cursor** under Integrations
4. Click **Add API key** and paste your Cursor API key
### Troubleshooting
When connecting Salesforce to Relevance AI, you may encounter one of these OAuth errors:
This error occurs when the Relevance AI connected app in Salesforce needs to be configured to allow admin-approved users.
A Salesforce administrator must complete these steps:
In Salesforce, click the gear icon in the top right and select **Setup**.
Search for and open **Connected Apps OAuth Usage**.
If the **Relevance AI** app is not already installed, click **Install**. This redirects to the app settings page — skip to step 5.
Navigate to **Manage Connected Apps** and click **Relevance AI**.
This opens the Connected App Detail page for Relevance AI.
Click the **Edit Policies** button on the Connected App Detail page.
Under **OAuth Policies**, set the **Permitted Users** dropdown to one of:
**All users may self-authorize** — any Salesforce user can connect to Relevance AI.
**Admin approved users are pre-authorized** — only users with specific profiles or permission sets can connect. If you choose this option, scroll down to the **Profiles** and **Permission Sets** sections to assign access.
Use **Manage Profiles** or **Manage Permission Sets** to select which users can connect.
If you don't see the Relevance AI app in Connected Apps OAuth Usage, initiate the connection from the Super GTM settings panel first — this registers the app in your Salesforce org.
If a user can't install the Relevance App from the HubSpot App Marketplace, they likely don't have the **App Marketplace access** permission enabled on their account. A HubSpot Super Admin (or any admin with permission to manage users) needs to grant this.
Log in to HubSpot and click the **Settings** gear icon in the top navigation bar.
In the left sidebar, click **Users & Teams**. This shows a list of all users in your HubSpot account.
Find the user who needs access and click **Edit permissions**. This opens the permissions editor.
Scroll down to **Account / Settings Access** (or search for "App Marketplace") and toggle **App Marketplace access** to **ON**. You may also want to enable **App Marketplace uninstall access** if the user should be able to remove apps later.
Click **Save** to apply the new permissions. The user now has App Marketplace access and can install the Relevance App.
To grant access to multiple users at once, select the checkboxes next to each user in the Users & Teams list (they must share the same seat type), click **Edit permissions** at the top, toggle on **App Marketplace access**, and save.
On HubSpot Enterprise, you can also add **App Marketplace access** to an existing Permission Set under **Settings** > **Users & Teams** > **Permission Sets** — all users assigned to that set will automatically receive the permission.
If the permission changes don't take effect immediately, have the user open HubSpot in a private/incognito browser window. If it works there, they just need to clear their browser cache and cookies, then reload HubSpot.
# Super GTM
Source: https://relevanceai.com/docs/get-started/chat/super-gtm/introduction
An AI super agent for your entire go-to-market stack, with persistent skills, memory, and deep integrations
Super GTM is currently in closed beta (started March 2, 2026) and only available for Enterprise customers. If you're an Enterprise customer and want to join the beta, contact your account team.
Super GTM is a Chat mode that gives you an AI super agent capable of working across your entire go-to-market (GTM) technology stack — including CRM, calendar, email, calls, support tickets, and more. It doesn't just read from your tools; it takes actions across them, with your approval.
What sets Super GTM apart from standard Chat is its persistent layer of context: skills that run repeatable workflows, a file system that stores documents and reference material across sessions, and memory that learns your preferences and history over time. These three features work together to make the agent capable, consistent, and personal.
## What you can do with Super GTM
Connect your CRM, calendar, email, call recordings, support tickets, and other GTM tools
Define repeatable workflows the agent can activate automatically whenever you need them
Store documents and reference material that persist across conversations
The agent learns your preferences, feedback, and context — and carries it into every session
Run skills automatically on a recurring schedule
Connect any Agent you've built in Relevance AI so Super GTM can call it as a subagent
## Getting started
### Prerequisites
* You must be on an Enterprise plan with Relevance AI.
* Requires enrollment in the Super GTM closed beta. Contact your account team to request access.
### Enrollment
Super GTM is enabled by Relevance staff after discussion with your Account Executive (AE).
Provide a list of email addresses to your AE
Enable for all users with a specific email domain
Once enrolled, you'll see the Super GTM option in your Chat interface.
### Accessing Super GTM
Go to [chat.relevanceai.com](https://chat.relevanceai.com)
Click the model picker in the chat interface
Toggle on the Super GTM mode
Start working across your GTM stack
[Download the TestFlight app](https://apps.apple.com/us/app/testflight/id899247664) on your iPhone
[Open the invite link](https://testflight.apple.com/join/xx1C1Z6y) to join the Relevance AI iOS beta
Install Relevance AI from within TestFlight. Turn on automatic updates so the app stays up-to-date.
Open the model picker and enable the Super GTM mode toggle
## Quick start
By default, the agent asks for your confirmation before any write action (send, create, update, or delete). You can adjust this per integration in your [integration settings](/docs/get-started/chat/super-gtm/integrations#write-approval).
Click the gear icon next to the Super GTM toggle and connect the tools you use — CRM, calendar, email, and more. See [integrations](/docs/get-started/chat/super-gtm/integrations) for setup instructions.
Start with a real task. Try something like:
> "What deals are closing this month?"
> "Prep me for my next meeting"
> "Draft a follow-up email to the attendees from my last call"
The agent pulls from your connected tools and responds with actionable output.
When you find a workflow you want to repeat, ask the agent to turn it into a [skill](/docs/get-started/chat/super-gtm/skills). Skills save the full process so the agent can run it again without you re-explaining it.
Share feedback with your account team or [contact support](/docs/get-started/support) at any time.
# Memory
Source: https://relevanceai.com/docs/get-started/chat/super-gtm/memory
How the agent remembers your preferences, corrections, and context across conversations
Memory is how the agent learns about you across conversations. It stores your preferences, corrections, project context, and references so the agent gets better over time — without you having to repeat yourself.
The agent checks your memory at the start of every conversation, so it always has your context before it starts working.
## Where to find memory
You can view and manage your memories in the **Overview** tab, under **Context & Memories**. From here you can see all stored memories, review what the agent has learned about you, and remove anything that's outdated or incorrect.
Memory is scoped per user. Your memory is not shared with other users in your project.
## How it works
The agent maintains a memory entry for each thing it learns about you. At the start of each conversation, the agent reads a memory index and opens the individual entries relevant to your request. Those are loaded into the agent's context alongside your message.
The agent doesn't load everything every time — it loads what's relevant. The more clearly your memories are described, the better the selection works.
## Memory types
Information about you — your role, goals, expertise, and preferences. The agent uses this to tailor its work to who you are. For example, you might store that you're a VP of Sales managing a team of 8 AEs focused on enterprise accounts, that you prefer data-driven insights and concise communication, or that you have deep HubSpot experience but are new to Slack integrations.
Corrections and guidance you've given the agent. These are the most impactful memories — they prevent the agent from repeating mistakes. For example, you might correct the agent to keep email drafts professional but warm with no corporate jargon, to avoid including pricing in first outreach emails, or to always present data as bullet points rather than paragraphs.
Context about ongoing work, goals, and timelines that the agent wouldn't otherwise know. For example, you might store that the enterprise team has a \$2.4M pipeline target for Q3 closing September 30, that the Q2 campaign is focused on enterprise expansion, or that a product launch is scheduled for June 15 with deliverables due by June 10.
Pointers to where information lives, so the agent knows where to look. For example, you might tell the agent that deal stage definitions are in the HubSpot wiki under "Sales Process > Deal Stages", that the competitive analysis is saved in project files under /research/competitors.md, or that customer feedback is tracked in a Notion database called "Product Feedback".
## Building up memory over time
You don't need to set up memory all at once. The agent builds it naturally as you work together.
Ask the agent to save something to memory at any time:
> "Remember that I prefer bullet points over paragraphs"
> "Remember that the Q3 target is \$2.4M"
The agent will confirm what it stored and which memory type it used.
When you correct the agent — "No, don't include pricing in the first email" — it saves a feedback memory so it doesn't make the same mistake next time.
If a memory is outdated or incorrect:
> "Forget what you know about the Q2 campaign"
The agent will find and remove the relevant memory.
## How skills and memory work together
[Skills](/docs/get-started/chat/super-gtm/skills) and memory complement each other:
* **Skills define the process.** A skill tells the agent *how* to do something — the steps, the data sources, the output format.
* **Memory personalizes the execution.** Memory tells the agent *your way* of doing it — your tone, your preferences, your priorities.
A well-written skill references memory where it matters. For example, a post-meeting follow-up skill tells the agent to check your memory for communication preferences before drafting emails. The skill is the same for everyone on the team, but the output adapts to each person's style.
This means you can share a project skill with your whole team, and each person's agent executes it differently based on their individual memory.
# Scheduled tasks
Source: https://relevanceai.com/docs/get-started/chat/super-gtm/scheduled-tasks
Set up recurring prompts that Super GTM acts on automatically at a time you define
Scheduled tasks let you configure recurring prompts that Super GTM runs on your behalf at a set time. Instead of manually typing the same request every morning, you write the instruction once, pick a schedule, and the agent handles it from there.
When a schedule fires, the agent receives your saved message exactly as if you had typed it into a conversation. It pulls from your connected [integrations](/docs/get-started/chat/super-gtm/integrations), uses your [skills](/docs/get-started/chat/super-gtm/skills), references your [files](/docs/get-started/chat/super-gtm/file-system), applies [memory](/docs/get-started/chat/super-gtm/memory), and delivers the output — just like a normal Super GTM interaction.
Scheduled tasks is in limited rollout. Your organization needs access enabled before the feature appears. Contact your account team or [reach out to support](/docs/get-started/support) to check availability.
## Where to find schedules
The **Schedules** section lives in the Super GTM panel on the **Overview** tab, below the Calendar and Recently Viewed sections.
## Setting up a scheduled task
In the Super GTM **Overview** tab, scroll to the **Schedules** section and click to add a new schedule.
Enter a natural language instruction — this is the prompt the agent receives when the schedule fires. Write it the same way you would in a conversation.
Examples:
* "Summarize all new Gong calls from the last 7 days"
* "Check my pipeline for deals that haven't had activity in 2 weeks and flag them"
* "Find 5 new prospects matching our ICP and add them to my outreach list"
Choose how often the task should run (daily, weekly, monthly, or annually), the time of day, and your timezone.
Save the schedule. It runs automatically at the next scheduled time.
Write your scheduled message the same way you'd ask the agent in a conversation. The more specific your instruction, the more useful the output.
## Frequency options
Runs every day at a set time — e.g. morning pipeline digest at 9am
Runs on specific days each week — e.g. Monday kick-off report, Friday wrap-up
Runs once a month on a set day — e.g. account health review on the 1st
Runs once a year on a set date — e.g. annual renewal check-in
All schedules run in your selected timezone. Full IANA timezone support (e.g. Australia/Sydney, America/New\_York).
## Managing schedules
You can have up to **10 active schedules**. All management happens from the Schedules section of the Overview tab.
Temporarily stop a schedule without deleting it. Paused schedules show a "(paused)" label in the list. Resume at any time from the same menu.
Update the message, frequency, time, or timezone for an existing schedule. Changes take effect from the next scheduled run.
Remove a schedule permanently when it's no longer needed. This cannot be undone.
Each schedule displays the last time it was triggered, so you can confirm it's running as expected.
## Use cases
"Every morning, summarize my open deals and highlight any at-risk accounts"
"Every Monday, find 5 new prospects matching our ICP criteria and add them to my outreach list"
"Every Friday at 5pm, prepare a summary of this week's customer conversations from Gong"
"Every Tuesday, remind me of any contacts I haven't followed up with in 2+ weeks"
# Skills
Source: https://relevanceai.com/docs/get-started/chat/super-gtm/skills
Repeatable workflows that your agent activates automatically based on what you ask for
Skills are repeatable workflows that the agent activates based on what you ask for. Each skill defines the instructions, integrations, output format, and reference material for a specific task.
When your request matches a skill, the agent loads it and follows the instructions step by step. You don't need to explain how to do the work — the agent already has everything it needs.
## Where to find skills
View and manage your skills in the **Skills** tab in the right-side panel.
Browse all available skills (project, user, and built-in), see which are active, and open any skill to view or edit its contents.
## How the agent knows what's available
The agent sees all available skills at the start of every conversation. When your request matches a skill, it activates the skill and loads the full instructions.
You don't need to reference skills by name. Just describe what you need, and the agent will match it to the right skill if one exists.
To reference a skill directly, use the `/` menu. Type `/` in the chat input to see your available skills, then filter by typing part of the skill name. Use the arrow keys to navigate and press Enter or Tab to insert the skill into your message.
## How to create a skill
Ask the agent:
> "Create a skill that does \[description of the workflow]"
The agent activates the built-in **Skill Creator** and walks you through defining the workflow, integrations, output format, and whether it should be a project skill (shared) or user skill (personal). The agent handles formatting and saving. You can also ask the agent to update an existing skill at any time.
### Example: creating a post-meeting follow-up skill
After a sales call, you ask the agent:
> "Summarize my call with Relevance AI. Pull the action items, update the deal in HubSpot, and draft a follow-up email to the attendees."
The agent finds the meeting in Google Calendar, reads the transcript, extracts action items, updates HubSpot, and drafts the email. You refine:
> "Always include the deal stage and next scheduled meeting in the summary. Format the action items as a table with columns for action, owner, and deadline."
The agent adjusts the output. Now you tell it:
> "Make a skill out of this conversation."
The agent activates the Skill Creator, reviews the conversation, and builds a skill that captures the full workflow — steps, integrations, output format, and your formatting preferences. It saves the skill to your catalog. From then on, the agent can run that same workflow whenever you need it.
From then on, whenever you say something like:
* "Follow up on my call with Relevance AI"
* "I just got off a call with Sarah — process it"
* "Summarize my last meeting and update the CRM"
The agent matches your request to the skill and runs the same workflow.
**What you get back:**
* Meeting summary (date, attendees, duration, deal stage, next scheduled meeting)
* Action items table (action, owner, deadline)
* Confirmation of what was updated in HubSpot
* A draft follow-up email ready to send or edit
* Any open questions that need attention
The skill captures the process, not specific data. The agent adapts it to whatever meeting and CRM records are relevant.
## Types of skills
Shared workflows available to everyone in your project. Use these for recurring tasks your team handles the same way — post-meeting follow-ups, pipeline reviews, or weekly reporting.
Only admins can create and edit project skills. All project members can use them.
Personal workflows private to you. Use these for tasks tailored to your role or preferences — your specific outreach style, how you like reports formatted, or a workflow only you need.
Create and edit your own user skills freely. Other team members can discover and read them, but can't modify them.
Skills that ship with the platform. These include:
* **Skill Creator** — helps you build new skills (see [How to create a skill](#how-to-create-a-skill) above)
* **Meeting Prep & Summary** — prepares you for upcoming meetings using your calendar, transcripts, and notes. Requires a meeting integration like Google Calendar. Use it as a reference when creating your own skills.
Built-in skills are read-only and available to everyone.
## Running skills on a schedule
Skills don't have to be triggered by a conversation. Schedule the agent to run a skill automatically on a recurring basis — daily, weekly, monthly, or annually. Set up schedules in the **Overview** tab in the right-side panel.
You have a skill called **Follow up all calls** that checks recent meetings, lists outstanding action items, and flags clients you haven't followed up with. You schedule it to run every weekday morning at 9am.
Each morning, the agent runs the skill, checks your calendar and CRM, and sends you a summary — missed follow-ups, overdue action items, and calls without a recap.
This is useful for any skill that benefits from regular execution:
Summarize deal movements, stale opportunities, and next actions each morning.
Generate end-of-week reports covering activity metrics, closed deals, and upcoming priorities.
Flag missing fields, outdated contacts, and deals without recent activity.
Brief you on upcoming meetings, attendee context, and open action items for the week.
To set up a schedule, go to the **Schedules** section in the **Overview** tab. Choose the skill, set the cadence, and the agent runs it automatically. See [scheduled tasks](/docs/get-started/chat/super-gtm/scheduled-tasks) for full details.
## Tips for writing and managing skills
The agent already knows how to create, refine, and consolidate skills through its built-in Skill Creator. These tips help you get more out of your skills.
Each skill should handle one specific workflow — "post-meeting follow-up" or "weekly pipeline review," not "handle all my sales tasks." If you find yourself writing a skill that covers multiple unrelated workflows, split it into separate skills. You can always consolidate later once you've confirmed each piece works well on its own.
Include the kinds of things you'd say when you need this workflow. The agent uses these to match your requests to the right skill. Narrowly focused skills with clear descriptions produce more accurate matches.
Specify which integrations to use — "check HubSpot for the deal" is better than "check the CRM."
Describe what the result should look like so the agent delivers consistent output every time.
If the skill should respect your preferences (email tone, formatting style), tell it to check your [memory](/docs/get-started/chat/super-gtm/memory).
Define a clear process, but let the agent adapt to the data it finds. Specific steps are good; hard-coded values are not.
Use project skills for workflows the whole team runs the same way — post-meeting follow-ups, pipeline reviews, or weekly reporting. Use user skills for workflows tailored to your personal style or role. Start as a user skill and iterate through a few real scenarios until the results are consistent, then ask an admin to recreate it as a project skill. Each person's agent applies their own [memory](/docs/get-started/chat/super-gtm/memory) when running a shared project skill, so the same skill adapts to individual preferences without needing separate versions.
Fewer well-defined skills outperform a large collection of vague ones. The agent sees all available skills at the start of every conversation, and when too many overlap or have ambiguous descriptions, matching accuracy drops. Periodically review your skills in the **Skills** tab — consolidate overlapping skills (ask the agent: "consolidate my meeting follow-up skills into one") and remove any that haven't been triggered in several weeks. If your team uses project skills, treat the shared catalog as a curated set of your highest-value workflows.
# Subagents
Source: https://relevanceai.com/docs/get-started/chat/super-gtm/subagents
Connect any Agent you've built in Relevance AI as a subagent so Super GTM can call it during a conversation
Subagents let you connect any Agent you've built in the Relevance AI builder to Super GTM. Once connected, Super GTM sees the subagent in every conversation and can invoke it when a user request matches what the Agent does.
This is the bridge between the Agents your team has already built and the Super GTM chat experience — the work of designing, prompting, and configuring an Agent in the builder is reused directly inside Super GTM.
Subagents replace the deprecated agents-as-skills approach. Previously, Super GTM would become a connected Agent by reading its instructions and running its tools inline. Subagents instead run each connected Agent in its own conversation with its own context.
## How it works
Super GTM acts as an orchestrator. Connected subagents appear in its catalog at the start of every conversation, and Super GTM decides when to delegate to one based on the user's request and the subagent's description.
Each subagent runs as a full agent in its own conversation — separate context, its own reasoning, its own tools. The only context shared with Super GTM is the message Super GTM sends in. When the subagent responds, its output is returned to Super GTM, which then continues with the user. If Super GTM needs more from the same subagent later in the session, it sends a follow-up message into that same subagent conversation rather than starting fresh.
For each connected subagent, Super GTM sees:
* The Agent's **name**
* The Agent's **description**
These two fields drive routing — Super GTM matches the user's request against the description to decide whether to invoke the subagent. A clear, specific description that explains what the Agent does and when to use it is the single biggest factor in getting reliable routing.
When Super GTM first invokes a subagent, the subagent receives a single message with the instructions for the task. It does not see the rest of the Super GTM conversation, the user's memory, or any other context Super GTM has loaded.
The subagent runs from there using its own configuration — its system prompt, tools, integrations, and reasoning — exactly as it would when run standalone in the builder. If Super GTM sends a follow-up message later in the same session, it lands in the same subagent conversation and the subagent keeps its prior context.
When the subagent responds, its output is returned to Super GTM. Super GTM treats that output as the result of the delegation and uses it to continue working on the user's original request — summarizing it, combining it with other tool outputs, or passing it into another step.
If a tool inside the subagent requires approval, the approval request is passed up to the Super GTM UI for the user to approve or reject. The subagent pauses until the user responds, then continues.
## Connecting an Agent as a subagent
Go to [app.relevanceai.com](https://app.relevanceai.com) and open the Agent you want to connect.
The Agent must have both before it can be used as a subagent. The description is what Super GTM reads when deciding whether to route to this Agent — explain clearly what the Agent does and when to use it.
In the agent edit view, navigate to the **Advanced** section.
Enable the **Can be used by Super GTM** setting. The Agent is now available as a subagent in every Super GTM conversation in the project.
The Agent's description is the most important field for subagent performance. Super GTM reads it on every conversation to decide when to route a request to this Agent. If the description is vague, missing, or written for end users rather than for the orchestrator, routing will be unreliable.
## Writing a description that routes well
The description should answer two questions clearly:
1. **What does the Agent do?** Be specific about the task — "drafts personalized cold outreach emails based on a prospect's LinkedIn profile" beats "writes emails."
2. **When should Super GTM use it?** Describe the kind of request that should trigger it — "use when the user wants to write a first-touch email to a new prospect."
**Agent name:** Cold Email Writer
**Description:** Drafts personalized cold outreach emails for new prospects. Takes a LinkedIn URL or company name as input, researches the prospect, and produces a short first-touch email matching our team's voice and outreach playbook. Use when the user asks for an outreach email, an intro email, or wants to start a sequence with a new prospect. Do not use for follow-ups on existing conversations — those should go to the Follow-up Email Writer.
This works because it explains exactly what the agent produces, what it needs as input, when to route to it, and when *not* to. Super GTM uses all of that to make a routing decision.
**Agent name:** Email Agent
**Description:** Helps with emails.
This fails because Super GTM has no way to distinguish it from any other email-related capability — the built-in skills, an integration, or another subagent. Most email-related requests will not route here, and the ones that do will be inconsistent.
## Tips for managing subagents
The description is read by Super GTM, not the end user. Write it for an LLM making a routing decision. Include trigger phrases users might say, the kinds of inputs the agent expects, and any cases where this agent should *not* be used.
Subagents work best when each one owns a well-defined task. A "research a prospect" subagent and a "draft a follow-up email" subagent will route more reliably than a single "do anything sales-related" subagent.
Super GTM sees every connected subagent at the start of every conversation. As the catalog grows, the orchestrator has more tools and agents to choose between, and routing accuracy can drop. We recommend keeping the total number of connected subagents under \~20 per project. Super GTM also has 10+ built-in tools and agents already, so the effective catalog is larger than just your subagents.
If Super GTM routes to the wrong agent — or fails to route to your subagent when it should — the fix is almost always in the description. Update it to clarify when the agent should be used, then test the same request again.
A [skill](/docs/get-started/chat/super-gtm/skills) is the right choice when the workflow is a sequence of steps Super GTM itself should run. A subagent is the right choice when the work is best done by a separate agent with its own configuration — its own system prompt, tools, or integrations. If a skill can do the job, prefer the skill.
## Frequently asked questions (FAQs)
Not currently. Each connected agent has a single conversation per Super GTM session, and follow-up messages from Super GTM go to that same conversation rather than spinning up a new instance.
Not currently. When Super GTM invokes a subagent, it waits for that subagent to respond before continuing — invocations happen one at a time, sequentially.
Yes. If Super GTM needs more from a subagent it has already invoked, it sends a follow-up message into the same subagent conversation rather than starting a new one. The subagent keeps its prior context for that session.
Approval requests are passed up from the subagent to the Super GTM UI, where the user approves or rejects them just like they would for any other approval-gated action. Once the user responds, the subagent continues from where it paused.
There is no hard technical limit, but we recommend connecting no more than \~20 subagents per project. Beyond that, Super GTM has more capabilities to choose between and routing accuracy starts to drop. Keep in mind that Super GTM already ships with 10+ built-in tools and agents, so each subagent you connect adds to that baseline.
Yes. The "Can be used by Super GTM" setting is project-wide — once an Agent is enabled, every Super GTM user in the project sees it as a subagent. Use this in combination with the Agent's own permissions in the builder to control who can run it.
Super GTM cannot enable the toggle without a description. If you remove the description after the toggle is on, the Agent will still appear in the catalog but Super GTM will have no information to route on, so requests are unlikely to reach it.
## Skills, subagents, and memory
Subagents sit alongside [skills](/docs/get-started/chat/super-gtm/skills) and [memory](/docs/get-started/chat/super-gtm/memory) as the three ways you tailor Super GTM to your team's work:
* **Skills** define repeatable workflows Super GTM runs itself, step by step.
* **Subagents** delegate work to a separate agent that has its own configuration and runs in its own context.
* **Memory** personalizes how Super GTM and its subagents present output back to each user.
A common pattern is a project skill that tells Super GTM to call a specific subagent at a specific step — for example, a "post-meeting follow-up" skill that delegates email drafting to your Cold Email Writer subagent. Memory then shapes the tone of the final output for each user.
# Using Agents and Workforces in Relevance Chat
Source: https://relevanceai.com/docs/get-started/chat/using-agents
Utilize your Agents and Workforces in Chat conversations
Mention any Agent you have access to in your project using @, and Chat will integrate their capabilities into your conversation. Hover over any Agent in the @ menu to see a pop-up with its name, description, and other details — making it easy to pick the right one without leaving the chat.
Use a single Agent for specific tasks
Combine different Agents in the same conversation for complex workflows
Use teams of Agents working together on complex tasks
Use pre-built Agents cloned from the [Marketplace](/docs/get-started/marketplace/introduction)
Pre-built Agents for websites, research, images, and slides
## Agent visibility
By default, every Agent in your project appears in Chat's @-mention menu and "Browse agents" list. You can hide an Agent from Chat discovery using the **Visible in Chat** toggle.
To change an Agent's visibility:
1. Open the Agent in the builder
2. Go to **Advanced Settings > General**
3. Toggle **Visible in Chat** on or off
Hiding an Agent from Chat does not disable it. Hidden Agents remain fully accessible in the builder's app, via API, and direct links.
## Built-in Agents
Chat includes several pre-built Agents you can use without any setup. Mention them with @ in any conversation.
| Agent | Description | Credit cost |
| ---------------------------------------------------------------- | ------------------------------------------------------------------------ | -------------------- |
| [Slide Builder](/docs/get-started/chat/slide-builder) | Generate branded slide decks from prompts, files, or other agent outputs | Varies by deck size |
| [Website Builder](/docs/get-started/chat/chat-agents/website-builder) | Build websites from a prompt or description | 100+ credits per run |
| [Image Generator](/docs/get-started/chat/chat-agents/image-generator) | Generate images from text prompts | 10+ credits per run |
| [Deep Researcher](/docs/get-started/chat/chat-agents/deep-researcher) | Conduct comprehensive research on a topic | 100+ credits per run |
## Providing feedback on responses
Rate any response using the thumbs up and thumbs down icons that appear alongside the copy button at the bottom of each message. You can optionally add written feedback in the modal dialog that appears after rating.
Use when a response is incorrect, incomplete, or unhelpful. Describe what went wrong to
help improve the agent's performance.
Reinforce good behaviors when a response is particularly helpful, accurate, or
well-formatted.
Add details about what worked or didn't work to make your feedback more actionable.
# Agents
Source: https://relevanceai.com/docs/get-started/core-concepts/agents
Introduction to AI agents and building your AI Workforce!
## What are Agents?
Agents are powered by LLMs that plan and complete tasks on autopilot. They are given tools, and decide how to use tools to achieve goals prompted by you.
Unlike traditional automation that follows rigid, pre-programmed rules, AI agents can:
* **Think and reason** through complex problems
* **Adapt their approach** based on context and feedback
* **Learn from experience** by storing successful patterns
* **Make decisions** about which tools to use and when
* **Communicate naturally** with humans and other agents
## What are the benefits of an AI Agent?
Agents can flex with your needs, handling seasonal or regional spikes in activity—especially useful in industries like education, hospitality, and finance.
Automate repetitive tasks so your team can focus on high-value work. Sales teams, for example, use agents to qualify leads, freeing reps to close deals.
If an agent doesn't know something, it can escalate to a human, store the answer, and use it next time. Ours posts unknowns to Slack for fast input and learning.
Agents can run fully autonomously or in co-pilot mode. One of ours builds Webflow pages daily—no human touch required.
Unlike rule-based tools, agents adapt their responses to each task. A support agent might troubleshoot one day and resolve billing the next.
Agents work around the clock without breaks, ensuring consistent service and response times regardless of time zones or business hours.
## How AI Agents Work
Agents in Relevance AI can operate in different ways:
* **Autopilot** - They complete tasks independently.
* **Human in the loop** - Asking humans for input or approval when needed.
You can trigger agents to start work with:
* **Pre-built integrations** - Seamlessly connect with existing tools.
* **API access** - Use them in your applications.
* **User interface** - Run agents directly from our platform.
## Where are Agents most useful?
AI agents excel in roles requiring consistent execution of complex but well-defined processes, such as:
* **Customer Support**: Handling routine inquiries, troubleshooting common issues, and escalating complex problems to human agents
* **Sales Qualification**: Engaging with prospects, gathering initial information, and identifying promising leads
* **Content Creation**: Generating drafts of routine documents, reports, and communications
* **Data Analysis**: Processing and summarizing large volumes of information to extract actionable insights
* **Scheduling and Coordination**: Managing calendars, setting up meetings, and sending reminders
## Organizing your Agents
As you build and use more Agents, keeping them organized becomes essential for efficient workflows. Relevance AI provides several ways to manage and access your Agents:
### Pinning Agents for quick access
Pin your most frequently used Agents to keep them easily accessible in the Relevance AI platform. Pinned Agents appear:
* **At the top of your agents list** in the main app
* **First in the "Browse agents" section** when creating a new chat
This makes it easy to quickly access the Agents you rely on most, without scrolling through your entire collection.
To pin an Agent, click the pin icon next to the Agent's name in your agents list. You can pin multiple Agents and unpin them at any time by clicking the pin icon again.
### Organizing with folders
You can organize your Agents into folders within your project, making it easier to categorize and find Agents based on their purpose, department, or use case. This is particularly useful for teams managing large numbers of Agents across different functions.
### Organizing with tags
Tags give you a flexible way to categorize agents that cuts across folder boundaries — unlike folders, a single agent can have multiple tags at once, making it easy to group agents by team, status, client, or any other dimension that matters to your workflow. To create a tag, hover over an agent in the agent list and click the **Add Tag** button that appears, then select a color, give the tag a name, and click **Save**. Once a tag exists, you can assign it to other agents the same way. You need Editor role to create or manage tags.
### Filtering your agent list
The agent list includes Filter options to help you narrow down your view:
* **Pinned agents** — shows only agents you've pinned.
* **My agents** — shows only agents where you are the original creator.
* **Edited by me** — shows agents you have contributed any version to, including edits to agents created by others.
* **Cloneable agents** — shows agents that have been made cloneable.
* **Embeddable agents** — shows agents that have been made embeddable.
You can also filter by agent type (**Default**, **Phone**, or **Knowledge**). With no Filter option selected, the list shows every agent you have access to in the project.
If you previously relied on "My agents" to find agents you had edited, those agents now appear under "Edited by me" instead. "My agents" now shows only agents you originally created, so your team can more easily distinguish between creation and contribution.
### Customizing your agent list view
You can resize the **Agent name** and **Description** columns in the agent list table by dragging the divider between column headers. This lets you adjust how much space each column takes up based on your preferences. Other columns remain fixed-width.
## How to get the most from your Agents?
When inventing or creating an agent, you'd want to utilize domain expertise or model an agent after a Domain expert:
1. **Start with clear objectives**: Define specific tasks and goals for your agents
2. **Provide quality knowledge bases**: Equip agents with comprehensive, up-to-date information
3. **Establish escalation protocols**: Create clear paths for agents to involve humans when needed
4. **Monitor and refine**: Regularly review agent performance and make adjustments
5. **Integrate with existing systems**: Connect agents to your current tools and workflows
6. **Organize for efficiency**: Use pinning and folders to keep your most important Agents easily accessible
By thoughtfully implementing AI agents, organizations can enhance productivity, improve customer experiences, and free human employees to focus on work that requires creativity, empathy, and strategic thinking.
## Frequently asked questions (FAQs)
No, Invent is specifically designed to make agent creation accessible to users without technical expertise. You only need to describe what you want your agent to do in plain English.
Tools are capabilities that agents can use to perform specific actions and complete tasks. They extend what an agent can do beyond just conversation. For example, an agent might use tools to:
* Search the internet for information
* Access and update customer records in a CRM
* Send emails or messages
* Schedule appointments
* Generate content or analyze data
Relevance AI provides both pre-built tool templates and the ability to create custom tools for your agents.
Knowledge in Relevance AI refers to the information and context provided to agents to help them perform their tasks effectively. This is often implemented through Retrieval Augmented Generation (RAG), which allows agents to access and use specific information sources when responding to queries or completing tasks.
By giving agents access to knowledge bases, you can ensure they provide accurate, up-to-date information specific to your business, products, or services.
Yes, Relevance AI supports creating multi-agent systems where specialized AI agents work together to accomplish complex tasks. This is part of the AI Workforce feature, which provides a visual canvas where you can design, connect, and monitor teams of specialized agents.
Agents can be configured to escalate issues they can't handle to human team members. For example, if an agent cannot answer a customer's question, it can loop in a sales rep or manager via your preferred communication tool (email, chat, etc.). The human can provide an answer, which the agent can then use to respond to the customer and store for future reference.
Relevance AI offers numerous integrations that allow agents to connect with external tools and services, including:
* Email platforms (Gmail, Outlook)
* CRM systems (Salesforce, HubSpot)
* Messaging platforms (Slack, WhatsApp, Telegram)
* Productivity tools (Google Calendar, Google Sheets)
* Knowledge management systems (Notion, Confluence)
* And many more
These integrations enable agents to access data and perform actions across your entire tech stack.
Yes, agents on the Relevance AI platform can complete work end-to-end without human involvement. For example, you could create an agent that checks for new information daily and produces reports or updates websites automatically.
However, you can also configure agents to work in a co-pilot mode, where they assist humans rather than working completely independently. The best approach depends on your specific use case and comfort level with automation.
Relevance AI has system quotas that define the maximum resource allocations for different aspects of the platform. These may include limits on the number of agents, conversations, knowledge bases, or API calls depending on your plan. Specific details about these quotas can be found in the [system quotas documentation](/docs/admin/system-limits).
Relevance AI provides tools to monitor your agents' performance, including:
1. **Task View**: A centralized interface for monitoring, managing, and interacting with your AI workforce
2. **Conversation History**: Review past interactions to identify areas for improvement
3. **Analytics**: Track metrics related to agent usage and effectiveness
Regular monitoring helps you identify patterns, optimize agent behavior, and ensure they're meeting your business objectives.
Concurrency refers to the number of tasks that can be executed simultaneously by your agents. For more details, visit our [System Quotas page](/docs/admin/system-limits).
You can organize your Agents in several ways:
* **Pin important Agents**: Keep your most frequently used Agents at the top of your agents list in the main app for quick access
* **Use folders**: Organize Agents into folders based on purpose, department, or use case
* **Project organization**: Separate Agents across different projects based on your team structure
These organizational features help you manage large collections of Agents efficiently.
***
## Ready to get started with AI agents?
Build your first agent step by step
Start using agents instantly in Relevance Chat
Clone and customize pre-built agents
# API integration
Source: https://relevanceai.com/docs/get-started/core-concepts/api-integration
Add custom API keys to connect services Relevance doesn't have built-in, or use the Relevance API key to access the platform programmatically.
## What is API integration?
Relevance AI has [built-in integrations](/docs/integrations/introduction) for dozens of popular services — but if you need to call a custom endpoint or connect a service that isn't on the list, you can add your own API keys. And if you want to access Relevance programmatically — via the SDK — you can generate a Relevance API key.
## What are the benefits of API integration?
Add your own API keys to connect any service or endpoint that Relevance doesn't have a built-in integration for.
Use the Relevance API key to interact with the platform through the SDK.
All keys are encrypted and scoped to your project. Access them safely in tools using template variables.
Call any REST endpoint, pass custom headers and parameters, and use the response in your tool steps.
## How to add a custom API key
If the integration you need isn't available as a built-in, you can add a custom API key:
1. Go to the **Integrations & API Keys** page from the left-hand menu
2. Click **Custom API Keys**
3. Give your key a name, paste the value, and save
Once saved, you can access it in any tool step using the template variable:
```
{{secrets.chains_your_api_key}}
```
This lets you call any external endpoint from an API step or code step while keeping your credentials secure.
## Relevance API key
The Relevance API key is different from custom API keys — it authenticates *you* against the Relevance platform itself. Use it when you want to:
* **Use the Python or JavaScript SDK** to trigger agents, run tools, or manage resources programmatically
* **Connect agents to external platforms** by embedding them outside of Relevance
To generate one, go to **Integrations & API Keys** and click **Relevance API Keys**.
Users with the **Editor** role or above can generate Relevance API keys. On enterprise plans, users with the **Member** role can also generate their own API key — useful for connecting MCP clients like Claude Desktop or Cursor. Members can only manage their own keys and cannot manage API keys for other users.
API keys are a form of credential — treat them like passwords. Never share them publicly or commit them to source control.
### Region and URL endpoints
## Frequently asked questions (FAQs)
Custom API keys connect Relevance to an external service you want to call. The Relevance API key connects external code to Relevance itself — it's what you use with the SDK.
Reference it with the template variable `{{secrets.chains_your_key_name}}` in any tool step that supports it, such as an API call or Python code step.
Yes. All keys are encrypted and scoped to your project. They're never exposed in logs or agent responses.
Those are covered on the [Integrations](/docs/integrations/introduction) page. This page is for connecting services that don't have a built-in integration, or for accessing Relevance programmatically.
***
## Next steps
See the full list of built-in integrations and how to use them
Create a tool that uses your API keys to call external services
# Knowledge
Source: https://relevanceai.com/docs/get-started/core-concepts/knowledge
Give your agents the context they need with Relevance AI's RAG-powered knowledge system.
## What is Knowledge?
Knowledge is Relevance AI's retrieval augmented generation (RAG) system. It lets you give your agents and tools access to specific information — your docs, your data, your expertise — so they can respond with accuracy instead of relying only on their training data.
Think of it as your agent's reference library. When an agent needs to answer a question or complete a task, it searches your knowledge bases for the most relevant information and uses it to ground its response.
## What are the benefits of Knowledge?
Agents reference your actual data instead of guessing. Fewer hallucinations, more reliable output.
Turn any agent into a specialist by giving it access to the right knowledge — product docs, playbooks, policies, whatever it needs.
Update your knowledge bases as things change. Your agents automatically use the latest information.
Pull in data from files, websites, Google Drive, SharePoint, Notion, and more.
## How Knowledge Works
Knowledge uses semantic search to find the most relevant information for each query. When an agent receives a task or question:
1. It searches your connected knowledge bases for relevant content
2. The most relevant results are passed to the agent as context
3. The agent uses that context to generate an accurate, grounded response
This is powered by retrieval augmented generation (RAG) — your agents get the right information at the right time without needing it baked into their training data.
### Connecting Knowledge to an agent
When you add a knowledge base to an agent, you choose how the agent uses it:
* **Add all to prompt** — the entire knowledge set is included in the prompt every time the agent runs. Best for small or simple datasets.
* **Allow agent to search** — the agent searches the knowledge base using RAG and pulls only what's relevant. Best for large or complex datasets.
## Where is Knowledge most useful?
Knowledge is most effective when your agents need access to specific, proprietary, or frequently changing information:
* **Customer support**: Product documentation, troubleshooting guides, and FAQs so agents resolve issues accurately
* **Sales enablement**: Battlecards, pricing sheets, and case studies to keep sales agents informed
* **Internal operations**: Company policies, SOPs, and handbooks that employees need on demand
* **Onboarding**: Training materials and process documentation for new team members
* **Research and analysis**: Reports, datasets, and reference materials for agents that synthesize information
## How to get the most from Knowledge?
1. **Keep data clean and structured**: Well-organized content with clear headings and sections improves retrieval accuracy.
2. **Be specific with what you upload**: Give agents only the knowledge they need — too much irrelevant data dilutes search results.
3. **Keep it up to date**: Regularly refresh your knowledge bases so agents always reference current information.
4. **Use enrichment**: Run [tools](/docs/build/knowledge/enrich-with-tool) over your knowledge to add summaries, tags, or derived fields that help agents find the right content faster.
5. **Use snippets for quick access**: Set up [snippets](/docs/build/knowledge/use-snippets-for-quick-access) for frequently referenced information your agents use often.
## Frequently asked questions (FAQs)
You can upload CSV, PDF, Excel, JSON, and audio files. You can also pull content from websites or sync from integrations like Google Drive, SharePoint, and Notion.
Keyword search looks for exact word matches. Semantic search understands meaning — so a search for "pricing information" can find content titled "how much does it cost" even though the words don't match.
Yes. You can connect a single knowledge base to as many agents as you like. This is useful when multiple agents need access to the same reference material.
You can manually update entries, re-upload files, or use integrations like Google Drive and SharePoint that sync automatically when your source documents change.
Enrichment lets you run tools over your knowledge table to add or transform data — for example, generating summaries, extracting key fields, or tagging entries. This makes retrieval more effective and gives agents richer context.
***
## Ready to get started with Knowledge?
Upload your data and build your first knowledge base
Sync from Google Drive, SharePoint, Notion, and more
# MCP & Plugins
Source: https://relevanceai.com/docs/get-started/core-concepts/mcp-plugins
Build and manage your Relevance AI agents programmatically using Claude Code or any MCP-compatible AI client.
Connect your AI coding environment to Relevance AI to build agents, tools, and workforces directly from your terminal — using natural language. Instead of clicking through a UI, you build, test, and iterate through clients like Claude Code, Cursor, or any MCP-compatible AI client.
## Getting started
Pick the setup that matches your AI client.
Connect Codex to Relevance AI with the MCP server and agent skills.
The fastest way to get started. Install the Relevance AI plugin for Claude Code and build agents from your terminal.
Connect from any MCP-compatible client — Claude Desktop, Cursor, VS Code, ChatGPT, and more.
Clone the agent skills repository to give your AI coding assistant built-in knowledge of Relevance AI.
***
This page focuses on what builders can create and manage via MCP. MCP connections also work for team members who only need to run existing agents — not build or edit them. Users with Viewer or Chat project roles are automatically placed into a restricted access mode when they authenticate, so they can view and run agents without any write access. See [Access control](/docs/integrations/mcp/mcp-server#access-control) for details.
## What you can do
Once connected, your AI client gets full access to your Relevance AI project. This goes far beyond running existing tools — you can build and manage everything in your project from clients like Claude Code.
Design and configure new Agents, set their instructions, assign Tools, and configure Triggers.
Create new Tools with custom steps, inputs, and outputs.
Build multi-agent workflows with Triggers, conditions, and agent-to-agent handoffs.
Start conversations with your Agents and get responses.
Run any of your Relevance AI Tools directly from your AI client.
Diagnose issues with your Agents by reviewing conversation logs and tool outputs.
Iterate on Agent instructions, Tool configurations, and behavior based on real results.
Review previous agent runs, identify failures, and improve performance over time.
Modify agent instructions, tool settings, and workflow logic.
***
## Use cases
Create and configure agents end-to-end from your AI client. Describe what you want in natural language and let your AI client handle the setup.
**Example prompts:**
*"Create a new agent called 'Customer Support Bot' that answers questions using our FAQ knowledge base. Give it a friendly tone and make sure it escalates to a human when it can't answer."*
*"Build me an agent that qualifies inbound leads from HubSpot. It should check the company size and industry, then send a personalized follow-up email via Gmail."*
*"Set up an agent that monitors our Slack support channel, categorizes messages by urgency, and assigns them to the right team member."*
*"Create an agent with a scheduled trigger that runs every morning, pulls yesterday's data from Google Sheets, and posts a summary to Slack."*
Review how your agents have been performing by looking at previous conversation runs, identifying where they succeeded or failed, and making targeted improvements.
**Example prompts:**
*"Pull the last 20 conversations for my Support Agent. Identify any where the agent gave an incorrect answer or failed to resolve the issue."*
*"Look at my Sales Agent's recent runs. How often is it successfully qualifying leads vs. letting unqualified ones through?"*
*"Review the last week of conversations for my Onboarding Agent. Are there any common questions it struggles with? Suggest improvements to its instructions."*
*"Compare the performance of my Sales Agent before and after I updated its prompt last Tuesday. Is it doing better at objection handling?"*
Create custom tools that your agents can use, combining API calls, code steps, LLM processing, and integrations — all from your AI client.
**Example prompts:**
*"Create a tool that takes a company URL, scrapes the homepage, and returns a one-paragraph summary of what the company does."*
*"Build a tool that searches our knowledge base for the top 3 most relevant articles given a customer question, and formats them as a numbered list with links."*
*"Make a tool that takes a CSV of records, enriches each one with LinkedIn data, and outputs a Google Sheet with the results."*
*"Create a tool that generates a personalized email based on a contact's LinkedIn profile and our product's value props."*
When something isn't working right, dig into agent behavior, tool failures, and configuration problems.
**Example prompts:**
*"My Support Agent stopped responding to Slack messages yesterday. Check its trigger configuration and recent conversation logs to figure out what happened."*
*"The data enrichment tool is returning empty results. Look at the tool steps and check if the API call is configured correctly."*
*"My agent keeps hallucinating answers instead of using the knowledge base. Review its instructions and knowledge configuration and suggest fixes."*
*"List all my agents and their triggers. I think one of them has a broken webhook — find it and show me the configuration."*
***
## Best practices
Before asking your AI client to create or modify anything, start by having it plan the work first. In Claude Code, you can type `/plan` to enter plan mode — this lets you and Claude align on the approach before any changes are made.
Instead of jumping straight to *"Build me a support agent"*, start with *"Let's plan a support agent that handles inbound Slack messages. What tools will it need? What should the escalation flow look like?"* — then review the plan and tell Claude to execute it.
When your AI client proposes changes — like updating an agent's instructions or modifying a tool — read through what it's about to do before confirming. This is especially important for agents that are already live and handling real conversations.
When troubleshooting or refining an agent, ask your AI client to pull recent conversation logs first. This gives it real context to work with rather than guessing.
Prompts like *"Look at the last 10 conversations and tell me what's going wrong"* are far more effective than *"My agent isn't working well, fix it"*.
After building or updating an agent, trigger a test conversation to see how it actually behaves. Don't just review the configuration — run it. Ask your AI client to *"Send a test message to my Support Agent asking about refund policies"* and review the response.
If you have separate projects for development and production, connect to both via separate MCP entries. Build and test in your dev project, then once you're happy, recreate or promote the agent in production. This keeps your live agents safe while you experiment.
***
## Frequently asked questions (FAQs)
The Model Context Protocol (MCP) is an open standard that allows AI clients to connect to external tools and data sources. It provides a standardized way for AI assistants to access your Relevance AI workspace, so you can build and manage agents from clients like Claude Code, Cursor, or VS Code instead of the Relevance AI web interface.
No. Claude Code with the Relevance AI plugin provides the richest experience, but you can use any MCP-compatible client — Claude Desktop, ChatGPT, Cursor, VS Code, Windsurf, and more. See the [MCP server](/docs/integrations/mcp/mcp-server) page for all supported clients.
The MCP server and Claude Code plugin are free. You will be billed for any Relevance AI usage (agent runs, tool executions, etc.) according to your plan.
Yes. You can connect to the Relevance AI MCP server from as many clients as you like simultaneously. Each client authenticates independently.
Authentication tokens may expire after a period of inactivity. If you are prompted to re-authenticate, simply follow the login flow again.
Run-Only mode is the primary way to restrict MCP access. Assign a user the Viewer or Chat project role to force them into a restricted mode automatically — Viewers get run-only access (no write or destructive operations), and Chat users are limited to an even narrower set of tools. Member, Editor, and Admin users can opt into run-only mode from the toggle on the OAuth consent screen. For finer-grained control — such as exposing only a specific subset of agents — organize your tools across separate projects and authenticate each connection to the appropriate project. See [Access control on the MCP server page](/docs/integrations/mcp/mcp-server#access-control) for the full role matrix.
# Tools
Source: https://relevanceai.com/docs/get-started/core-concepts/tools
The actions your agents use to get things done — from API calls to LLM prompts to custom code.
## What are Tools?
Tools are the actions your agents can take. They're step-by-step automations you build in a no-code builder — things like calling an API, running an LLM prompt, sending an email, searching a database, or executing custom code.
You can give tools to your agents so they know how to complete tasks, share them as standalone forms, or run them in bulk across a knowledge table.
## What are the benefits of Tools?
Without tools, agents can only talk. With tools, they can take real actions — update your CRM, send emails, search the web, and more.
Build tools visually by chaining steps together. No engineering required.
Build a tool once and give it to any agent. Share it with your team or publish it to the Marketplace.
Use pre-built integrations, call any API, or write custom Python. Whatever your workflow needs.
## How Tools Work
Every tool follows the same pattern: **inputs → steps → outputs**.
* **Inputs** — the data the tool receives. Text, numbers, files, or data passed from an agent or another tool.
* **Steps** — the actions the tool performs in sequence. Each step can use the output of previous steps. Steps include LLM prompts, API calls, integrations, code execution, and more.
* **Outputs** — what the tool returns when it's done. Text, links, structured data, or files that get passed back to the agent or displayed to the user.
## Where are Tools most useful?
Tools shine anywhere your agents need to take action beyond conversation:
* **CRM updates**: Automatically create, update, or enrich records in HubSpot, Salesforce, and other systems
* **Email and messaging**: Send emails, Slack messages, or notifications as part of a workflow
* **Web search and scraping**: Pull live information from the web to inform agent decisions
* **Data processing**: Transform, filter, or analyze data with code steps or LLM prompts
* **Third-party APIs**: Connect to any external service — payment processors, marketing platforms, internal systems, and more
## How to get the most from your Tools?
1. **Keep tools focused**: Each tool should do one thing well. Break complex workflows into smaller, composable tools.
2. **Write clear descriptions**: Your agent uses the tool's name and description to decide when to use it — make them specific.
3. **Define inputs carefully**: Use descriptive input names and set sensible defaults so agents pass the right data.
4. **Test step by step**: Run individual steps as you build to catch issues early instead of debugging the whole chain.
5. **Reuse and share**: Build tools once, then give them to multiple agents or share with your team via the Marketplace.
## Frequently asked questions (FAQs)
No. The Tool Builder is a no-code interface where you chain steps together visually. If you need custom logic, you can add a code step with Python, but it's entirely optional.
An agent thinks, plans, and decides what to do. A tool is a specific action the agent can take — like calling an API or sending an email. Agents use tools to get work done.
Yes. Tools are reusable. Build a tool once and assign it to as many agents as you like.
Use the **Logs** tab in the Tool Builder to review past executions. You can see exactly what each step received and returned, making it easy to pinpoint where things went wrong.
Yes. You can add an API step to call any REST endpoint, pass headers and parameters, and use the response in subsequent steps.
***
## Ready to get started with Tools?
Follow our guide to create your first tool step by step
Learn best practices for building effective tools
# Workforces
Source: https://relevanceai.com/docs/get-started/core-concepts/workforces
Workforce transforms how your agents collaborate by providing a visual canvas where you can design, connect, and monitor teams of specialised agents.
## What is a Workforce?
A Workforce is a team of AI agents that work together to complete multi-step tasks. Instead of building one agent that tries to do everything, you connect specialists — each handling a different part of the process — on a visual canvas.
Think of it like a team of employees: a researcher gathers information, a writer drafts the output, and a reviewer checks the quality. Each agent focuses on what it's best at, and the Workforce handles the handoffs between them.
## What are the benefits of a Workforce?
Split multi-step processes across specialized agents instead of overloading a single one.
Design agent teams with drag-and-drop — no code, easy to understand and modify.
Use AI-driven handoffs, fixed sequences, or conditional logic to control how work flows between agents.
Track every step of a workflow to see what's working and where things get stuck.
## How Workforces Work
### Connection types
When building your agent workflows, you choose how agents hand off to each other:
* **AI connection** — the agent decides when to pass control to another agent based on context. Great when you want the agent to use judgement about whether another specialist is needed.
* **Next step** — a mandatory transition. When one agent finishes, the next one starts automatically. Use this for predictable, sequential processes.
### Tool integration
You can connect tools directly within your workflow:
* Connect tools to agents to extend what they can do
* Link tools to other tools to create processing chains
* Combine agent intelligence with specialized tool functionality
### Conditional logic
Make your workflows smarter with routing rules:
* Create "if this, then that" rules to determine workflow paths
* Set up decision points that route tasks based on specific criteria
* Build adaptive workflows that respond differently depending on inputs or outcomes
## Where are Workforces most useful?
Workforces are ideal when a task requires multiple steps, skills, or handoffs that a single agent can't handle well on its own:
* **Content pipelines**: A researcher gathers information, a writer drafts the content, and a reviewer checks quality before publishing
* **Lead processing**: One agent qualifies inbound leads, another enriches the data, and a third routes them to the right sales rep
* **Customer support escalation**: A frontline agent handles common questions and hands off complex issues to a specialist agent
* **Report generation**: Agents collect data from multiple sources, analyze it, and compile a final report
* **Onboarding workflows**: Coordinate welcome emails, account setup, training material delivery, and check-ins across multiple agents
## How to get the most from your Workforce?
1. **Start with a clear workflow**: Map out your process before building — know which agents handle which steps and how they hand off.
2. **Keep agents focused**: Each agent should have a single responsibility. A researcher shouldn't also be writing and reviewing.
3. **Choose the right connection type**: Use AI connections when the agent needs judgement about handoffs. Use next step for predictable, sequential flows.
4. **Name connections clearly**: Descriptive names document the purpose of each handoff and make your workflow easier to understand.
5. **Test with varied inputs**: Run different scenarios to make sure routing works as expected and edge cases are handled.
6. **Monitor and optimize**: Review workflow performance regularly to identify bottlenecks or communication gaps between agents.
## Frequently asked questions (FAQs)
There's no hard limit on the number of agents in a Workforce. However, simpler workflows with clearly defined roles tend to perform better than overly complex ones.
An AI connection lets the agent decide when to hand off based on context — it uses judgement. A next step is a mandatory transition that always fires when the previous agent finishes. Use AI connections for flexible routing and next steps for predictable sequences.
Yes. You can connect tools directly to agents within your Workforce, or link tools to other tools to create processing chains.
Yes. The same agent can participate in multiple Workforces. This is useful when a specialist agent — like a data enrichment agent — is needed in several different workflows.
Review the workflow execution to see which agent handled each step, what it received, and what it passed on. This helps you identify where the process broke down — whether it's a routing issue, a tool failure, or a prompt that needs refining.
***
## Ready to get started with Workforces?
Create a multi-agent workflow on the visual canvas
See how to build an AI content creation team in Workforce
Run your workforce from Relevance Chat
# Introduction
Source: https://relevanceai.com/docs/get-started/introduction
Relevance AI is the home of your AI Workforce.
Relevance AI is a low/no-code platform where you can build AI agents and multi-agent teams that autonomously complete tasks, much like human employees.
Whether you're looking to automate customer support, scale your sales operations, or streamline internal workflows, Relevance AI provides the tools and infrastructure to build, deploy, and manage your AI workforce.
## Why Relevance AI?
Traditional automation tools require rigid workflows and constant maintenance. AI agents are different—they think, adapt, and learn from experience. With Relevance AI, you can:
* **Deploy agents in minutes** using our no-code builder or pre-built templates
* **Scale on demand** without hiring or training new team members
* **Integrate seamlessly** with your existing tools and workflows
* **Maintain control** with human oversight and approval workflows
* **Customize everything** from agent behavior to escalation protocols
## Quick Links
Follow our step-by-step guide to build and deploy your first AI agent
Start using AI agents instantly — no setup required
Learn from our video library covering agents, tools, and best practices
Access our support team, community, and troubleshooting guides
## Core Features
AI entities that autonomously complete tasks like human employees
Built-in chat interface for human-like conversations with your agents
Multi-agent teams where specialized AI agents collaborate on complex tasks
RAG solution giving agents access to specific information beyond pre-trained knowledge
No-code workflow builder for integrations and automations
Pre-built agents, tools, and workforces you can clone and customize
## Build your first agent
Follow along to see how to create an agent from scratch:
## How It Works
Relevance AI gives you everything you need to build, connect, and scale an AI workforce:
1. **Build agents** — create AI agents that autonomously complete tasks. Use Invent to generate one from a description, clone a pre-built agent from the Marketplace, or build from scratch.
2. **Give them tools** — equip agents with actions like sending emails, updating your CRM, searching the web, or calling any API — all built in a no-code tool builder.
3. **Add knowledge** — connect your data so agents respond with accuracy. Upload files, sync from Google Drive, SharePoint, Notion, or pull from websites.
4. **Connect them into workforces** — link multiple agents together on a visual canvas to handle complex, multi-step workflows. Each agent focuses on what it's best at, and the workforce handles the handoffs.
5. **Set guardrails and deploy** — configure escalations, approval workflows, and triggers, then put your workforce to work.
## Popular Use Cases
Deploy AI agents that handle routine inquiries, troubleshoot common issues, and escalate complex problems to human agents. Reduce response times and free your support team to focus on high-value interactions.
Automate prospect research, lead qualification, and initial outreach. AI agents can engage with prospects, gather information, and identify promising leads for your sales team to close.
Generate drafts of routine documents, reports, social media posts, and communications. Maintain your brand voice while scaling content production.
Process and summarize large volumes of information to extract actionable insights. Automate report generation and data visualization.
Manage calendars, set up meetings, send reminders, and coordinate across teams. Eliminate scheduling conflicts and reduce administrative overhead.
## Learning Resources
Join our Community to connect with other users and get help from the Relevance AI team
Stay updated with the latest features, best practices, and customer stories
***
Ready to build your AI Workforce? [Start building now!](https://app.relevanceai.com/auth)
# Marketplace
Source: https://relevanceai.com/docs/get-started/marketplace/introduction
Discover the world's top AI Agents
The Relevance AI Marketplace is a one-stop shop for finding Agents and Tools that match your needs. It offers a curated selection of ready-to-use AI agents designed to automate tasks, streamline workflows, and enhance productivity across a wide range of use cases. Whether you're looking to solve a specific problem or explore what's possible with AI, the Marketplace makes it easy to get started.
## Who can add Agents / Tools to the Marketplace?
Agents and Tools in the Marketplace have been created by Relevance AI employees (Rellies) and Relevance Builders from our community.
Agents and Tools can be submitted by verified Relevance Builders from our community. The Relevance Builder program is currently exclusive to ensure high-quality Marketplace listings. Learn more in our [Relevance Builders guide](/docs/get-started/marketplace/relevance-builders/become-a-relevance-builder).
**Note for Enterprise users:** If you're part of an Enterprise organization with Role-Based Access Controls (RBAC), your ability to become a Relevance Builder and submit to the Marketplace depends on your assigned permissions. Users with Viewer or Chat-only roles at the project level, or those with limited asset-level permissions, may not be able to create or submit Marketplace listings. Contact your organization administrator if you need elevated permissions.
## Do I have to pay for Agents / Tools?
Some Agents and Tools in the Marketplace require payment. Pricing is determined by the creator of each listing. If you purchase a paid Agent or Tool and it doesn't perform as expected, you can request a refund within seven days of your purchase. Refunds are not available after this seven-day window.
We recommend first reaching out to our support team to get help before pursuing a refund, to make sure we can help you use your purchased listing first.
## I need help using an Agent / Tool I've cloned from the Marketplace
Please [reach out to our support team](/docs/get-started/support) for assistance. If you purchased an Agent / Tool, we can help contact them on your behalf if you need their help.
## How to access your purchases on the Marketplace
To view and re-clone listings you've already purchased:
1. Click 'Marketplace' in the sidebar
2. Click 'My Purchases' in the top right
3. You can then view your purchases on this page and select listings you've already purchased if you need to clone them into your project again
## Frequently asked questions (FAQs)
Yes. When you purchase a listing, it's tied to the specific project where you made the purchase. If you purchase a listing on one project, you won't see it in My Purchases on another project.
Not always. Relevance Builders can choose to make their listings clonable or not. If they have made their listing clonable, you can clone it to any of your projects. If they have not made their listing clonable, you can only use it in the project you purchased it in. Most Builders restrict cross-project cloning for paid listings to ensure proper licensing per project.
Yes, you have full access to modify any Agent or Tool you've purchased. You can customize prompts, add or remove tools, adjust settings, and make any other changes to fit your specific needs.
All pricing information is clearly displayed on each Marketplace listing. Free listings are marked as "Free" while paid listings show the price. You'll see the cost before confirming your purchase.
The My Purchases page only displays paid listings you've purchased. Free listings can be cloned again at any time directly from the Marketplace without needing to track them in your purchase history.
***
## What's next?
Once you've cloned an agent, use it instantly in Relevance Chat
Submit your own agents and tools to the Marketplace
# Become a Relevance Builder
Source: https://relevanceai.com/docs/get-started/marketplace/relevance-builders/become-a-relevance-builder
Learn how to become a Relevance Builder and start sharing your Agents and Tools in the Marketplace
The Relevance Builder program is now exclusive to verified builders to maintain high-quality Marketplace listings. New builder applications are not currently being accepted.
## What is a Relevance Builder?
Relevance Builders are approved builders who are able to submit listings to the Relevance Marketplace. Once you set up your Relevance Builder profile, you will also be given access to our Community discussion space for Relevance Builders, and be tagged as a Relevance Builder in the Community when posting Agents, answering questions, etc.
You can start submitting Agents and Tools to the Marketplace right away. Simply navigate to the Relevance Builders section in your project to set up your profile and begin submitting listings.
Want to learn more about the Marketplace? Check out our [Marketplace overview](/docs/get-started/marketplace/introduction) to discover how it works and what's available.
## What's in this guide?
In this guide, you'll:
Learn how to create your Relevance Builder profile and connect your Stripe account for payments
Understand our approval process and requirements for submitting Agents and Tools
Learn about pricing, payments, and how to maximize your earnings
Find out about support expectations and engaging with the Relevance AI Community
## Benefits of becoming a Relevance Builder
Create and sell Agents and Tools to the Relevance AI community. Set your own prices and earn revenue from your creations.
Showcase your skills and build credibility within the Relevance AI ecosystem. Get recognized as a Relevance Builder in the Community.
Share your solutions with others facing similar challenges. Your Agents can help businesses automate workflows and increase productivity.
Connect with other Relevance Builders, share knowledge, and collaborate on innovative solutions.
## Ready to get started?
Head to the next page to learn how to [set up your Relevance Builder profile](/docs/get-started/marketplace/relevance-builders/setup-builder-profile) and start submitting to the Marketplace!
# Getting paid for your Agents
Source: https://relevanceai.com/docs/get-started/marketplace/relevance-builders/getting-paid
Learn about pricing, payments, and maximizing your earnings from Marketplace listings
If you have set up your Stripe account, you will be able to list Agents for a price of your choosing.
## How big a cut does Relevance AI take?
Relevance currently does not take any cut from the payments you receive for Marketplace listings. The small Stripe transaction fee will however come out of your fee.
This means you keep 100% of your listing price (minus Stripe's standard processing fees, which are typically around 2.9% + \$0.30 per transaction).
## How much should I charge?
The price you set for an agent is up to you, though we have an absolute limit of no more than \$1000 USD. We recommend setting a lower price to ensure uptake and demand, to grow your clone count and build trust before increasing prices.
### Pricing strategies
When you first get started, consider listing your Agents for free or at a lower price to increase your clone count. After a while, you can then start to increase your prices as you build trust within the Relevance AI community.
Price your Agent based on the value it provides:
* **Simple automation** (\$5 - \$25): Basic task automation or simple workflows
* **Moderate complexity** (\$25 - \$100): Multi-step processes with integrations
* **Advanced solutions** (\$100 - \$500): Complex workflows with multiple tools and sophisticated logic
* **Enterprise-grade** (\$500 - \$1000): Highly specialized, industry-specific solutions
Browse the Marketplace to see how similar Agents are priced. This will help you position your listing competitively.
Consider creating multiple versions of your Agent at different price points:
* Basic version (free or low-cost)
* Pro version with additional features
* Enterprise version with premium capabilities
## If someone buys my Agent, do they still have to pay for a Relevance AI subscription?
In most cases — yes. While our free tier gives customers access to 100 credits per day, if they need more than this to run your Agent and any others they have, they'll need to upgrade.
Purchasing listings from the Marketplace would then be an additional cost.
## Can I earn money from referring customers to the platform?
Sure! You can join our affiliate program at [https://relevance-ai.getrewardful.com/signup](https://relevance-ai.getrewardful.com/signup)
You can use this link to refer customers to Relevance AI, who can then purchase your Agents from the Marketplace.
## How can I get more people to buy my Agents and Tools?
### Set your Agents to a lower price / free to start
When you first get started, it's a good idea to list your Agents for a lower price to increase your clone count. After a while, you can then start to increase your prices as you build trust within the Relevance AI community.
### Promote your listings!
The best way to drive more customers to your listings is to promote them yourself. Here are some ideas on how to promote your listings:
Post them to our Community in the Agent Templates section, showing a demo of the Agent, and any help documentation you've created
Share them on your own social media platforms like YouTube, LinkedIn, TikTok, X (Twitter), etc.
Help people out in the Community Questions section. If you see someone who would benefit from one of your listings, share it with them!
Create video tutorials or written guides showing how to use your Agent. This builds trust and demonstrates value.
### Additional promotion strategies
Create a collection of related Agents that work together. Customers who buy one may be interested in others.
Ask satisfied users for feedback and testimonials. Display these in your listing descriptions or promotional materials.
Provide quick, helpful responses to questions about your Agents. Good support leads to positive reviews and word-of-mouth referrals.
Regularly update your Agents with improvements and new features. This shows you're actively maintaining your listings.
Provide comprehensive documentation for your Agents. This can be in the form of:
* Public Notion pages
* Video walkthroughs
* Step-by-step guides
* FAQ sections
## Payment and refund policies
### When do I receive payments?
Payments are processed through Stripe according to their standard payout schedule. Typically, funds are transferred to your bank account within 2-7 business days after a purchase, depending on your country and bank.
### How do refunds work?
Relevance has a 1 week, no questions asked, refund policy for purchased Marketplace listings. When a user refunds a listing, they will lose access to that listing and will not be able to use it. This money will be taken out of your Stripe account.
After 1 week, our policy is not to offer refunds. This means customers will need to assess within a week whether or not they wish to continue using your listing.
To minimize refunds, make sure your Agent descriptions are accurate and comprehensive, and provide clear usage instructions. The better customers understand what they're getting, the less likely they are to request refunds.
## Tracking your earnings
You can track your earnings and sales through:
1. **Stripe Dashboard**: View detailed transaction history, payouts, and analytics
2. **Relevance Builders section**: See how many times your Agents have been cloned
3. **Community engagement**: Monitor discussions about your Agents to gauge interest and satisfaction
## Next steps
Learn about [supporting your Agents](/docs/get-started/marketplace/relevance-builders/supporting-agents) and engaging with the Relevance AI Community to build trust and increase sales.
# Set up your Relevance Builder profile
Source: https://relevanceai.com/docs/get-started/marketplace/relevance-builders/setup-builder-profile
Learn how to create your Relevance Builder profile and connect your Stripe account
This guide is for approved Relevance Builders. If you don't see the Relevance Builders section in your sidebar, you don't currently have builder access.
Your Relevance Builders profile is where you'll manage your Marketplace listings and receive payments. This guide will walk you through setting up your profile and connecting your Stripe account.
## Setting up your profile
Your Relevance Builders profile will be connected to one of your projects — we recommend creating a new project, adding all of your Agents that you want to list to this project, and creating your profile from here.
Select the project you want to create the Agents you'll list on. We recommend creating a dedicated project for your Marketplace listings.
Click on 'Relevance Builders' in the sidebar menu.
Head to the 'My Profile' tab.
Enter your **profile name** — this will show up on anything you publish. Choose a name that represents you or your brand.
Click 'Create profile' to finish!
**Support for profile pictures and cover images is coming soon!**
***
## Connecting to a Stripe account
If you wish to receive payments for paid listings, you'll need to connect to a Stripe account. If you only wish to add free Agents and Tools to the Marketplace, you do not need to follow this step.
Head to the 'My Profile' section of the 'Relevance Builders' section of Relevance AI, and click 'Get started' next to 'Link Stripe account'.
Select your country and business type on the pop-up screen.
Click 'Generate Stripe link' to proceed.
This will take you to Stripe to set up your Stripe account. You will need to fill in any required information for the country and business type you've selected.
Make sure to complete all required fields in Stripe to ensure you can receive payments. Stripe may require additional verification depending on your country and business type.
## What information does Stripe require?
The information required by Stripe varies depending on your country and business type. Common requirements include:
* Full legal name
* Date of birth
* Address
* Phone number
* Email address
* Business name
* Business type (sole proprietorship, LLC, corporation, etc.)
* Business address
* Tax ID or EIN
* Bank account number
* Routing number (US) or equivalent
* Bank account holder name
Stripe may require you to upload identification documents such as:
* Government-issued ID (passport, driver's license)
* Proof of address (utility bill, bank statement)
## Troubleshooting
Make sure you have the appropriate permissions in your project. If you're part of an Enterprise organization with RBAC enabled, you may need elevated permissions. Contact your organization administrator for assistance.
Try the following:
* Ensure you've completed all required fields in Stripe
* Check that your browser isn't blocking pop-ups
* Try using a different browser
* Contact our support team if the issue persists
Yes, you can update your profile name at any time from the 'My Profile' section. Note that this will update the name displayed on all your existing listings.
Yes, you can connect the same Stripe account to multiple Relevance Builder profiles across different projects.
## Next steps
Now that your profile is set up, you're ready to start submitting Agents to the Marketplace! Head to the next page to learn about [how to submit Agents](/docs/get-started/marketplace/relevance-builders/submit-agents).
# Submit Agents to the Marketplace
Source: https://relevanceai.com/docs/get-started/marketplace/relevance-builders/submit-agents
Learn how to submit Agents and Tools to the Marketplace and meet approval requirements
Once your Relevance Builders profile is set up and ready to go, you can start submitting Agents!
## How to submit your Agent
To submit an Agent to the Marketplace:
Go to the Agent you want to submit in your project.
Click the "Submit to Marketplace" button or navigate to the Relevance Builders section and select "Submit new listing".
Enter a title and description for your listing. Make sure these meet the requirements outlined below.
Choose whether your listing will be free or paid. If paid, set your price (up to \$1000 USD).
Click "Submit" to send your Agent for review by the Relevance team.
## Is there an approval process for submitted agents?
All agents submitted to the marketplace will be reviewed by the internal Relevance team. Agents must follow our agent building best practices to ensure all listed agents are usable, reliable, and valuable to the community. If your agent requires updating, the Relevance team will reach out with specific and actionable feedback to update your submission so that your agent can be approved the next time you submit it.
### Can I push changes and updates to your Agents and Tools once they are approved?
Yes you can!
To do this, head to the Agent / Workforce / Tool that has been submitted to Marketplace, make changes and then click 'Update Marketplace listing'.
The new changes will be sent for approval, and once approved, your Marketplace listing will point to the new version of your Agent / Workforce / Tool.
***
## Approval requirements for submitting marketplace Agents
You can use the below list as a checklist to tick off before submitting your agent, to make sure it meets the approval criteria.
### Do not include Sub-Agents
Agents that use Sub-Agents will not be approved, as Sub-Agents is now a legacy feature. Instead, we suggest that you wait until Workforces can be submitted (coming soon).
### Listing title and description
When you submit an Agent, you will enter a custom title and description.
The title of your Agent must clearly describe what the focus of the Agent is. This should not be longer than 50 characters. You can give the Agent a name if you like, but this is not required.
**Examples**: "Atlas, the Account Analyst", "Google Calendar Meeting Notetaker"
Your description should start with a short paragraph outlining exactly what your agent does and how it works. After the initial paragraph, you can add some more detail on how the agent works if you would like. You can also link to publicly accessible help docs (e.g. public Notion pages) if you would like - this will help with your agent's supportability and help get it approved.
### Agent core prompt
In order to help the user understand what the agent is doing, we recommend you leave comments throughout your core prompt to explain what the agent is doing. You can also leave comments detailing how the user can edit, change, or extend their agent, such as by adding knowledge or suggested triggers.
The agent core prompt should be optimised to ensure reliable accuracy and performance. This responsibility is up to you to ensure the agent is performing well and the core prompt following prompt engineering best practices.
You can also use comments to link to publicly accessible help docs, or video demos, about how to use the Agent.
### Tools that require OAuth
If your agent has tools that require OAuth to run, you *must* make sure these settings are surfaced as **required tool inputs**. This will allow the user to fill these out when the 'missing tool inputs' modal is shown while setting up the agent.
Agents that use tools that require OAuth within tool steps that are not surfaced as inputs will not be approved.
### Using API keys
If you have a tool that requires an API key to work, and we do not have a native OAuth solution for that API key, you will need to create a tool input of type 'Text', leave it empty, and provide instructions in the input description on where and how the user can create the API key. For example, you can include a link to relevant docs from the 3rd party tool explaining how to create an API key.
### Tool inputs
At this stage we do not accept tools which use:
* The Knowledge feature (in the left side menu in tool builder)
* Have knowledge table type input fields
Please make sure that the description fields for all tool inputs clearly describe exactly how a user or agent should fill in this input. These descriptions are used by the agent to know how to fill a field reliably, so make sure any critical requirements or guidelines are included in the input description.
### Agent variables
Agent variables will be copied over when a marketplace listing is cloned, as long as they are not knowledge tables, API keys or OAuth accounts.
It is best practice to save any information in the agent core prompt that can be customised for each user as a variable. Good examples include company name, company descriptions, output formatting guidelines, etc.
***
## What do I do if my agent is not approved?
If your agent is not approved, the Relevance team will reach out with specific and actionable feedback. You'll need to make the requested changes to your Agent and then resubmit it to the Marketplace for review.
***
## What doesn't get copied over when users clone your listing?
We currently do not copy over any knowledge tables along with your listing. We plan to add this soon, but in the meantime, we suggest creating a variable and add the knowledge content to that variable. You can then add that variable to the agent's core instructions.
Triggers will not get carried over, but we will suggest triggers for the user to set up based on the triggers attached to the agent when you submit it - so make sure you have triggers set up when you submit if you think the agent needs them.
Please use agent variables rather than global snippets, as global snippets don't copy over.
If you have an agent that uses secrets, these should be surfaced as tool inputs of type API key or OAuth so the user can fill them out when setting up the agent. Do not use secrets.
The following tool input or variable types will not have their default values carried over:
* Knowledge table (avoid using this input type)
* API key (the user will have to fill this in)
* OAuth account (the user will have to fill this in)
***
## Submission checklist
Before submitting your Agent, make sure you've completed the following:
* **Guide for using Agent**: Added a 'Guide for using agent' in Advanced Settings that tells users how to use the agent or provides examples to test with
* **No Sub-Agents**: Confirmed your Agent doesn't use Sub-Agents
* **Clear title and description**: Written a clear, descriptive title (under 50 characters) and created a comprehensive description with usage instructions
* **Optimized core prompt**: Added comments explaining what the Agent does, included instructions for customization, and followed prompt engineering best practices
* **OAuth and API keys**: Surfaced all OAuth requirements as required tool inputs and provided clear instructions for any API keys needed
* **Tool inputs**: Avoided using Knowledge or knowledge table inputs and written clear descriptions for all tool inputs
* **Variables**: Used agent variables for customizable information and avoided using global snippets or secrets
## Next steps
Once your Agent is approved, you can start earning from your listings! Learn more about [getting paid for your Agents](/docs/get-started/marketplace/relevance-builders/getting-paid).
# Supporting your Agents
Source: https://relevanceai.com/docs/get-started/marketplace/relevance-builders/supporting-agents
Learn about support expectations and engaging with the Relevance AI Community
As a Relevance Builder, understanding your support responsibilities and engaging with the community will help you build trust and increase the success of your Marketplace listings.
## Do I need to support my Agents / Tools?
You will not need to support your *free* Agents / Tools. Any free Agents / Tools that you add to the Marketplace will be supported by our Relevance AI support team, but if someone asks about them in the Community, we'd appreciate if you could help out and answer questions.
For paid Agents / Tools, our support team will attempt to troubleshoot with your customers first. However, our support team may reach out to you, or direct your customers to you, if they're unable to help your customers with your Agents.
**Best practice**: Even for free listings, being responsive to questions in the Community helps build your reputation and can lead to more downloads and purchases of your other listings.
## How do refunds work?
Relevance has a 1 week, no questions asked, refund policy for purchased Marketplace listings. When a user refunds a listing, they will lose access to that listing and will not be able to use it. This money will be taken out of your Stripe account.
After 1 week, our policy is not to offer refunds. This means customers will need to assess within a week whether or not they wish to continue using your listing.
To minimize refunds, provide clear and accurate descriptions of what your Agent does, include comprehensive usage instructions, respond quickly to support questions, and keep your Agents well-maintained and updated.
## Joining the Community
It is expected that Relevance Builders are also passionate members of our Relevance AI Community. Once you set up your Relevance Builder profile, you will be given a badge in the Community that shows your status as a Relevance Builder.
### Share your listings
You are encouraged to post any listings you submit to the Marketplace in our [Agent Templates](https://community.relevanceai.com/c/agent-templates) section. This will bring more attention to your listing, and allow you to chat with customers who download / purchase your listing directly. We also encourage you to share your listings on social media (LinkedIn, YouTube, TikTok, etc.).
### Answer questions
We would also appreciate you keeping an eye out for questions related to your listings in the [Questions](https://community.relevanceai.com/c/questions) section. We may tag you in questions if we believe they're about your listings if we can't solve these questions ourselves.
### Relevance Builders space
You'll also have access to a dedicated space for Relevance Builders in the Community. Join the Community to access this space where you can discuss with fellow Relevance Builders and the Relevance AI team, share your listings and learnings, and leave feedback for the Relevance AI team.
Relevance Builders who spend more time in the Community build more trust with our customer base, and therefore have more success in our Marketplace.
## Best practices for supporting your Agents
Create detailed documentation for your Agents including:
* Step-by-step setup instructions
* Common use cases and examples
* Troubleshooting guides
* FAQ sections
You can host this on public Notion pages, GitHub, or your own website, and link to it from your listing description.
Try to respond to questions about your Agents within 24-48 hours. Quick responses show you're actively supporting your listings and build customer confidence.
Video walkthroughs can be incredibly helpful for users. Consider creating:
* Setup and configuration videos
* Use case demonstrations
* Troubleshooting guides
Share these on YouTube and link to them from your listing descriptions.
Regularly review and update your Agents to:
* Fix any bugs or issues
* Add new features based on user feedback
* Ensure compatibility with platform updates
* Improve performance and reliability
If you discover an issue with your Agent:
* Communicate it clearly to users
* Provide workarounds if available
* Update the Agent as soon as possible
* Notify users when the issue is resolved
Actively seek feedback from users and use it to improve your Agents. This shows you're committed to providing value and helps you create better listings.
## Community engagement strategies
Answer questions in the Community, even if they're not directly about your listings. This establishes you as a knowledgeable builder.
Post creative ways people are using your Agents. This inspires others and demonstrates the value of your listings.
Connect with other Relevance Builders to share knowledge, collaborate on projects, and cross-promote listings.
Engage in broader platform discussions. Your insights help shape the community and increase your visibility.
## Support workflow for paid listings
When a customer has an issue with your paid listing:
The customer will typically reach out to our support team first.
Our support team will attempt to troubleshoot the issue using your documentation and their knowledge of the platform.
If the issue requires your expertise, our support team will either:
* Reach out to you directly for assistance
* Direct the customer to contact you
* Tag you in a Community post about the issue
Work with the customer to resolve the issue. If it's a bug in your Agent, update the listing and push the changes.
After resolving the issue, follow up to ensure the customer is satisfied and consider if the issue reveals a need for better documentation or Agent improvements.
## Measuring your success
Track these metrics to understand how well you're supporting your Agents:
* **Clone count**: How many times your Agents have been downloaded
* **Refund rate**: Percentage of purchases that result in refunds
* **Community engagement**: Questions answered, posts made, discussions participated in
* **Customer feedback**: Reviews, testimonials, and direct feedback
* **Update frequency**: How often you improve and update your listings
Builders with low refund rates, high community engagement, and regular updates tend to have the most successful Marketplace presence.
## Getting help
If you need assistance with supporting your Agents or have questions about your responsibilities as a Builder:
* **Relevance Builders space**: Ask questions in the private Builders community
* **Support team**: Reach out to our support team for guidance
* **Documentation**: Refer to this guide and other documentation resources
***
## Congratulations!
You've completed the Relevance Builders guide! You now have everything you need to:
* Set up your Builder profile
* Submit Agents to the Marketplace
* Price and promote your listings
* Support your customers effectively
Ready to start building? Head to the [Relevance Builders section](https://app.relevanceai.com) in your project and create your first Marketplace listing!
Connect with other Relevance Builders, share your listings, and get support from the community
# Pricing
Source: https://relevanceai.com/docs/get-started/pricing
Plan tiers, Actions, Vendor Credits, and feature comparison for Relevance AI
Start delegating work to agents today. Grow as your AI Workforce expands.
**\$0** / month
Explore the platform.
From **\$19** / month
For solo GTM operators.
From **\$234** / month
For teams building at scale.
**Custom**
For org-wide AI Workforces.
## Plan details
Explore the platform — build agents, clone from the marketplace, and test them out.
**Includes:**
* 200 Actions / month
* \$2 bonus Vendor Credits (one-time)
* Unlimited Agents & Tools
* 1 Workforce
* 1 User & 1 Project
* 30-day Task History
* Marketplace Access
* Community Forum
* SOC 2 & GDPR Compliance
[Sign up today →](https://app.relevanceai.com/auth)
For GTM operators and engineers looking to start building agents and delegating them work. Annual billing saves 33% over the monthly rate.
**Includes everything in Free, plus:**
* 30,000 Actions / year (or 2,500 / month)
* \$240 Vendor Credits / year (or \$20 / month)
* Unlimited Workforces
* 2 Build Users
* Schedule Tasks
* Chat Mode
* Smart Escalations (Email & Slack)
* Activity Center
* Premium App Triggers (WhatsApp, LinkedIn, Telegram)
* Bring Your Own LLM
[Try for free →](https://app.relevanceai.com/auth)
For teams building agents to handle large workloads or for many users. Annual billing saves 33% over the monthly rate.
**Includes everything in Pro, plus:**
* 84,000 Actions / year (or 7,000 / month)
* \$840 Vendor Credits / year (or \$70 / month)
* Unused Credits Rollover
* 5 Build Users · 45 End Users
* 5 Shared Projects
* Calling & Meeting Agents
* A/B Testing
* Analytics Dashboard
* Priority Support
[Try for free →](https://app.relevanceai.com/auth)
For companies looking to decouple growth from headcount via an AI Workforce.
**Includes everything in Team, plus:**
* Custom Actions and Vendor Credits
* Unlimited Users & Projects
* Enterprise App Triggers (Salesforce, Snowflake, Zendesk)
* Agent Evaluations
* Work Hour Controls
* Multi-Org Management
* Enterprise Security (SSO, RBAC, audit logs)
* Dedicated Account Manager
* Custom Implementation
* Priority Early Access
[Contact sales →](https://relevanceai.com/book-a-demo)
## Complete feature comparison
### Platform
| Feature | Free | Pro | Team | Enterprise |
| ---------------------------------------------------------------------------------------- | ---------------- | --------- | --------- | ---------- |
| **[Actions](/docs/admin/subscriptions/plans) / month** | 200 | 2,500 | 7,000 | Custom |
| **[Vendor Credits](/docs/admin/subscriptions/plans) / month** | 1,000 (one-time) | 10,000 | 35,000 | Custom |
| **[Build Users](/docs/admin/project-management/add-members)** | 1 | 2 | 5 | Unlimited |
| **[End Users](/docs/admin/project-management/add-members)** | — | — | 45 | Unlimited |
| **[Shared Projects](/docs/admin/project-management/switch-projects)** | 1 | 1 | 5 | Unlimited |
| **[Workforces](/docs/get-started/core-concepts/workforces)** | 1 | Unlimited | Unlimited | Unlimited |
| **[Agents](/docs/get-started/core-concepts/agents)** | Unlimited | Unlimited | Unlimited | Unlimited |
| **[Tools](/docs/get-started/core-concepts/tools)** | Unlimited | Unlimited | Unlimited | Unlimited |
| **[Integrations](/docs/integrations/introduction)** | Unlimited | Unlimited | Unlimited | Unlimited |
| **[Concurrent Agent Tasks](/docs/admin/system-limits)** | Less | Standard | More | Custom |
| **[Knowledge / Memory](/docs/get-started/core-concepts/knowledge)** | Less | Standard | More | Custom |
| **[Task History](/docs/build/agents/build-your-agent/agent-settings/task-view)** | 30d | 90d | 90d | Custom |
| **[Scheduling Tasks](/docs/build/agents/build-your-agent/agent-triggers/scheduled-triggers)** | ✗ | ✓ | ✓ | ✓ |
| **[Escalations](/docs/build/agents/build-your-agent/alerts)** | ✗ | ✓ | ✓ | ✓ |
### Agent modes
| Feature | Free | Pro | Team | Enterprise |
| --------------------------------------------------------------------- | ---- | --- | ---- | ---------- |
| **[Chat](/docs/get-started/chat/introduction)** | ✓ | ✓ | ✓ | ✓ |
| **[Calling](/docs/build/agents/build-your-agent/agent-modes/phone-calls)** | ✗ | ✗ | ✓ | ✓ |
| **[Meeting](/docs/build/agents/use-cases/meeting-agents-overview)** | ✗ | ✗ | ✓ | ✓ |
### App integrations
| Feature | Free | Pro | Team | Enterprise |
| -------------------------------------------------------------------------------- | ---- | --- | ---- | ---------- |
| **[2,000+ Apps](/docs/integrations/introduction)** | ✓ | ✓ | ✓ | ✓ |
| **[Custom Apps & API Integrations](/docs/get-started/core-concepts/api-integration)** | ✓ | ✓ | ✓ | ✓ |
### Triggers
| Feature | Free | Pro | Team | Enterprise |
| ---------------------------------------------------------------------------------------------------------------------- | ---- | --- | ---- | ---------- |
| **[1,000+ App Triggers](/docs/build/agents/build-your-agent/agent-triggers/integrations)** | ✓ | ✓ | ✓ | ✓ |
| **[Premium Triggers](/docs/build/agents/build-your-agent/agent-triggers/integrations)** (WhatsApp, LinkedIn, Telegram) | ✗ | ✓ | ✓ | ✓ |
| **[Build your own Triggers](/docs/build/agents/build-your-agent/triggers)** | ✗ | ✓ | ✓ | ✓ |
| **[Enterprise Triggers](/docs/build/agents/build-your-agent/agent-triggers/integrations)** (Salesforce, Snowflake, Zendesk) | ✗ | ✗ | ✗ | ✓ |
### AI management
| Feature | Free | Pro | Team | Enterprise |
| ------------------------------------------------------------- | ---- | --- | ---- | ---------- |
| **Use any LLMs with credits** | ✓ | ✓ | ✓ | ✓ |
| **Bring your own LLM** | ✗ | ✓ | ✓ | ✓ |
| **A/B Testing** | ✗ | ✓ | ✓ | ✓ |
| **[Analytics Dashboard](/docs/enterprise/analytics)** | ✗ | ✗ | ✓ | ✓ |
| **[Agent Evaluations](/docs/build/agents/build-your-agent/evals)** | ✗ | ✗ | ✗ | ✓ |
| **Work Hour Controls** | ✗ | ✗ | ✗ | ✓ |
### Security & compliance
| Feature | Free | Pro | Team | Enterprise |
| -------------------------------------------------------------------- | ---- | --- | ---- | ---------- |
| **[SOC 2 & GDPR Compliance](/docs/admin/security)** | ✓ | ✓ | ✓ | ✓ |
| **[SSO (SAML)](/docs/enterprise/sso-setup)** | ✗ | ✗ | ✗ | ✓ |
| **[RBAC](/docs/enterprise/rbac)** | ✗ | ✗ | ✗ | ✓ |
| **[Audit Logs](/docs/enterprise/streaming-events)** | ✗ | ✗ | ✗ | ✓ |
| **[Multi-Org Management](/docs/enterprise/org-structure-best-practices)** | ✗ | ✗ | ✗ | ✓ |
### Support
| Feature | Free | Pro | Team | Enterprise |
| --------------------------------------------------------------- | ---- | --- | ---- | ---------- |
| **[Community Forum](https://community.relevanceai.com)** | ✓ | ✓ | ✓ | ✓ |
| **[Marketplace Access](/docs/get-started/marketplace/introduction)** | ✓ | ✓ | ✓ | ✓ |
| **Priority Support** | ✗ | ✗ | ✓ | ✓ |
| **Dedicated Account Manager** | ✗ | ✗ | ✗ | ✓ |
| **Custom Implementation** | ✗ | ✗ | ✗ | ✓ |
| **Priority Early Access** | ✗ | ✗ | ✗ | ✓ |
## Add-ons and top-ups
Top up your account with extra Actions or Vendor Credits at any time on a paid plan — no plan change required. Actions must be bought in increments of 1,000; Vendor Credits in increments of 10,000.
**\$80** per 1,000 Actions
More capacity for your AI Workforce to send emails, update CRMs, and run workflows.
**\$20** per 10,000 Vendor Credits
More AI model and tool usage, passed through at wholesale with no markup.
Top-ups are only available on paid plans — Free users need to upgrade to Pro or Team to purchase. See [Plans and credits](/docs/admin/subscriptions/plans) for the in-platform purchase flow.
### What rolls over and what resets at renewal
* **Vendor Credits roll over indefinitely** while you're subscribed — both your plan's included Vendor Credits and any top-ups you purchase. You won't lose unused Vendor Credits as long as your subscription stays active.
* **Plan Actions reset at each renewal** to your plan's default amount.
* **Action top-ups roll over to the next billing cycle**, so purchased Actions carry forward even though base plan Actions reset.
Rollover behavior above applies to Free, Pro, and Team plans. Enterprise customers should confirm rollover terms with their Account Manager.
## Frequently asked questions (FAQs)
An Action is counted when an agent runs a tool — whether it's a simple task like sending one email or a complex workflow with many steps.
Vendor Credits cover LLM and tool usage costs at wholesale, with no markup. They roll over indefinitely while you're subscribed, and you can bring your own API keys on paid plans to bypass them entirely.
Yes — on any paid plan, you can purchase top-ups at $80 USD per 1,000 Actions and $20 USD per 10,000 Vendor Credits. Actions must be bought in increments of 1,000 and Vendor Credits in increments of 10,000. To purchase, click the credit & action counter in the bottom left of your home screen, then **Buy credits**. Free users need to upgrade to Pro or Team to add top-ups.
Vendor Credits — both your plan's included Vendor Credits and any top-ups you purchase — roll over indefinitely while you're subscribed. Plan Actions reset to your plan's default amount at each renewal, but any Action top-ups you purchase roll over to your next billing cycle. Rollover behavior above applies to Free, Pro, and Team plans; Enterprise customers should confirm with their Account Manager.
You can upgrade in-platform by clicking the **Manage Plan** / credits counter in the bottom left of your dashboard in Relevance AI while logged in.
Yes, for Free, Pro, and Team plans. Subscriptions are applied at the Organization level, not to individual users or projects. Everyone in the Organization shares the plan's Actions, Vendor Credits, and feature access.
Enterprise customers can request additional Organizations under their subscription. If you're on an active Enterprise plan and need another Organization, speak to your account team.
No. Subscriptions cannot be transferred from one Organization to another.
Vendor Credits on the Free plan are a one-time allocation (1,000 credits at sign-up) and do not renew. Once you've used them, you'll need to upgrade to a paid plan (Pro or Team) to get more — Free users can't purchase top-ups.
Actions on Free reset to 200 each month, so basic Action-only usage continues each cycle.
Learn more about our Enterprise plans with our team. [Book a call](https://relevanceai.com/book-a-demo) to discuss your requirements.
No, Relevance AI's free plan doesn't require a credit card.
Your Project Information is confidential, even from Relevance AI. We are SOC 2 Type II compliant. [Read more about Relevance AI Security](/docs/admin/security).
## Next steps
Learn how Actions, Vendor Credits, top-ups, rollovers, and renewals work in the platform.
Talk to our team about Enterprise plans, custom Actions and Vendor Credits, or curated multi-agent systems like the BDR agent.
# Quick Start
Source: https://relevanceai.com/docs/get-started/quick-start-guide
Build and test your first AI agent in under 5 minutes.
This guide gets you from zero to a working agent as fast as possible. Pick one of three paths, follow the steps, and see your agent in action.
These steps assume you're logged in and on the home screen. If you don't have an account yet, [sign up for free](https://auth.relevanceai.com/signup/).
## Step 1: Create your first Agent
There are three ways to get started. Pick the one that fits you best.
Describe what you want and let AI build it for you
Grab a pre-built agent and make it yours
Full control over every detail
### Option 1: Invent an Agent
The fastest way to get started. Describe what you need and we'll generate a working agent for you.
1. Click **Agents** in the left sidebar
2. Click **+ Create Agent**
3. Select **Invent**
4. Describe what you want your agent to do — be specific about the task, the output you expect, and any integrations it should use. For example: *"Create an agent that researches a company before a sales call. It should use web search to find recent news, funding, and key contacts, then output a one-page brief with company overview, decision makers, and talking points."*
5. Review the generated agent — Inventor will set up the prompt and suggest tools
6. Connect any integrations your tools need (e.g. Gmail, HubSpot, LinkedIn) in the Tools section of the Agent builder, or [add integrations](/docs/integrations/add-integrations) from the sidebar
Best when you know what you want and can describe it clearly. Great for getting a concept off the ground quickly — Inventor handles the setup, you make the tweaks.
### Option 2: Clone from Marketplace
Start with an agent that's already been built and tested by domain experts.
1. Go to [Marketplace](https://marketplace.relevanceai.com/) or click **Marketplace** in the left sidebar
2. Browse or search for an agent that matches your use case
3. Click on the agent to view its details
4. Click **Clone** to add it to your workspace
5. A setup popup will walk you through connecting any integrations the agent needs — follow the prompts to link your accounts
6. Review the prompt, tools, and settings — adjust anything you need
Great when you have a common use case — like lead qualification, meeting prep, or customer support — and want a proven starting point. Clone it, tweak it, ship it.
### Option 3: Build from scratch
Full control from the ground up. Best if you have a specific workflow in mind.
1. Click **Agents** in the left sidebar
2. Click **+ Create Agent**
3. Select **Start from scratch**
4. Write a [prompt](/docs/build/agents/build-your-agent/prompt) — tell the agent who it is, what it does, and how it should behave
5. Add [tools](/docs/build/agents/build-your-agent/tools) — give it the actions it needs (search the web, send emails, update your CRM, etc.)
6. Optionally add [knowledge](/docs/build/knowledge/create-knowledge) — upload docs or connect data sources for context
For a full breakdown of building with Relevance AI, see [Build with Relevance AI](/docs/build/introduction).
## Step 2: Test your Agent
Head to the **Run** tab to give your agent a task. This is a real run — you can see exactly what tools it calls, what output it produces, and how it handles the task end-to-end.
You can also use your agent in [Relevance Chat](/docs/get-started/chat/introduction) — a conversational interface where you and your team can @ mention any agent.
## Step 3: Refine
If the output isn't quite right, iterate:
* **Tighten the prompt** — be more specific about what you want, how it should be formatted, and what tone to use
* **Add or adjust tools** — make sure the agent has access to the right actions for the job
* **Add knowledge** — upload docs, connect data sources, or add context so the agent has what it needs
Test again after each change. A few rounds of this and you'll have a solid agent.
## Step 4: Share and deploy
Once you're happy with the output, put your agent to work:
* [Share your agent](/docs/build/agents/share-your-agent) with your team so others can use it
* Use [Relevance Chat](/docs/get-started/chat/introduction) to give your team instant access to your agents
* Set up [triggers](/docs/build/agents/build-your-agent/triggers) to run it automatically — on a schedule, from a webhook, or when something happens in your CRM
* Use [bulk schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule) to run it across a list of inputs
* Add [alerts](/docs/build/agents/build-your-agent/alerts) so you get notified when something needs attention, and the agent knows when to loop in a human
## Beyond building
Now that you've got an agent up and running, there's more to explore across the platform.
### Use your Agents in Chat
[Relevance Chat](/docs/get-started/chat/introduction) is a conversational interface where you and your team interact with your agents directly. Type a message, @ mention any agent in your project, and it will handle the task using the tools and knowledge you've configured. You can switch between LLMs, combine multiple agents in a single conversation, save prompts your team uses often, and @ mention project files to insert their paths directly into your message. Chat also comes with built-in agents for things like building websites, generating images, deep research, and creating presentations.
Visit [chat.relevanceai.com](https://chat.relevanceai.com) to get started — it works on desktop and mobile.
### Browse the Marketplace
The [Marketplace](/docs/get-started/marketplace/introduction) is a curated library of pre-built agents and tools created by Relevance AI and the community. Instead of building from scratch, you can clone an agent that's already been designed and tested for common use cases — lead qualification, customer support, meeting prep, and more. Once cloned, you have full control to customize the agent's prompt, tools, and settings to fit your needs.
### Build from your AI coding environment
Prefer to work from your terminal? Connect your AI coding environment — Claude Code, Cursor, or any MCP-compatible client — to Relevance AI over MCP. Describe what you want in natural language and your AI assistant builds and edits your Agents, Tools, and Workforces directly. See [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins) to get started.
***
Ready to go deeper? Head to [Build with Relevance AI](/docs/build/introduction) for a full breakdown of how to configure agents, tools, knowledge, and multi-agent workforces.
# How to reach out to our support team
Source: https://relevanceai.com/docs/get-started/support
How to contact Relevance AI support for help and questions
If you need help or have questions, our support team is here to assist you! There are three ways to get support, either from our team or from fellow customers.
## Relevance AI Community
The [Relevance AI Community](https://community.relevanceai.com) is a platform to connect with fellow Relevance AI customers, Partners, AI experts and Rellies (Relevance AI team members).
If you're looking for support from your fellow users, including advice on how to build using our platform, we'd recommend reaching out to the Community and creating a question [here](https://community.relevanceai.com/c/questions/).
Please note that this space is primarily monitored by our Community members, and is considered a peer to peer Community space. If your question in the Community has been left unanswered, you are welcome to reach out to our support team for help using the methods below.
## In-app chat ticket support
The fastest way to get in touch is through our in-app chat support:
1. Log in to [Relevance AI](https://app.relevanceai.com/)
2. Click the **Ask for Help** button, found in the bottom left corner of Relevance AI in the sidebar (or use the keyboard shortcut CMD + K)
3. Ask the AI Agent a question here, or click 'Create a support ticket' to start chatting with our support team
4. Then, click on **Start new chat** to start chatting with our support team
## Email support
If you prefer, you can also email us at [**support@relevanceai.com**](mailto:support@relevanceai.com).
## Phone support
We only offer dedicated staff calls for **Enterprise customers**.
If you're on a **Free to Team plan**, we offer calls with **Harley**, an AI support agent who can walk through your concerns with you.
### How to request a call from Harley:
1. [Raise a support ticket](/docs/get-started/support#in-app-chat-ticket-support) first, including a description of your concern
2. Request a call in your ticket, providing:
* Your phone number
* A suitable time within our business hours (9am - 5pm Sydney time (AEST / AEDT) on weekdays)
**Beta Service Notice:** Harley is currently in beta and may experience bugs or errors. This is an early-stage service, and we welcome constructive feedback to help us improve the experience.
***
## Enterprise support
We offer priority support to Enterprise customers, including a dedicated Slack channel for support. We also offer custom implementation (agent building services and consultation) to our Enterprise customers, as well as a dedicated Account Manager and priority early access to new features.
You can compare our plans, including all the value Enterprise has to offer your organization, on our [pricing page](/docs/get-started/pricing).
If you'd like to discuss an upgrade to Enterprise, please [book a demo](https://relevanceai.com/book-a-demo). If you don't hear back from our sales team, please reach out to support via one of the methods above.
***
## Service Level Agreements (SLAs)
We offer the following first response times (FRT) SLAs, based on your subscription:
| Subscription | SLA |
| -------------- | --------------- |
| **Enterprise** | 1 business day |
| **Team** | 2 business days |
| **Pro** | 3 business days |
While **Free** customers can raise tickets at this time, we do not offer SLAs for free customers.
Our team currently only offer support to Free, Pro and Team customers between 9am - 5pm Sydney time (AEST / AEDT) on weekdays at this time. We do not offer weekend support. Our team is actively growing, and we will expand our support team globally in the future.
***
## Frequently asked questions (FAQs)
Yes! We dogfood our own AI Agent platform across all teams, including support. We're AI-first and use AI Agents throughout our support process for answering customer questions, researching our platform, and drafting documentation.
The level of support you receive depends on your subscription:
* **Free tier:** AI Agent support and Community access
* **Pro and Team tiers:** A mixture of human and AI support
* **Enterprise tier:** Dedicated support including account managers, with AI assistance
This approach allows us to provide faster, more consistent support while ensuring human experts are available for complex issues.
We're committed to providing excellent support in a respectful and professional environment. We expect professional and respectful communication across all channels, including support tickets, email, and Community forums.
Aggressive, antagonistic, or abusive language—including swearing—may result in our inability to provide support. Our team members deserve a safe and respectful work environment.
All interactions are governed by our [Terms & Conditions](https://relevanceai.com/terms-and-conditions). We welcome constructive feedback about our products and services, and we encourage you to share it professionally.
The Business plan has been sunset, and all Business customers have automatically been moved to the Team plan. If you'd like to retain your dedicated Slack channel, please contact our sales team to discuss an upgrade to Enterprise.
Our team members and AI Agents aren't able to help answer questions. Please reach out using one of the methods above and we'll be able to help you with your question or issue!
Our engineering team is on-call 24/7, and we will respond to any outages that occur outside of our supported hours. You may not receive a response outside of our supported hours, but our engineering team will come online to address any alerts / outages and swiftly resolve them.
Bug reports are sent to our engineering team for investigation, however, we don't respond to bug reports. If you need immediate help or want to follow up on a bug report, please reach out to support via one of the methods above.
# Troubleshooting agents not working
Source: https://relevanceai.com/docs/get-started/troubleshooting/troubleshooting-agents-not-working
Troubleshoot agents that are failing or not working properly
When your agents aren't working as expected, there are several common causes and solutions. This guide will help you identify and resolve the most frequent issues that prevent agents from functioning properly.
## Common causes of agent failures
### 1. Insufficient credits or actions
If your agent is failing, the most common cause is running out of credits or actions.
#### Understanding credits and actions
Relevance AI uses two types of consumption:
* **Actions**: Each time a tool runs, it counts as one action — whether it's a simple task like sending one email or running a complex workflow with many steps
* **Vendor Credits**: The cost of running the AI model (LLM costs) and the tools you use
#### How to check your usage
Learn how to monitor your credit and action usage at both the [organization level](/docs/admin/subscriptions/plans#monitoring-actions-and-vendor-credits-usage) and [individual agent level](/docs/admin/subscriptions/plans#at-an-individual-agent-level).
#### Solutions for insufficient credits/actions
* **Upgrade your plan**: Consider upgrading to a higher plan with more credits/actions
* **Purchase additional credits**: If you have a paid plan, you can purchase extra credits to use before your next renewal
* **Bring your own API keys**: Use your own API keys to bypass Vendor Credits entirely (available on paid plans only)
### 2. Tool failures
When agents fail, it's often because one of their tools is not working properly. Here's how to troubleshoot tool issues:
Use the **Has active tool failures** filter in the Task list to quickly identify which Tasks had Tool failures — including cases where the Agent continued running despite a Tool error. See [Filtering Tasks](/docs/build/agents/give-your-agent-tasks/task-overview#filtering-tasks) for details.
#### Step 1: Test the tool independently
1. Go to the [Tools page](https://app.relevanceai.com/tools)
2. Find the tool your agent is using
3. Click on the tool and go to the "Use" tab
4. Run the tool with test inputs to see if it works on its own
If the tool fails independently, the issue is with the tool itself, not the agent. To fix tool issues:
1. Go to the "Build" tab of the tool
2. Run each tool step individually by clicking the play icon next to each step
3. Identify which specific step is failing
4. Check the step configuration and fix any issues:
* Verify API keys are correct
* Check input formats and data types
* Review step settings and parameters
* Remove or reconfigure problematic steps
#### Step 2: Check agent-to-tool communication
If the tool works independently but fails when used by the agent:
1. **Verify input data types**: Ensure the agent is sending the tool the correct data types (string, array, number, etc.)
2. **Check input format**: Make sure the agent is providing inputs in the expected format
3. **Review tool input descriptions**: Ensure each tool input has a clear description explaining what the agent should provide
4. **Review tool configuration**: Go to your agent's tools section and check:
* Input configuration mode (Let agent decide, Set manually, or Tool output)
* Whether the agent has the right context to use the tool
* If approval settings are preventing tool execution
#### Common tool input issues
**Data type mismatches:**
* Tool expects a string but receives an array
* Tool expects a number but receives text
* Tool expects JSON but receives plain text
**Format issues:**
* Missing required fields
* Incorrect field names
* Wrong data structure
**Solution**: Review your agent's instructions and tool configuration to ensure the agent understands what data to send to each tool.
### 3. Agent configuration issues
#### Check agent settings
1. **Review agent prompt**: Ensure your agent has clear, specific instructions about when and how to use tools
2. **Verify tool approval settings**: Check if tools are set to "Auto Run", "Approval Required", or "Let Agent Decide"
3. **Check escalation settings**: Review retry settings and error handling behavior
#### Common configuration problems
* **Vague prompt**: Agent doesn't understand when to use tools
* **Wrong approval mode**: Tools require approval but agent doesn't ask
* **Missing context**: Agent lacks information needed to use tools effectively
* **Conflicting settings**: Multiple tools with overlapping purposes
### 4. Integration and API issues
#### Check integrations
1. Go to [Integrations & API Keys](https://app.relevanceai.com/integrations) in Relevance AI
2. Verify all required integrations are connected
3. Check if API keys are valid and have proper permissions
4. Test integration connections
#### Common integration problems
* **Expired API keys**: Update or refresh your API keys
* **Insufficient permissions**: Ensure API keys have the required scopes
* **Rate limiting**: Check if you've hit API rate limits
* **Service outages**: Verify the external service is operational
## Agent not working as expected
If your agent is running but not producing the results you want, this is often a prompt engineering issue.
### Understanding agent behavior
Agents are designed to make their own decisions and aren't end-to-end workflows. They use reasoning to determine the best approach to complete tasks, which means they may not always follow the exact path you expect.
### Improving your agent prompt
To get better results from your agent:
1. **Be as clear and specific as possible** in your agent prompt
2. **Provide detailed instructions** about what you want the agent to do
3. **Include examples** of good responses or behaviors
4. **Specify the format** you want outputs in
5. **Set clear boundaries** about what the agent should and shouldn't do
### Key prompt engineering principles
* **Be explicit**: Don't assume the agent will understand implicit requirements
* **Use clear language**: Avoid ambiguous terms and provide specific criteria
* **Provide context**: Give the agent relevant background information
* **Set expectations**: Clearly define what success looks like
* **Iterate and test**: Refine your prompt based on the agent's performance
For a deeper understanding of when to use AI agents vs workflows, read our co-founder's [comprehensive guide on LinkedIn](https://www.linkedin.com/feed/update/urn:li:activity:7336149777472024593/).
### Model performance issues
If your agent isn't performing well, consider upgrading to a more capable language model.
#### When to upgrade your model
* **Complex reasoning tasks**: Advanced models handle multi-step reasoning better
* **Tool usage**: Some models are better at understanding when and how to use tools
* **Large context**: If you need to process large amounts of information
* **Specialized tasks**: Some models excel at specific types of work
#### Available models and their strengths
**OpenAI models:**
* Advanced conversational abilities and creative writing
* Broad general knowledge and versatility
* Best for: Versatile agents, customer support, brainstorming
* Learn more: [OpenAI LLM models](/docs/integrations/llm-integrations/openai)
**Google Gemini models:**
* Strong coding ability and complex task handling
* Excellent at processing multiple file types (PDF, images, audio, video)
* Best for: Software development agents, complex task execution
* Learn more: [Google's Gemini LLM models](/docs/integrations/llm-integrations/gemini)
**Anthropic Claude models:**
* Focused on safe, reliable, and ethical AI responses
* Excellent at reasoning and thoughtful tasks
* Best for: Detailed explanations, structured outputs, sensitive industries
* Learn more: [Anthropic LLM models](/docs/integrations/llm-integrations/anthropic)
More advanced models are more expensive but often provide significantly better results. Consider your use case and budget when choosing a model.
If you're experiencing configuration issues where your agent isn't working as expected, our support team has limited ability to provide guidance to customers on Team or below as this is considered implementation support, which we only offer to Enterprise customers.
If you're interested in an Enterprise subscription with dedicated implementation support to build agents for your use cases, you can [book a demo](https://relevanceai.com/book-a-demo). You can also reach out to our [Partners](https://partners.relevanceai.com) for implementation support.
## Still need help?
If you've tried all the troubleshooting steps above and your agent is still not working, please [contact our support team](/docs/get-started/support) and include:
* Your agent configuration details
* Error messages you're seeing
* Steps you've already tried
* A description of the specific issue you're experiencing
* **Screen recording**: Attach a [Loom](https://loom.com) or [jam.dev](https://jam.dev) recording of the issue to help us understand the problem better
# Troubleshooting browser issues
Source: https://relevanceai.com/docs/get-started/troubleshooting/troubleshooting-browser-issues
Troubleshoot browser-related issues with Relevance AI
The browser is what you use to access Relevance AI on your desktop computer. This includes Chrome, Firefox, Safari, Edge, and other modern browsers. Because all browsers are different, sometimes you might experience issues with Relevance AI because of the browser you are using. These issues can range from login problems (such as blank pages or login loops) to unexpected behavior in Relevance AI once you log in, including slow loading times, broken features, or integration failures. This article will help you troubleshoot those issues and get back to using Relevance AI smoothly.
## Supported browsers and platforms
Relevance AI supports the following modern browsers on desktop:
* **Chrome**
* **Firefox**
* **Safari**
* **Edge**
* **Arc**
* **Dia**
* **Comet**
**Do not use [app.relevanceai.com](https://app.relevanceai.com) on mobile devices.** The builder platform (where you create and configure Agents, Tools, and Workforces) is designed for desktop use only and will not function properly on mobile browsers. Please use a desktop computer to access [app.relevanceai.com](https://app.relevanceai.com).
While the builder platform is not available on mobile, Relevance Chat is available as a native app for [iOS](https://apps.apple.com/au/app/relevance/id6757512568) and [Android](https://play.google.com/store/apps/details?id=com.relevanceai.android), or in a mobile browser at [chat.relevanceai.com](https://chat.relevanceai.com).
## Basic troubleshooting steps
If you're experiencing issues with Relevance AI, try the following steps in order:
### 1. Update your browser
Make sure you're using the latest version of your browser. Outdated browsers may not support all the features required by Relevance AI.
### 2. Disable browser extensions
Browser extensions can sometimes interfere with Relevance AI's functionality. Try disabling all extensions temporarily:
1. Open your browser in incognito/private mode
2. Navigate to [app.relevanceai.com](https://app.relevanceai.com)
3. Test if the issue persists
If the issue is resolved in incognito mode, one of your extensions is likely causing the problem.
### 3. Clear browser cache
Clearing your browser's cache can resolve many common issues:
* **Chrome**: Press `Ctrl+Shift+Delete` (Windows) or `Cmd+Shift+Delete` (Mac)
* **Firefox**: Press `Ctrl+Shift+Delete` (Windows) or `Cmd+Shift+Delete` (Mac)
* **Safari**: Go to Safari menu > Clear History and Website Data
* **Edge**: Press `Ctrl+Shift+Delete` (Windows) or `Cmd+Shift+Delete` (Mac)
### 4. Try a different browser
Test Relevance AI in a different browser to see if the issue is browser-specific.
### 5. Check your network connection
Try connecting to a different network to rule out network-related issues.
### 6. Check antivirus software
Make sure your antivirus software isn't blocking the following Relevance AI domains:
* `app.relevanceai.com`
* `chat.relevanceai.com`
* `marketplace.relevanceai.com`
* `api-REGIONID.stack.tryrelevanceai.com` (replace REGIONID with your [region ID](/docs/admin/project-management/ids))
## Troubleshooting specific issues
### Login problems
If you're having trouble logging in:
1. **Blank login page**: Clear your browser cache and try incognito mode
2. **Login loop**: Disable browser extensions and try incognito mode
3. **Invalid credentials**: Double-check your email and password, or [reset your password](/docs/admin/account-management/change-password) if needed
4. **SSO login issues**: If you're using Single Sign-On (SSO), contact your Enterprise admin for assistance with authentication problems
### Performance issues
If Relevance AI is running slowly:
1. **Check your internet connection**: Ensure you have a stable, fast connection
2. **Close unnecessary tabs**: Free up browser memory
3. **Disable resource-heavy extensions**: Ad blockers and privacy tools can slow down the platform
4. **Clear browser cache**: Accumulated cache can impact performance
### Integration connection problems
If integrations aren't working:
1. **Check pop-up blockers**: Some integrations require pop-ups to be allowed
2. **Verify domain permissions**: Ensure the integration domains are allowed
3. **Check antivirus settings**: Make sure your antivirus isn't blocking integration domains
## Browser console errors
If you're still experiencing issues, check your browser's console for error messages:
### Opening the console
* **Chrome**: Press `Ctrl+Shift+J` (Windows) or `Cmd+Opt+J` (Mac)
* **Firefox**: Press `Ctrl+Shift+K` (Windows) or `Cmd+Opt+K` (Mac)
* **Safari**: Enable Developer menu in Preferences > Advanced, then press `Cmd+Opt+C`
* **Edge**: Press `F12` and go to the 'Console' tab
### Common error messages
Look for these common error messages in the console:
* **CORS errors**: Usually related to domain restrictions
* **Network errors**: Check your internet connection
* **JavaScript errors**: May indicate browser compatibility issues
* **Authentication errors**: Check your login credentials
If you find error messages in the console, take a screenshot or copy the error text and include it when contacting support.
## Still need help?
If you've tried all the troubleshooting steps above and are still experiencing issues, please [contact our support team](/docs/get-started/support) and include:
* Your browser type and version
* Any error messages from the console
* Steps you've already tried
* A description of the specific issue you're experiencing
* **Screen recording**: Attach a [Loom](https://loom.com) or [jam.dev](https://jam.dev) recording of the issue to help us understand the problem better
# Guides
Source: https://relevanceai.com/docs/guides
Practical, opinionated walkthroughs for putting Relevance AI to work in the function your team actually runs.
Each Guide takes a real go-to-market or operations function and shows you the shortest path from zero to a working AI implementation. They fork into three persona paths so the walkthrough matches how hands-on your team wants to be — no build, build visually, or build with AI.
## Pick a function
Research, outreach, lead scoring, CRM enrichment, meeting prep.
Lifecycle campaigns, content repurposing, campaign analytics.
Account health, QBR prep, renewal and expansion.
Ticket triage, response drafting, knowledge base generation.
RFP responses, demo prep, technical discovery summaries.
Pipeline hygiene, lead routing, data dedup.
## The four levels of AI autonomy
Every Guide climbs the same ladder — from human-led work to self-driving systems.
Human asks, Agent acts, one task at a time. A sharper version of search — single request, single response.
Human kicks off a job, the Agent runs many actions, human reviews output before it ships. The Agent works ahead of you; you stay the gate.
Events and signals trigger a workforce of Agents that collaborate end-to-end. Humans manage the fleet, not each task.
Humans set business goals, Agents experiment and optimize autonomously. The system shapes itself against outcomes.
Pick a Guide above to see what each level looks like for your team.
# Account health and churn signals
Source: https://relevanceai.com/docs/guides/customer-success/account-health
Score every account on health with reasoning, not just a number. Surface risk before renewal so CSMs can act in time.
Health scores that are just numbers don't get used. A health Agent rates accounts across the signals that actually predict churn — usage drops, support spikes, exec turnover, deal-stage stalls — and surfaces the *why* so CSMs can do something about it.
## When this pays off
Churn risks are caught at renewal, not 90 days out when there's still time to fix them.
The existing red/yellow/green field doesn't influence CSM action — nobody trusts the rollup.
Usage data, support tickets, deal notes, exec changes — all in different tools, nobody synthesizes them.
Each CSM has 80+ accounts and there's no way to triage which ones need attention this week.
## The shape of this use case
A health Agent takes an account and returns a score, the reasoning behind it, and a recommended next action.
Account record, time window, segmentation cut.
CRM, support tickets, product usage / analytics, deal history, exec change tracking, your CS playbook.
A health score with cited signals, a short summary of the risk picture, and a recommended outreach action.
Written back to the CRM as a field plus a note, posted in [Slack](/docs/integrations/popular-integrations/slack) for at-risk accounts, surfaced in a CSM digest.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Customer Success Manager](https://marketplace.relevanceai.com/listing/b9b5e05c-4512-4749-8f66-4623ab895e21)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your CSMs can use on day one:
* *"How is Acme Corp doing right now? Usage, tickets, last contact, anything I should worry about?"*
* *"Which 5 accounts in my book look highest-risk for Q1 renewal?"*
* *"Compare Globex's engagement this quarter vs. last — what changed?"*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your CS playbook in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Pipe churn outcomes back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so scoring tracks what predicted cancellation.
## Common pitfalls
A number alone is unactionable. CSMs need to see *which* signals moved and *why* the Agent flagged the account — otherwise they ignore it.
Your churn drivers shift over time. Review the prompt's scoring criteria each quarter against actual churned accounts.
Some segments use the product weekly and never churn; others log in monthly and stay loyal. Weight signals by segment, not globally.
Without piping churn outcomes back to the Agent's evals, the scoring can't learn. Connect closed-lost / churned status to evaluation runs.
# Customer Success
Source: https://relevanceai.com/docs/guides/customer-success/getting-started
Put AI Agents to work across the post-sale journey — health, renewals, expansion — so CSMs spend time on the accounts that need them.
CSMs are stretched across too many accounts. AI Agents take the watchful work — tracking signals, prepping QBRs, surfacing renewal risks — so CSMs focus on the conversations that actually move retention and expansion.
## Start with a Marketplace template
The Marketplace ships pre-built Agents you can clone in one click. Adapt them to your segments, your renewal cadence, your playbook. Or [build a custom Agent from scratch](/docs/build/introduction).
In-depth research on an account, producing a structured report — useful before QBRs and renewal conversations.
Researches an account and writes the plan back to your CRM — handy for expansion across the book.
The full catalog of Agents — health scoring, renewals, QBR prep, customer comms.
Click **Clone Agent** on any listing, connect the systems it needs (CRM, support, product analytics), and run it on a real account.
## Pick your path
How hands-on do you want to be? Pick a tab — the rest of the page is written for you.
You don't need to touch the builder. Open the cloned Agent above, ask in plain English, and let it work across the systems it's connected to.
## Sharpen the answers with knowledge
Upload your CS playbooks, segmentation rules, renewal use case docs, and product positioning. Every conversation references them — sharper output, no new setup.
Upload context once. Every conversation references it.
## Make it run on its own
When you find yourself summarizing the same account state every Monday, set a trigger — every CSM gets a weekly book-of-business digest, every at-risk account auto-flags. One toggle, no code, no builder.
Schedule runs, fire on CRM events, listen to webhooks.
## Ready to go further?
When prompting and templates stop being enough — when you want the Agent to follow your team's playbook word for word and orchestrate cross-system signal monitoring — pick the **Build visually** tab above.
You're comfortable in product UIs. You don't want to wire up an Agent from scratch, but you do want it to follow your CS playbook account by account. Open the cloned Agent in the builder and shape every piece.
## Connect the tools it needs
CS Agents work best when they can read from and write to the systems your team already uses.
* **CRM** — [HubSpot](/docs/integrations/popular-integrations/hubspot) or [Salesforce](/docs/integrations/popular-integrations/salesforce) for account data, deal stage, and renewal timing
* **Support** — [Zendesk](/docs/integrations/popular-integrations/zendesk) or Intercom for ticket activity and CSAT
* **Product analytics** — your usage data source for engagement signals
* **Comms** — [Gmail](/docs/integrations/popular-integrations/gmail), [Slack](/docs/integrations/popular-integrations/slack) for outreach and internal alerts
See more about [Integrations](/docs/integrations/introduction).
## Shape every surface
Each piece below changes how the Agent behaves. Run it on a real account between every change — small iterations beat big rewrites.
Edit the system prompt to match your segmentation, escalation rules, and renewal use case.
Add or remove the actions the Agent can take — pull usage data, query support tickets, draft renewal emails.
Upload your CS playbook, customer journey docs, segmentation rules. The Agent draws on these whenever it works.
Run the Agent automatically — on a schedule, when usage drops, when a renewal date approaches.
Get notified when an account crosses a health threshold or when a renewal slips.
Persistent context per account — last interactions, prior escalations, what worked at renewal time.
## Chain Agents into a workforce
When a single Agent isn't enough — score health, then draft outreach, then schedule, then log to the CRM — wire them together on the Workforce canvas.
Drag, connect, and run multi-Agent pipelines without code.
## Test before you trust
Set up evals so health scoring or QBR-prep regressions get caught before they reach the CSM.
Define test cases in the UI. Run them on every change.
## Ready to go further?
When clicking through the builder starts to feel slow — when you'd rather have your AI coding assistant build and edit Agents for you, drop into custom Python or JS code blocks, or call Agents from your own app via the SDK — pick the **Build with AI** tab above.
You already work in an AI coding environment. Clicking through a UI to edit health-scoring rules feels slow. Have your AI assistant build, shape, and orchestrate Agents directly from your editor.
## MCP & Plugins
Connect your AI coding environment to Relevance AI over MCP. Describe what you want in natural language; your AI assistant reads and writes your Relevance workspace — system prompts, Tools, knowledge, triggers, workforces, evals.
The fastest setup. Install the Relevance AI plugin and build Agents from your terminal.
Connect from Claude Desktop, Cursor, VS Code, ChatGPT, OpenAI Codex, or any MCP client.
Clone the skills repo so your coding assistant has built-in knowledge of Relevance patterns.
The full reference for what you can do programmatically.
## The four levels in customer success
How the [autonomy ladder](/docs/guides) plays out across your book of business:
A CSM asks the Agent to summarize Acme's last quarter before a check-in — the Agent returns a snapshot with usage, tickets, and any deal-stage shifts.
A CSM asks for renewal plans across 12 accounts — the Agent drafts each plan, the CSM reviews and queues outreach.
Product usage drops on a key account → health score updates → the CSM is alerted with a draft outreach plan, all without anyone touching a dashboard.
You set the objective — "reduce gross churn" — and the Workforce scores health, drafts outreach, and logs to the CRM, with its risk-signal criteria tuned through evals as churn outcomes flow back.
## Zoom into a single use case
Each use case below is a working entry point — clone a template, then run it, shape it visually, or build with AI depending on which tab fit you.
Score every account on health with reasoning, not just a number. Surface risk before renewal.
Auto-generate exec-ready QBR decks from CRM, support, and usage data — minutes, not hours.
Draft account-aware renewal and expansion plays for every account, every quarter.
## See it in production
# QBR and business review prep
Source: https://relevanceai.com/docs/guides/customer-success/qbr-prep
Auto-generate exec-ready QBR decks from CRM, support, and usage data — minutes, not hours.
A QBR is supposed to take an hour to prep and instead takes half a day. The CSM pulls usage data, support history, deal notes, and an exec summary into a slide deck — and does that for 12 accounts a quarter. A QBR Agent does the assembly so the CSM spends time on the *insight*, not the data hunting.
## When this pays off
Reviews get canceled or shortened because nobody had time to prep — the customer notices.
Senior CSMs ship excellent QBRs; newer ones ship rough ones — the customer experience varies wildly.
CSMs are exporting from HubSpot, screenshotting Looker, copying from Zendesk — the same way every time.
The "next quarter recommendation" slide always gets written last, briefly, because data prep ate the time.
## The shape of this use case
A QBR Agent takes an account + time window and returns a structured review with sourced data.
Account, review period, audience (operational vs exec), template / brand to follow.
CRM activity, support ticket history, product analytics, deal notes, your QBR template, segment playbooks.
A draft QBR — usage summary, support summary, business outcomes, recommended next quarter, cited data — in your team's format.
Posted to a [Notion](/docs/integrations/popular-integrations/notion) or Google Doc for the CSM to refine, emailed as a draft, dropped into a [Slack](/docs/integrations/popular-integrations/slack) thread for review.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Customer Success Manager](https://marketplace.relevanceai.com/listing/b9b5e05c-4512-4749-8f66-4623ab895e21)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your CSMs can use on day one:
* *"Draft a QBR for Acme Corp covering last quarter — usage, support summary, business wins, recommended next steps."*
* *"What did Globex achieve this year vs. their stated goals? Pull from CRM notes and product usage."*
* *"Give me the operational summary slide for Initech's QBR — usage trends and support trend only."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your QBR template in [Knowledge](/docs/build/knowledge/create-knowledge), and a connected [CRM](/docs/integrations/popular-integrations/hubspot), support, and analytics.
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed back which QBR sections landed into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so the format tracks what's used.
## Common pitfalls
A QBR that lists metrics without telling a story is just a report. Force the prompt to summarize what changed and why it matters.
Enterprise QBRs and mid-market QBRs should look different. Branch the prompt on segment so the depth and audience tone shift accordingly.
Tempting to skip the CSM read. Don't — a misread on a strategic account is a relationship cost. The Agent drafts, the CSM ships.
If the Agent pulls product usage but doesn't filter by account properly, you get the wrong numbers in front of an exec. Validate the data sources for the top 10 accounts before going live.
# Renewal and expansion outreach
Source: https://relevanceai.com/docs/guides/customer-success/renewal-expansion
Draft account-aware renewal and expansion plays for every account, every quarter — so no opportunity slips.
The accounts most likely to expand and the accounts most likely to churn both want personalized attention at renewal. With 80 accounts per CSM, "personalized" usually means "whoever has the loudest email this week." A renewal Agent drafts the playbook touch for every account so nothing is on autopilot — and nothing falls through.
## When this pays off
Some accounts get a renewal plan three months out, others get a check-in email two weeks before.
Accounts that look healthy don't get expansion conversations because nobody flagged them.
Every renewal email reads the same — the customer can tell.
Promises made at QBR aren't being tracked into the renewal cycle.
## The shape of this use case
A renewal Agent takes an account + renewal window and returns a tailored plan with drafted outreach.
Account, renewal date, health score, segmentation, last touch, prior QBR commitments.
CRM, prior QBRs, support history, usage data, your renewal playbook, expansion criteria.
A renewal plan — recommended action sequence, drafted outreach for each step, expansion talking points where they apply.
Plan saved to the CRM, outreach drafts queued in [Gmail](/docs/integrations/popular-integrations/gmail), expansion intel posted to the AE in [Slack](/docs/integrations/popular-integrations/slack).
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open **[Apla, the Account Planning Agent](https://marketplace.relevanceai.com/listing/fd712abc-66e4-4507-8f16-c4404cf5f5e5)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your CSMs can use on day one:
* *"Acme Corp renews in 90 days — give me a 3-touch renewal plan with drafted emails, plus any expansion angle worth raising."*
* *"What did we promise Globex at the last QBR? Draft a follow-up confirming we delivered before their renewal."*
* *"Is Initech worth a price increase conversation this renewal? Pull usage and engagement signals to make the case."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your renewal playbook in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed renewal outcomes back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so it leans on the plays that saved accounts.
## Common pitfalls
Without per-account context (last QBR commitments, segment, usage pattern), every renewal email reads identical. Pull from past account interactions, not just static templates.
Renewal outreach to a strategic account that goes out without a human read is how trust gets burned. Keep CSM-in-the-loop until you've watched it for several cycles.
A healthy renewal that doesn't ask about expansion is a missed quarter. Build expansion checks into the same use case, not as a separate pass.
The renewal pitch contradicts what got said at QBR. Have the Agent reference prior commitments from CRM notes before drafting.
# Customer Support
Source: https://relevanceai.com/docs/guides/customer-support/getting-started
Put AI Agents to work across the support queue — triage, drafting, knowledge — so agents handle the cases that need a human.
Support teams are buried in repetitive volume that's faster to answer than to escalate. AI Agents take the routine — triaging tickets, drafting first replies, generating knowledge base articles from resolved cases — so human agents handle the cases that need judgment.
## Start with a Marketplace template
The Marketplace ships pre-built Agents you can clone in one click. Adapt them to your products, your tone of voice, your escalation rules. Or [build a custom Agent from scratch](/docs/build/introduction).
Answers customer questions from your knowledge base — useful for first-response drafts and self-serve flows.
Classifies tickets into billing / technical / account / feature / bug and assigns P1–P4 priority on the way in.
The full catalog of Agents — ticket triage, response drafting, KB management, escalation routing.
Click **Clone Agent** on any listing, connect your support tools (Zendesk / Intercom / Salesforce Service Cloud), and run on a real ticket.
## Pick your path
How hands-on do you want to be? Pick a tab — the rest of the page is written for you.
You don't need to touch the builder. Open the cloned Agent above, ask in plain English, and let it work across the systems it's connected to.
## Sharpen the answers with knowledge
Upload your support playbook, tone-of-voice doc, escalation rules, and knowledge base articles. Every conversation references them — sharper output, no new setup.
Upload context once. Every conversation references it.
## Make it run on its own
When the same kinds of tickets keep landing, set a trigger — every billing question gets first-touch drafted, every refund request gets routed to the right team. One toggle, no code, no builder.
Schedule runs, fire on ticket events, listen to webhooks.
## Ready to go further?
When prompting and templates stop being enough — when you want the Agent to follow your playbook word for word and orchestrate triage across channels — pick the **Build visually** tab above.
You're comfortable in product UIs. You don't want to wire up an Agent from scratch, but you do want it to follow your support playbook ticket by ticket. Open the cloned Agent in the builder and shape every piece.
## Connect the tools it needs
Support Agents work best when they can read from and write to the systems your team already uses.
* **Ticketing** — [Zendesk](/docs/integrations/popular-integrations/zendesk), Intercom, or Salesforce Service Cloud for tickets and case history
* **Knowledge base** — your KB system for citation-grounded responses
* **CRM** — [HubSpot](/docs/integrations/popular-integrations/hubspot) or [Salesforce](/docs/integrations/popular-integrations/salesforce) for customer context
* **Comms** — [Gmail](/docs/integrations/popular-integrations/gmail), [Slack](/docs/integrations/popular-integrations/slack) for follow-up and internal escalation
See more about [Integrations](/docs/integrations/introduction).
## Shape every surface
Each piece below changes how the Agent behaves. Run it on a real ticket between every change — small iterations beat big rewrites.
Edit the system prompt to match your tone, your escalation rules, your tier-1 boundary.
Add or remove the actions the Agent can take — search the KB, query the CRM, draft replies, route tickets.
Upload your KB articles, support playbook, and tone-of-voice guides. The Agent draws on these in every reply.
Run the Agent automatically — on every new ticket, on tag updates, on SLA breaches.
Get notified when CSAT drops, when an SLA is at risk, when an escalation pattern emerges.
Persistent context per customer — past tickets, known account context, prior resolutions.
## Chain Agents into a workforce
When a single Agent isn't enough — triage, then draft, then update the CRM, then notify the team — wire them on the Workforce canvas.
Drag, connect, and run multi-Agent pipelines without code.
## Test before you trust
Set up evals so regressions in tone or accuracy get caught before the Agent replies to a customer.
Define test cases in the UI. Run them on every change.
## Ready to go further?
When clicking through the builder starts to feel slow — when you'd rather have your AI coding assistant build and edit Agents for you, drop into custom Python or JS code blocks, or call Agents from your own app via the SDK — pick the **Build with AI** tab above.
You already work in an AI coding environment. Clicking through a UI to edit response templates feels slow. Have your AI assistant build, shape, and orchestrate Agents directly from your editor.
## MCP & Plugins
Connect your AI coding environment to Relevance AI over MCP. Describe what you want in natural language; your AI assistant reads and writes your Relevance workspace — system prompts, Tools, knowledge, triggers, workforces, evals.
The fastest setup. Install the Relevance AI plugin and build Agents from your terminal.
Connect from Claude Desktop, Cursor, VS Code, ChatGPT, OpenAI Codex, or any MCP client.
Clone the skills repo so your coding assistant has built-in knowledge of Relevance patterns.
The full reference for what you can do programmatically.
## The four levels in support
How the [autonomy ladder](/docs/guides) plays out across the support queue:
An agent opens a ticket and asks the Agent to summarize the customer's history and suggest a reply — the Agent returns context with a draft response.
An agent reviews a batch of new tickets — the Agent has already drafted replies and triage suggestions, the agent approves and sends.
A new ticket lands → triaged, tagged, routed, first-reply drafted and auto-sent on simple cases, all without an agent touching the queue.
You set the objective — "cut time-to-first-response" — and the Workforce triages, drafts, and routes, with its triage and template criteria tuned through evals as CSAT outcomes flow back.
## Zoom into a single use case
Each use case below is a working entry point — clone a template, then run it, shape it visually, or build with AI depending on which tab fit you.
Classify, tag, and route every inbound ticket so the right agent picks it up first.
First-draft replies grounded in your knowledge base, with citations so the agent can spot-check.
Turn resolved tickets into knowledge base articles — close the loop without writing them by hand.
## See it in production
# KB article generation from resolved tickets
Source: https://relevanceai.com/docs/guides/customer-support/kb-generation
Turn resolved tickets into knowledge base articles — close the loop without writing them by hand.
Every support team has the same problem: the KB is the most leveraged thing in the operation, and it's the thing nobody has time to write. A KB Agent watches resolved tickets, spots the patterns worth documenting, and drafts the articles — so the next ticket of that shape gets a faster answer.
## When this pays off
New product features ship every sprint; the KB last got an article six months ago.
Agents answer the same niche question 30 times a quarter — and never have time to write the article.
Senior agents know the answers; new hires don't, because nobody documented them.
Customer self-serve traffic is low because there's no article matching their search.
## The shape of this use case
A KB Agent takes a resolved ticket (or cluster of tickets) and returns a publishable article.
Resolved ticket(s), category, prior similar resolutions, your KB style guide.
Ticket conversations, agent resolution notes, product changelog, your KB style and structure guides.
A drafted KB article — title, summary, steps, screenshots placeholders, related-articles links — ready for review.
Posted to your KB platform as a draft, dropped in [Notion](/docs/integrations/popular-integrations/notion) for review, queued in a "needs editor" workflow.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open **[Tim, Technical Documentation Generator](https://marketplace.relevanceai.com/listing/214b9ba5-7e83-4c54-8494-dcaed6557aeb)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"Look at the last 50 resolved tickets in the 'billing' category — what 3 articles should we write that we don't have?"*
* *"Turn this ticket into a KB article. Customer hit the SSO bug last week and we resolved with workaround X."*
* *"What's the most common search query on our help site this month that has no matching article?"*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your style guide in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed read and deflection data back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so it drafts the formats that help.
## Common pitfalls
Drafting from a single ticket gives you an article that only solves that exact case. Cluster similar tickets first so the article generalizes.
Auto-drafting without checking existing articles produces overlap and contradiction. Have the Agent search the KB first and propose an *edit* if an article already covers it.
KB articles are externally visible — bad ones cost trust. Always gate publishing with a human editor until you've watched it for two quarters.
Drafting articles agents *would have used* is fine, but missing the bigger win: articles for what customers *search and can't find*. Connect the Agent to KB search analytics.
# Response drafting from KB
Source: https://relevanceai.com/docs/guides/customer-support/response-drafting
First-draft replies grounded in your knowledge base, with citations so the agent can spot-check before sending.
The fastest support team isn't the one with the most agents — it's the one whose agents don't start replies from a blank page. A response Agent drafts the first reply for every ticket, pulling the right KB articles, the right account context, the right tone. The agent edits, sends, and moves on.
## When this pays off
The same 20 question types make up 70% of inbound. Agents type the same answer with slight variation, all day.
You've got a knowledge base but tickets get answered from agent memory — and the KB grows stale.
Tone varies wildly between new hires and tenured agents — customer experience is uneven.
New agents take weeks to become productive because there's no fast path to "right answer + right voice".
## The shape of this use case
A response Agent takes a ticket and returns a drafted reply with citations.
Ticket body, customer record, prior tickets, channel-specific format hints.
Knowledge base, prior resolutions, tone-of-voice guide, product status / changelog, account history.
A drafted reply with cited KB articles and a confidence indicator — ready for agent review and send.
Inserted as a draft in [Zendesk](/docs/integrations/popular-integrations/zendesk) / Intercom for agent review, posted in a comment for visibility, attached as a macro suggestion.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Customer Query Handler](https://marketplace.relevanceai.com/listing/5dc6f8ea-a087-4f7f-a053-5870d9292891)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"Draft a reply to this ticket — the customer can't activate their account and we've seen this before with their email domain."*
* *"What's our standard response when someone asks about the new billing cycle? Cite the KB articles."*
* *"Customer is asking for a refund — what's the playbook and what should I check first?"*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your KB in [Knowledge](/docs/build/knowledge/create-knowledge), and [Tools](/docs/build/agents/build-your-agent/tools) for KB and CRM search.
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed back which drafts shipped untouched, plus CSAT, into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so it matches what your team sends.
## Common pitfalls
If agents are rewriting every draft, the Agent isn't actually saving time — it's adding a step. Watch the edit-rate; rebuild the prompt or Knowledge if it climbs.
The Agent cites articles that don't exist or fabricates policy. Force citations to KB IDs from your actual catalog and fail visibly when there's no match.
Without a strong tone-of-voice doc, every draft sounds like the same chatbot. Upload your best past replies as examples in Knowledge.
Auto-sending replies before you've watched the Agent on real tickets for a month is how you ship a bad answer at scale. Start with drafts only.
# Ticket triage and routing
Source: https://relevanceai.com/docs/guides/customer-support/ticket-triage
Classify, tag, and route every inbound ticket so the right agent picks it up first.
The first 30 seconds of a ticket's life shapes its whole trajectory. If it's mis-tagged, mis-routed, or lands in the wrong queue, response time blows out. A triage Agent reads each inbound ticket the moment it lands and tags, prioritizes, and routes it so the right human picks it up.
## When this pays off
A lead or senior agent spends an hour every morning reading and routing the overnight backlog.
Tickets sit in the wrong queue for hours before someone re-routes them.
Tags differ across agents, so reporting and trend analysis are unreliable.
High-value account issues sit in the general queue because nobody flagged them.
## The shape of this use case
A triage Agent takes an inbound ticket and returns a structured classification.
Ticket body, subject, channel (email / chat / form), customer record, prior tickets.
CRM for account context, prior tickets for pattern matching, your taxonomy / tag library, SLA / VIP rules.
Classification (category, priority, urgency), tags, recommended queue and assignee, with reasoning.
Applied directly in [Zendesk](/docs/integrations/popular-integrations/zendesk) / Intercom / Service Cloud, posted to [Slack](/docs/integrations/popular-integrations/slack) for VIP escalations, written to a triage log for review.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open **[Customer Support Categorization](https://marketplace.relevanceai.com/listing/bffa15a4-5d7c-4408-82a0-6a09fa3d02a9)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"How would you triage this ticket? Customer is on Enterprise tier, ticket mentions a billing error and a feature outage."*
* *"Walk me through these 10 overnight tickets — what should we pick up first and why?"*
* *"Is this a P1? Customer says 'urgent' but the issue is a typo in our marketing site."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed resolved-ticket outcomes back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so its triage tracks what actually held up.
## Common pitfalls
The Agent invents new tags rather than using your existing taxonomy. Force the prompt to choose from a fixed Knowledge list — and fail closed if no tag fits.
The Agent marks every "urgent"-flagged email as P1. Train it to read the actual issue against your priority matrix, not the customer's adjective.
Tickets get routed by topic only and miss the account dimension — a P3 from a churning enterprise account isn't a P3. Pull CRM context into the triage prompt.
A wrong tag at scale corrupts reporting and routing. Start with Agent-as-suggester (writes to a "suggested\_priority" field) and graduate to direct application after a quarter of audit.
# Campaign performance analytics
Source: https://relevanceai.com/docs/guides/marketing/campaign-analytics
Pull cross-channel campaign reports together and surface what's working — without hours of spreadsheet wrangling.
Performance data lives in seven tools. The weekly campaign review takes someone half a day to pull together and another half day to translate into insight. A campaign analytics Agent does the pulling and the translating — so the review meeting starts with answers, not data hunting.
## When this pays off
Pulling Google Ads + HubSpot + LinkedIn + GA into one slide takes the same person, the same way, every Monday.
You know spend by channel but not what each channel is actually doing for the funnel.
Was this campaign better than the last one? Nobody can answer without an hour of cross-referencing.
The CMO wants a Friday "what worked, what didn't" — and it always slips because it's not anyone's job.
## The shape of this use case
A campaign analytics Agent takes a time window + campaign set and returns a report with reasoning.
Time window, campaign set (specific campaigns or all), channels to include, segmentation cuts.
Marketing automation ([HubSpot](/docs/integrations/popular-integrations/hubspot), [Marketo](/docs/integrations/popular-integrations/marketo)), ad platforms (Google, Meta, [LinkedIn](/docs/integrations/popular-integrations/linkedin)), web analytics, CRM, your own benchmark docs.
A digest — top performers, underperformers, key shifts vs. last period, suggested actions — with cited data and reasoning.
Posted to [Slack](/docs/integrations/popular-integrations/slack), written to a [Notion](/docs/integrations/popular-integrations/notion) page for the team review, emailed to the CMO Friday morning.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Email Marketing Strategist](https://marketplace.relevanceai.com/listing/28783038-03f0-4aec-9c76-4b28452b6e33)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"Pull last week's campaign performance from HubSpot and Google Ads — top 3 winners, top 3 losers, with reasons."*
* *"Compare the Q3 onboarding sequence against Q2 — what shifted in open and click rates?"*
* *"Which channels drove qualified pipeline last month? Cite the data."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), KPI definitions in [Knowledge](/docs/build/knowledge/create-knowledge), and [Tools](/docs/build/agents/build-your-agent/tools) to query each platform.
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Weight the Agent's [evals](/docs/build/agents/build-your-agent/evals) toward the metrics that actually predicted pipeline.
## Common pitfalls
A wall of numbers in Slack isn't useful. Force the Agent to explain *why* metrics moved and *what to do* — not just *what they are*.
HubSpot's "campaign" and your ad platform's "campaign" probably aren't the same thing. Define attribution rules in Knowledge once and reference them every time.
Without baselines, every CTR looks normal. Upload your historical benchmarks to Knowledge so the Agent flags actual outliers.
Ad platforms can lag 24-48 hours. Have the Agent disclose data freshness in the report so the team knows what's preliminary.
# Content creation and repurposing
Source: https://relevanceai.com/docs/guides/marketing/content-repurposing
Turn one piece of content into many — blog posts, social snippets, ad copy, email teasers — without losing the source voice.
Every long-form asset is supposed to become a quarter's worth of derivative content. In practice, the blog goes up, the webinar drops, and the LinkedIn posts never get written. A content Agent turns one source asset into channel-specific drafts — pulling your brand voice and past top-performers from knowledge, then queuing each derivative for review before it ships.
## When this pays off
Long-form is published; the social/email/ad versions are sitting in a Slack channel labeled "todo".
Every channel needs its own voice — copying the headline into Twitter doesn't work. Manual rewrites take hours per asset.
Hours of recorded content with no repurposing — clips, summaries, follow-up emails are all theoretically going to happen.
A product launch needs 30+ derivative pieces and the content team has time for 5.
## The shape of this use case
A content Agent takes a source asset + target formats and returns ready-to-publish derivatives.
Source asset (blog, webinar transcript, video, whitepaper), target channels and formats, campaign goal.
Brand voice docs, channel-specific style guides, past top-performing posts per channel.
A bundle of derivatives — blog posts, LinkedIn carousels, X threads, email teasers, ad copy variations — each tuned to its channel.
Posted to [Notion](/docs/integrations/popular-integrations/notion) or a content doc for review, drafted into your scheduler (Buffer / Hootsuite), pushed to ad platforms via integration.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Simple Content Repurposer](https://marketplace.relevanceai.com/listing/870991de-99fd-4453-83bf-084c872e7cb2)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"Turn this blog post into 5 LinkedIn posts, 3 X threads, and a teaser email. Match our voice — direct, no hype."*
* *"Pull the 4 strongest quotes from this webinar transcript and write them as standalone social posts."*
* *"Take this product launch one-pager and give me 10 ad headline variations for paid social."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your brand voice in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed channel engagement back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so it leans on what performed.
## Common pitfalls
LinkedIn voice, X voice, and email voice are different. Upload per-channel style guides and force the prompt to reference them, otherwise everything ends up sounding LinkedIn-flavored.
Generated content that goes live without a human read is how brand misfires happen. Keep marketing review gates until you've watched a quarter of output.
"Turn this blog into a tweet thread" produces something forgettable without strong style references. Show the Agent your best past threads, not just the source asset.
Heavy rewriting can flatten the original author's perspective. If the source is a guest post or executive POV, prompt the Agent to preserve the speaker's voice in derivatives.
# Marketing
Source: https://relevanceai.com/docs/guides/marketing/getting-started
Put AI Agents to work across the marketing funnel — content, campaigns, analytics — without losing your brand voice.
Marketing teams are stretched across channels. AI Agents take the high-volume execution work — drafting nurture sequences, repurposing content, pulling cross-channel reports — so marketers can spend their time on strategy and storytelling.
## Start with a Marketplace template
The Marketplace ships pre-built Agents you can clone in one click. Adapt them to your brand voice, your channels, your funnel. Or [build a custom Agent from scratch](/docs/build/introduction).
Analyzes campaign performance, optimizes subject lines, segments audiences, drafts copy, and plans A/B tests.
Paste a YouTube link, podcast episode, or blog URL → get platform-native LinkedIn and X posts drafted in your voice.
The full catalog of Marketing-relevant Agents — content, social, analytics, lifecycle.
Click **Clone Agent** on any listing, connect the channels it needs (email, social, web analytics), and run it on real campaign data.
## Pick your path
How hands-on do you want to be? Pick a tab — the rest of the page is written for you.
You don't need to touch the builder. Open the cloned Agent above, ask in plain English, and let it work across the channels it's connected to.
## Sharpen the answers with knowledge
Upload your brand guidelines, tone-of-voice doc, ICP definitions, and messaging frameworks. Every conversation references them — sharper output, no new setup.
Upload context once. Every conversation references it.
## Make it run on its own
When you find yourself drafting the same campaign every month, set a trigger — every new MQL gets the onboarding sequence drafted, every product launch triggers a content repurposing pass. One toggle, no code, no builder.
Schedule runs, fire on CRM events, listen to webhooks.
## Ready to go further?
When prompting and templates stop being enough — when you want the Agent to follow your brand voice word for word and orchestrate multi-step campaign automation — pick the **Build visually** tab above.
You're comfortable in product UIs. You don't want to wire up an Agent from scratch, but you do want it to sound like your brand and follow your campaign cadence. Open the cloned Agent in the builder and shape every piece.
## Connect the tools it needs
Marketing Agents work best when they can read from and write to the systems your team already uses.
* **Marketing automation** — [HubSpot](/docs/integrations/popular-integrations/hubspot) or [Marketo](/docs/integrations/popular-integrations/marketo) for campaigns and lifecycle
* **Email** — [Gmail](/docs/integrations/popular-integrations/gmail) or [Outlook](/docs/integrations/popular-integrations/outlook) for outbound
* **Content & social** — [Notion](/docs/integrations/popular-integrations/notion), [Canva](/docs/integrations/popular-integrations/canva), [Slack](/docs/integrations/popular-integrations/slack) for content workflows
* **Analytics** — [Google Sheets](/docs/integrations/popular-integrations/google-sheets) or your BI tool for performance pulls
See more about [Integrations](/docs/integrations/introduction).
## Shape every surface
Each piece below changes how the Agent behaves. Run the Agent on a real campaign between every change — small iterations beat big rewrites.
Edit the system prompt to match your brand voice, segmentation logic, and approval rules.
Add or remove the actions the Agent can take — pull campaign data, draft email copy, post to Slack.
Upload brand guidelines, persona docs, top-performing past campaigns. The Agent draws on these whenever it works.
Run the Agent automatically — on a schedule, when an MQL enters HubSpot, when a campaign launches.
Get notified when CTR drops, when copy fails a brand check, when send caps approach.
Persistent context across campaigns — past performance, which segments responded to which hooks.
## Chain Agents into a workforce
When a single Agent isn't enough — research the audience, write the copy, schedule the send, post a recap — wire them together on the Workforce canvas.
Drag, connect, and run multi-Agent pipelines without code.
## Test before you trust
Set up evals so brand-voice regressions get caught before they ship to your list.
Define test cases in the UI. Run them on every change.
## Ready to go further?
When clicking through the builder starts to feel slow — when you'd rather have your AI coding assistant build and edit Agents for you, drop into custom Python or JS code blocks, or call Agents from your own app via the SDK — pick the **Build with AI** tab above.
You already work in an AI coding environment. Clicking through a UI to edit copy guidelines feels slow. Have your AI assistant build, shape, and orchestrate Agents directly from your editor.
## MCP & Plugins
Connect your AI coding environment to Relevance AI over MCP. Describe what you want in natural language; your AI assistant reads and writes your Relevance workspace — system prompts, Tools, knowledge, triggers, workforces, evals.
The fastest setup. Install the Relevance AI plugin and build Agents from your terminal.
Connect from Claude Desktop, Cursor, VS Code, ChatGPT, OpenAI Codex, or any MCP client.
Clone the skills repo so your coding assistant has built-in knowledge of Relevance patterns.
The full reference for what you can do programmatically.
## The four levels in marketing
How the [autonomy ladder](/docs/guides) plays out across your funnel:
A marketer asks the Agent for three subject-line options for tomorrow's drop — the Agent returns options with reasoning.
A marketer asks for a 5-step onboarding sequence for new free-trial users — the Agent drafts all 5, the marketer reviews and queues.
A new MQL lands in HubSpot — segmentation, nurture-sequence drafting, and Slack alerts to the AE all happen automatically.
You set the objective — "increase trial-to-paid conversion" — and the Workforce runs onboarding sequences, with subject lines, send times, and CTAs tuned through evals as conversion data flows back.
## Zoom into a single use case
Each use case below is a working entry point — clone a template, then run it, shape it visually, or build with AI depending on which tab fit you.
Draft nurture, re-engagement, and onboarding sequences in your brand voice at the moments that matter.
Turn one asset into blog posts, social snippets, ad copy — without losing the source voice.
Pull cross-channel reports together; surface what's working and what isn't.
## See it in production
# Lifecycle email campaigns
Source: https://relevanceai.com/docs/guides/marketing/lifecycle-campaigns
Draft nurture, re-engagement, and onboarding sequences in your brand voice at the moments that matter.
Lifecycle email is the workhorse of B2B marketing — and the place that scales worst with headcount. A lifecycle Agent drafts the sequences that match each segment, lifecycle stage, and trigger so you can run more campaigns without copying templates into Google Docs.
## When this pays off
You're copy-pasting "Welcome Series v3" docs between every product launch instead of running per-launch sequences.
Trial ending, contract renewing, feature unused — these moments deserve sequences and currently get nothing.
Different team members write each campaign and the voice has slipped across them.
A dormant-list re-engagement campaign keeps getting deprioritized because the copy work is the bottleneck.
## The shape of this use case
A lifecycle Agent takes a segment + trigger and returns a multi-step email sequence in your voice.
Segment definition, lifecycle stage, triggering event, campaign goal.
Brand voice docs, past-campaign copy, persona definitions, product positioning, your marketing automation platform.
A drafted sequence — subject lines, body copy, send timing, CTA per step — ready for review.
Drafted into [HubSpot](/docs/integrations/popular-integrations/hubspot) or [Marketo](/docs/integrations/popular-integrations/marketo) for review, written to a doc for marketing approval, queued in your ESP.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Email Marketing Strategist](https://marketplace.relevanceai.com/listing/28783038-03f0-4aec-9c76-4b28452b6e33)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"Draft a 4-step welcome series for new free-trial users in HubSpot — friendly tone, focus on activating the dashboard feature."*
* *"Write a re-engagement sequence for trial users who haven't logged in for 30 days."*
* *"Give me a 3-touch renewal sequence for accounts in the 90-day renewal window."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your brand voice in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed opens, clicks, and conversion back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so drafts track what converts.
## Common pitfalls
Without persona-specific Knowledge, every sequence reads like a watered-down version of the welcome email. Upload distinct persona docs and force the prompt to reference them.
The HubSpot trigger fires on the wrong field and the sequence drafts the wrong campaign. Gate triggers tightly and review what actually causes them to fire in week one.
A prompt tweak changes tone everywhere. Use [evals](/docs/build/agents/build-your-agent/evals) on a few canonical drafts to catch drift before it ships to subscribers.
Tempting to skip marketing approval and queue directly. Don't — one bad subject line in production costs trust. Gate L3 with a Slack approval until you've watched it run for a quarter.
# Data dedup and cleanup
Source: https://relevanceai.com/docs/guides/revops/data-dedup
Find and merge duplicate records, fix inconsistent fields, surface the records that need a human.
CRMs accrete duplicate records the way oceans accrete plastic. The exact-match dedup is easy; the fuzzy cases — "Acme Corp" vs "Acme Corporation" vs "Acme Inc" — eat hours of RevOps time. A dedup Agent does the fuzzy matching with reasoning, merges what's safe, and surfaces the ambiguous cases for a human to decide.
## When this pays off
Sales operations reports keep getting flagged because the same company exists under three names.
Each quarter, someone spends a day or two going through dedup candidates and merging by hand.
Even when records get merged, field-level conflicts (which address? which industry?) get resolved arbitrarily.
A wrong merge wipes deal history; teams stop trusting the dedup process and the queue grows.
## The shape of this use case
A dedup Agent takes a candidate pair (or a list of candidates) and returns a merge decision with reasoning.
Candidate records, full field-level data, related activity / deal history.
CRM, your dedup heuristics / playbook, parent-child hierarchy, third-party data for ground-truth checks.
A decision (merge / keep separate / human review) with confidence, plus field-level conflict resolution recommendations.
High-confidence merges applied directly (with audit log); ambiguous cases queued in a review tool or posted to RevOps [Slack](/docs/integrations/popular-integrations/slack).
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[CRM Agent](https://marketplace.relevanceai.com/listing/f3e18700-27e2-477d-8eaa-4c6fa04282bf)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"These two HubSpot accounts both look like Acme Corp — are they the same company? Compare addresses, websites, contact overlap."*
* *"Run dedup on the leads imported from this trade-show CSV — flag the high-confidence matches and the ones I should look at."*
* *"Did we already have a record for this contact? Check across CRM and prior tickets."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your matching rules in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed merge undos and disputes back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so its confidence thresholds track what's reliable.
## Common pitfalls
A wrong merge loses deal history. Always log what got merged and offer one-click undo for the first quarter of running.
Aggressive auto-merge merges records that should have stayed separate. Start with high thresholds and loosen as you watch outcomes.
Merging accounts without a rule for which address / industry / size wins produces garbled records. Document field priority rules in Knowledge.
Merging an account with an active opportunity into one without can break attribution and rep ownership. Have the Agent factor open-deal status into the decision.
# RevOps
Source: https://relevanceai.com/docs/guides/revops/getting-started
Put AI Agents to work across revenue operations — pipeline hygiene, routing, forecasting — so the GTM machine actually runs on clean data.
RevOps owns the systems that everyone else depends on. Data hygiene, routing rules, pipeline reviews, forecast accuracy — all of it gets done manually because the rules are too edge-casey to hard-code. AI Agents handle the judgment-y middle ground: clear enough to automate, fuzzy enough that hard rules break.
## Start with a Marketplace template
The Marketplace ships pre-built Agents you can clone in one click. Adapt them to your CRM, your segmentation, your pipeline definitions. Or [build a custom Agent from scratch](/docs/build/introduction).
Fills in firmographics, contact details, and job-function classification on every record — the foundation for everything else.
Takes a LinkedIn profile or CRM record, researches the company, and returns a qualification read you can wire into routing.
The full catalog of Agents — enrichment, routing, forecasting, data hygiene.
Click **Clone Agent** on any listing, connect your CRM and data sources, and run on real records.
## Pick your path
How hands-on do you want to be? Pick a tab — the rest of the page is written for you.
You don't need to touch the builder. Open the cloned Agent above, ask in plain English, and let it work across the systems it's connected to.
## Sharpen the answers with knowledge
Upload your ICP definitions, segmentation rules, routing logic, and pipeline definitions. Every conversation references them — sharper output, no new setup.
Upload context once. Every conversation references it.
## Make it run on its own
When you're answering the same data-quality or routing question every week, set a trigger — every new account auto-enriches, every stale record auto-flags. One toggle, no code, no builder.
Schedule runs, fire on CRM events, listen to webhooks.
## Ready to go further?
When prompting and templates stop being enough — when you want the Agent to enforce your routing rules across the whole pipeline and orchestrate cross-system workflows — pick the **Build visually** tab above.
You're comfortable in product UIs. You don't want to wire up an Agent from scratch, but you do want it to enforce your routing logic record by record. Open the cloned Agent in the builder and shape every piece.
## Connect the tools it needs
RevOps Agents work best when they can read from and write to the systems your team already uses.
* **CRM** — [HubSpot](/docs/integrations/popular-integrations/hubspot) or [Salesforce](/docs/integrations/popular-integrations/salesforce) — the system of record
* **Data sources** — [Apollo](/docs/integrations/popular-integrations/apollo), [ZoomInfo](/docs/integrations/popular-integrations/zoominfo), web search for enrichment
* **BI / analytics** — [Google Sheets](/docs/integrations/popular-integrations/google-sheets) or your warehouse for pipeline reporting
* **Comms** — [Slack](/docs/integrations/popular-integrations/slack), [Gmail](/docs/integrations/popular-integrations/gmail) for alerts and ops notifications
See more about [Integrations](/docs/integrations/introduction).
## Shape every surface
Each piece below changes how the Agent behaves. Run it on a small record set between every change — small iterations beat big rewrites.
Edit the system prompt to match your ICP, segmentation, routing rules, and pipeline definitions.
Add or remove the actions the Agent can take — query CRM, enrich from third-party data, write back fields, post to Slack.
Upload ICP, territory definitions, routing logic, pipeline schemas. The Agent draws on these whenever it works.
Run the Agent automatically — on record create, on stage change, on a freshness schedule.
Get notified when routing rules conflict, when forecast accuracy drifts, when dedup confidence is low.
Persistent context per record — past routing decisions, prior enrichment sources, change history.
## Chain Agents into a workforce
When a single Agent isn't enough — enrich, then score, then route, then notify — wire them together on the Workforce canvas.
Drag, connect, and run multi-Agent pipelines without code.
## Test before you trust
Set up evals so routing or enrichment regressions get caught before they propagate across thousands of records.
Define test cases in the UI. Run them on every change.
## Ready to go further?
When clicking through the builder starts to feel slow — when you'd rather have your AI coding assistant build and edit Agents for you, drop into custom Python or JS code blocks, or call Agents from your own app via the SDK — pick the **Build with AI** tab above.
You already work in an AI coding environment. Clicking through a UI to edit routing rules feels slow. Have your AI assistant build, shape, and orchestrate Agents directly from your editor.
## MCP & Plugins
Connect your AI coding environment to Relevance AI over MCP. Describe what you want in natural language; your AI assistant reads and writes your Relevance workspace — system prompts, Tools, knowledge, triggers, workforces, evals.
The fastest setup. Install the Relevance AI plugin and build Agents from your terminal.
Connect from Claude Desktop, Cursor, VS Code, ChatGPT, OpenAI Codex, or any MCP client.
Clone the skills repo so your coding assistant has built-in knowledge of Relevance patterns.
The full reference for what you can do programmatically.
## The four levels in revenue operations
How the [autonomy ladder](/docs/guides) plays out across your pipeline:
A RevOps analyst asks the Agent which accounts in the new MQL batch look like a fit for the enterprise team — the Agent returns a list with reasoning.
A RevOps analyst asks the Agent to dedupe a list of 1,200 imported leads — the Agent flags clusters with merge recommendations, the analyst approves the merges.
A new lead enters the CRM → enriched, scored, routed to the right rep, posted to Slack, all without anyone touching it.
You set the objective — "improve forecast accuracy" — and the Workforce enriches, scores, and routes, with its deal-signal criteria tuned through evals as close-vs-slip outcomes flow back.
## Zoom into a single use case
Each use case below is a working entry point — clone a template, then run it, shape it visually, or build with AI depending on which tab fit you.
Spot stalled deals, missing fields, and at-risk forecast slippage before pipeline review.
Apply your routing rules — plus the judgment edge cases — to every new lead automatically.
Find and merge duplicates, fix inconsistent fields, surface the records that need a human.
For account-level enrichment, see the [CRM data enrichment](/docs/guides/sales/crm-data-enrichment) use case in Sales — same shape, applies cleanly to RevOps use. For scoring inbound, see [Lead scoring](/docs/guides/sales/lead-scoring).
## See it in production
# Lead routing and territory assignment
Source: https://relevanceai.com/docs/guides/revops/lead-routing
Apply your routing rules — plus the judgment edge cases — to every new lead automatically.
Routing rules in Salesforce or HubSpot handle 80% of inbound leads. The other 20% are the edge cases that eat hours — accounts spanning multiple territories, ambiguous industries, parent-child company tangles, region overrides. A routing Agent reads each lead, applies your rules where they're clear, and handles the judgment where they aren't.
## When this pays off
Existing logic handles the easy 80%; the rest end up in a queue waiting for RevOps to manually route.
Reps argue over who owns a lead because firmographic data disagrees about region or segment.
Hours pass between lead landing and lead getting picked up because manual routing is the bottleneck.
A new contact at a subsidiary lands without recognizing the parent already has an open opportunity.
## The shape of this use case
A routing Agent takes a new lead and returns an assignment decision with reasoning.
Lead record, account context, territory boundaries, current rep workload.
CRM, territory / segmentation rules, rep capacity data, parent-child account hierarchy, your routing playbook.
A routing decision (rep / team, reasoning, confidence), with flags for edge cases that need human review.
Applied directly in the CRM as owner, posted to [Slack](/docs/integrations/popular-integrations/slack) on edge cases for RevOps to confirm, logged with reasoning for audit.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[CRM Agent](https://marketplace.relevanceai.com/listing/f3e18700-27e2-477d-8eaa-4c6fa04282bf)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"Where should this lead go? Acme Corp, contact at the German subsidiary, parent account owned by the US enterprise team."*
* *"This batch of 50 leads imported from a trade show — apply our routing rules and tell me which ones need a human decision."*
* *"Is this lead a re-engagement of an existing opportunity or a new prospect? Check parent-child and prior history."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your territory rules in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed back which routing held up into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so edge-case handling tracks real outcomes.
## Common pitfalls
Force the Agent to flag low-confidence decisions for human review rather than making a guess. Wrong assignments are expensive to undo.
Without hierarchy data in Knowledge, the Agent treats subsidiaries as net-new accounts. Document the parent-child structure explicitly.
Routing on rules alone overloads top reps. Have the Agent factor current pipeline volume into the routing decision.
Reps dispute routing decisions. Log every Agent decision with its reasoning so you can review later.
# Pipeline forecasting and hygiene
Source: https://relevanceai.com/docs/guides/revops/pipeline-hygiene
Spot stalled deals, missing fields, and at-risk forecast slippage before pipeline review.
The Monday pipeline review depends on data that's only as fresh as the rep updated it on Friday — which is to say, not very. A pipeline Agent reads the whole pipeline state, flags what's stalled, what's missing, what's likely to slip, and surfaces the gaps so the review actually starts with reality.
## When this pays off
Half the deals in pipeline haven't been touched in 30 days; reps update only when forced.
Commit vs. close-rate gap grows quarter over quarter — leadership stops trusting the forecast.
The first 20 minutes of every pipeline review is reps explaining missing data.
Deals slip the week before the quarter ends — when it's too late to do anything.
## The shape of this use case
A pipeline Agent takes a pipeline snapshot and returns a structured analysis with flags.
Pipeline state (deals, stages, dates, amounts), historical close-rate benchmarks, your forecast definitions.
CRM, prior quarter close data, deal activity logs, your sales methodology / MEDDICC framework.
A pipeline brief — stalled deals, missing critical fields, slippage risk per deal, forecast vs. commit gap with reasoning.
Posted to [Slack](/docs/integrations/popular-integrations/slack) ahead of pipeline review, written to a [Notion](/docs/integrations/popular-integrations/notion) ops doc, surfaced as deal-level alerts to AEs.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Deal Health Analyst](https://marketplace.relevanceai.com/listing/5ecd3c3f-73ba-4f08-877c-bb68dde05387)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your team can use on day one:
* *"What deals look at-risk for Q3? Pull stalled deals, missing close dates, and weak MEDDICC scores."*
* *"Compare this week's commit vs. last quarter's commit-vs-close at the same point in the cycle — are we tracking?"*
* *"Which 10 deals should the team focus on this week to hit number?"*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your methodology in [Knowledge](/docs/build/knowledge/create-knowledge), and [Tools](/docs/build/agents/build-your-agent/tools) to query the CRM.
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed back which at-risk signals predicted slippage into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so flagging sharpens.
## Common pitfalls
If the Agent flags every deal as "at risk", the team stops reading. Tighten criteria to what actually predicts slippage.
Without piping won/lost / slipped outcomes back to the Agent's evals, the criteria can't improve. Pipe deal outcomes to evaluations.
Pure field-based analysis misses what AEs hear on calls. Have the Agent read recent activity notes and pick up sentiment signals.
Letting the Agent overwrite stage or amount fields without rep review breaks trust and reporting. Surface recommendations; the rep changes the field.
# Competitive intelligence
Source: https://relevanceai.com/docs/guides/sales/competitive-intelligence
Track competitor moves and keep your team's positioning sharp.
Deals get lost when reps can't articulate how you compare. A competitive intelligence Agent monitors what competitors are doing and keeps your team's battle cards current — so reps walk into positioning conversations ready, not improvising.
## When this pays off
The market is moving faster than your battle cards can keep up.
Battle cards exist but were last updated two quarters ago and nobody trusts them.
Win/loss reviews keep flagging the same competitor as the reason — and the same gaps.
Leadership wants a regular pulse on competitive activity for the GTM team.
## The shape of this use case
A competitive intelligence Agent monitors a defined competitor set and surfaces what matters.
Competitor list, products to compare, market segments you operate in.
Competitor websites, news, job boards, social media, your own win/loss notes.
Updated battle cards, product comparison summaries, weekly digests.
Posted to [Slack](/docs/integrations/popular-integrations/slack), written to your wiki or [Notion](/docs/integrations/popular-integrations/notion), attached to deal records when a competitor shows up.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Sales Battlecard Creator](https://marketplace.relevanceai.com/listing/ca29a93b-cca6-4238-95d0-84159c692241)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your reps can use on day one:
* *"What did Acme Corp announce last quarter? They came up on a call this morning."*
* *"Pull a quick comparison of our pricing vs. Globex for an exec on this deal."*
* *"Summarize where we stand against Initech for a renewal conversation tomorrow."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), [Knowledge](/docs/build/knowledge/create-knowledge), and [Firecrawl](/docs/build/tools/tool-steps/firecrawl) for competitor sites.
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed win/loss notes back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so it tracks the signals that matter.
## Common pitfalls
Twenty competitors equals alert fatigue and nothing gets read. Limit to the 5–10 that actually surface in deals.
Reps can't use a battle card mid-call if it's a webpage. Write them as short objection-handling scripts the rep can read in one breath.
A weekly digest is interesting. Resurfacing the right battle card the moment a competitor shows up in a deal is useful. Wire the Agent to deal records, not just channels.
Press releases only show you what competitors want you to see. Add hiring patterns, job postings, and customer-side social signals to catch real direction.
# CRM data enrichment
Source: https://relevanceai.com/docs/guides/sales/crm-data-enrichment
Fill in missing CRM fields automatically so reps stop wasting time looking up basics.
Incomplete CRM data slows everything down — reps waste time looking up basics, lead routing breaks, and reporting becomes unreliable. An enrichment Agent fills in the gaps automatically so your data stays clean without manual effort.
## When this pays off
Lead-routing logic depends on fields that are blank for half the records.
Industry and company-size data is inconsistent, so segmentation reports are useless.
Reps are pasting LinkedIn profile links into the CRM and calling it enrichment.
You're redefining your ICP and need to re-evaluate every existing record against the new lens.
## The shape of this use case
An enrichment Agent takes a partial CRM record and fills in missing fields.
Existing CRM record (contact or account) with partial data.
Web search, [LinkedIn](/docs/integrations/popular-integrations/linkedin), third-party data vendors, your own CRM history.
Filled-in fields — firmographics, contact details, tech stack, social profiles — with source attribution.
Written back to the CRM in the correct fields, with sourcing notes attached.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open **[Elli, the Enrichment Agent](https://marketplace.relevanceai.com/listing/88ab63e7-f357-48ad-84c6-463be16d850b)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your reps can use on day one:
* *"Enrich Acme Corp — fill in industry, employee count, and any recent news."*
* *"Find the head of RevOps at Initech and add them as a contact in HubSpot."*
* *"What tech stack is Globex running? Web search and check LinkedIn."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), a connected [CRM](/docs/integrations/popular-integrations/hubspot) for read/write, and rules in [Knowledge](/docs/build/knowledge/create-knowledge).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Tune it through [evals](/docs/build/agents/build-your-agent/evals) so it maintains the fields your team actually uses.
## Common pitfalls
Credit-burn at scale. Gate enrichment on lifecycle stage and a freshness window — don't re-enrich records that were updated last week.
A rep's hand-typed value usually beats whatever the web returns. Preserve human overrides, or write to a parallel "enriched\_\*" field that reports can choose to use.
Reps can't trust a value if they can't see where it came from. Have the Agent attach a source URL and timestamp to every enriched field.
Pulling 2019 data into a 2026 record looks like enrichment but isn't. Filter sources by recency where it matters — leadership, headcount, funding.
# Sales
Source: https://relevanceai.com/docs/guides/sales/getting-started
Put AI Agents to work across your sales pipeline. Start wherever you are — Relevance grows with you.
Hand the research, prep, and outreach grind to AI. Spend your time on the conversations that close deals.
## Start with a Marketplace template
The Marketplace ships pre-built sales Agents you can clone in one click. They're the starting point for every path below — run them as-is, shape them in the builder, or hand them to your AI coding assistant. Or skip the templates and [build a custom Agent from scratch](/docs/build/introduction).
Builds detailed call-prep briefs covering company, contacts, news, and pain points.
Writes personalized connection requests and follow-ups based on prospect research.
The full catalog of pre-built Agents across every use case and vertical.
Click **Clone Agent** on any listing, then connect the integrations it needs (CRM, email, web search). Run it on a real account to see it work.
## Pick your path
How hands-on do you want to be? Pick a tab — the rest of the page is written for you.
You don't need to touch the builder. Open the cloned Agent above, ask in plain English, and let it work across the integrations it's connected to.
## Sharpen the answers with knowledge
Upload ICP definitions, personas, and battle cards. Every conversation references them — sharper output, no new setup.
Upload context once. Every conversation references it.
## Make it run on its own
When you find yourself asking for the same thing every day, set a trigger on a cloned Agent — research every new lead, draft a brief before every meeting. One toggle, no code, no builder.
Schedule runs, fire on CRM events, listen to webhooks.
## Ready to go further?
When prompting and templates stop being enough — when you want the Agent to follow your team's exact playbook word for word — pick the **Build visually** tab above.
You're comfortable in product UIs. You don't want to wire up an Agent from scratch, but you do want it to sound like your team and follow your process. Open the cloned Agent above in the builder and shape every piece.
## Connect the tools it needs
Sales Agents work best when they can read from and write to the systems your team already uses.
* **CRM** — [HubSpot](/docs/integrations/popular-integrations/hubspot) or [Salesforce](/docs/integrations/popular-integrations/salesforce) for account data and activity logging
* **Email** — [Gmail](/docs/integrations/popular-integrations/gmail) or [Outlook](/docs/integrations/popular-integrations/outlook) for sending outreach
* **Prospecting** — [Apollo](/docs/integrations/popular-integrations/apollo) or [ZoomInfo](/docs/integrations/popular-integrations/zoominfo) for contact and firmographic data
See more about [Integrations](/docs/integrations/introduction). Start with your CRM and one outreach channel; add the rest as the workflow grows.
## Shape every surface
Each piece below changes how the Agent behaves. Run the Agent on a real account between every change — small iterations beat big rewrites.
The system prompt is the Agent's playbook. Edit it to match your tone, your qualification criteria, your escalation rules.
Add or remove the actions the Agent can take — search the web, query your CRM, send emails, run another Agent.
Upload ICP definitions, personas, battle cards, product one-pagers. The Agent references these whenever it works.
Run the Agent automatically — on a schedule, when a CRM record updates, when a webhook fires.
Get notified when the Agent hits a threshold or runs into an issue. Use the prompt to instruct it which cases to flag for human review.
Give the Agent persistent context across conversations — past interactions, account history, learned preferences.
## Chain Agents into a workforce
When a single Agent isn't enough — research, then enrich, then write outreach, then send — wire Agents together on the Workforce canvas.
Drag, connect, and run multi-Agent pipelines without code.
## Test before you trust
Once you're shaping prompts and tools, set up evals so you catch regressions before customers do.
Define test cases in the UI. Run them on every change.
## Ready to go further?
When clicking through the builder starts to feel slow — when you'd rather have your AI coding assistant build and edit Agents for you, drop into custom Python or JS code blocks, or call Agents from your own app via the SDK — pick the **Build with AI** tab above.
You already work in an AI coding environment. Clicking through a UI to edit a system prompt feels slow. Have your AI assistant build, shape, and orchestrate Agents directly from your editor.
## MCP & Plugins
Connect your AI coding environment to Relevance AI over MCP. Describe what you want in natural language; your AI assistant reads and writes your Relevance workspace — system prompts, Tools, knowledge, triggers, workforces, evals.
The fastest setup. Install the Relevance AI plugin and build Agents from your terminal.
Connect from Claude Desktop, Cursor, VS Code, ChatGPT, OpenAI Codex, or any MCP client.
Clone the skills repo so your coding assistant has built-in knowledge of Relevance patterns.
The full reference for what you can do programmatically.
## The four levels in sales
How the [autonomy ladder](/docs/guides) plays out across your pipeline:
A rep asks the Agent before a call — "research Acme Corp" — and gets a brief back.
A rep asks for 12 personalized LinkedIn messages — the Agent drafts all 12, the rep approves and sends.
A new lead lands in HubSpot — research, enrichment, outbound, and CRM logging all happen automatically. The rep sees the result, not the queue.
You set the objective — "increase qualified meetings from inbound" — and the Workforce researches, enriches, drafts outbound, and logs to the CRM, with its copy and qualification thresholds tuned through evals as results flow back.
## Zoom into a single use case
Each use case below is a working entry point — clone the template, then run it, shape it visually, or build with AI depending on which tab fit you.
Automate company and contact research before calls.
Generate tailored emails and LinkedIn messages at scale.
Qualify and prioritize inbound leads automatically.
Keep CRM records accurate and complete.
Generate structured call prep for every meeting.
Monitor competitors and surface insights for reps.
## See it in production
# Lead scoring
Source: https://relevanceai.com/docs/guides/sales/lead-scoring
Qualify and prioritize leads so reps spend their time on the accounts most likely to close.
Not every lead deserves the same effort. A scoring Agent evaluates incoming leads against your ICP and buying signals so reps focus on the accounts most likely to close — and disqualify the ones that won't.
## When this pays off
Leads are arriving faster than reps can manually triage them.
Reps are spending the same hour on a Fortune 500 prospect as a free-trial signup with no fit.
Marketing-qualified leads are sitting unrouted while marketing complains the funnel is broken.
You have an ICP doc but the team isn't applying it consistently across new leads.
## The shape of this use case
A scoring Agent takes a lead record and returns a qualification assessment.
CRM lead record, form-fill data, intent signals, web activity.
CRM, marketing automation, ICP and qualification framework in Knowledge, web search for missing context.
A score with a reasoning summary — not just a number — plus a recommended action.
Written back to the CRM as a field, posted to [Slack](/docs/integrations/popular-integrations/slack) for hot leads, used to auto-route to the right rep.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open **[Lia, the LinkedIn Lead Researcher & Qualifier](https://marketplace.relevanceai.com/listing/ba230945-e61a-4fb0-8c47-7e240f18456d)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your reps can use on day one:
* *"Score this lead — they came in from the pricing page yesterday. Is it worth a first call?"*
* *"Why did we lose Globex last quarter, and is this new account similar?"*
* *"Walk me through the top 10 new leads from this week and what to do with each."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your ICP in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule) to backfill.
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed closed-won and closed-lost outcomes back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so "qualified" tracks what closes.
## Common pitfalls
Thin CRM data produces unreliable scores. Enrich the record before you ask the Agent to judge it.
Reps stop using their own judgment if the number is treated as final. The score is an input — surface the reasoning so reps can override it.
If the ICP in Knowledge hasn't been touched in 18 months, the Agent is judging against last year's reality. Review it quarterly against actual close-won data.
Without won/lost deals flowing back into the scoring criteria, the model can't learn. Pipe deal outcomes back to the Agent's evals.
# Meeting briefs
Source: https://relevanceai.com/docs/guides/sales/meeting-briefs
Generate structured call prep so reps walk into every meeting already up to speed.
Reps shouldn't be scrambling for context five minutes before a call. A meeting brief Agent pulls together everything relevant about the account — recent conversations, deal history, company updates — into a snapshot a rep can scan in under a minute.
## When this pays off
Reps run meetings in sequence with no buffer to prep between them.
Account history lives across CRM, Slack, support tickets, and email — and key details get missed.
Reps joining mid-deal need to come up to speed without reading every email thread.
Leadership joins late-stage calls and needs the picture in two minutes, not twenty.
## The shape of this use case
A meeting brief Agent compiles a one-page snapshot of the account ahead of a scheduled call.
Calendar event — account, attendees, deal stage, meeting time.
CRM activity, past meeting notes, email threads, support tickets, company news.
A brief covering deal context, recent activity, company updates, and suggested talking points.
Emailed to the rep before the meeting, attached to the calendar event, or posted in [Slack](/docs/integrations/popular-integrations/slack).
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Pre-Meeting Prepper](https://marketplace.relevanceai.com/listing/e2bc9eb0-6afd-4e24-b2ba-16160259981a)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your reps can use on day one:
* *"What do I need to know about Acme Corp before my 3pm? Pull the last three emails and recent deal activity."*
* *"Summarize where we are with Globex — last call notes, open objections, next steps."*
* *"Who from Initech is on my calendar tomorrow and what should I prep on each of them?"*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), [Knowledge](/docs/build/knowledge/create-knowledge), and a connected CRM, email, and [calendar](/docs/integrations/popular-integrations/google-calendar).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed back which sections reps actually use into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so briefs sharpen over time.
## Common pitfalls
If the brief takes more than a minute to scan, reps stop reading. Cap section lengths in the prompt and force prioritization.
A brief that just regurgitates the CRM record isn't useful. The Agent has to surface what's *new* — last contact, last news, last ticket.
A discovery call and a renewal call need different briefs. Branch the prompt by meeting type or deal stage.
"2 open tickets" is data. "Two open critical tickets opened this week — both about billing" is a talking point. Have the Agent interpret, not just enumerate.
# Personalized outbound
Source: https://relevanceai.com/docs/guides/sales/personalized-outbound
Draft tailored emails and LinkedIn messages from real prospect context, then queue them for the rep to approve and send.
Generic outreach gets ignored. Hand-crafted messages get replies — but they don't scale to a list of 500 prospects. An outbound Agent reads each prospect's CRM and LinkedIn context, drafts a personalized message, and queues it for rep approval.
## When this pays off
SDRs running 100+ touches a week and personalization is collapsing into copy-paste.
The team is writing more emails and getting fewer replies — the messages stopped sounding different.
Reps only hand-personalize their A-list. Everyone else gets a template they're not happy with.
Email + LinkedIn + follow-up timing is breaking down because no human is orchestrating it.
## The shape of this use case
An outbound Agent takes a prospect and produces a message ready to send.
Prospect name, company, role, recent activity, CRM history.
CRM, [LinkedIn](/docs/integrations/popular-integrations/linkedin), web and news, your messaging playbooks, ICP and persona docs.
A drafted email or LinkedIn message tuned to that prospect, in your team's voice.
Queued in Gmail/Outlook, posted to LinkedIn, written to the CRM, or dropped in a rep's queue for review.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open **[LinkedIn Outreach & Follow up](https://marketplace.relevanceai.com/listing/5508c7f6-f3a7-4593-8faf-22fbecc4e0d4)** — or **[Outbound Composer](https://marketplace.relevanceai.com/listing/42f2cab0-71d6-41ca-b71e-fbaa55dfc53a)** for multi-variant email. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your reps can use on day one:
* *"Draft a LinkedIn DM to Sarah at Initech — she just got promoted to VP of Sales last month."*
* *"Write a follow-up email to Acme Corp referencing our last call notes in HubSpot."*
* *"Give me three subject line options for a re-engagement email to dormant trial users."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed reply and meeting rates back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so drafts work from what converts.
## Common pitfalls
Mentioning the company name doesn't count. The opening line has to reference something the prospect would only believe you noticed if you actually paid attention — a post, a launch, a role change.
Volume plus zero warm-up equals the spam folder. Use sending caps and a warm-up schedule on new domains.
If your reply rates flatline as volume grows, the Agent has converged on a template. Force structural variation in the prompt — different opens, different CTA placements.
Use [Alerts](/docs/build/agents/build-your-agent/alerts) to route messages for high-value accounts through human review before they send.
# Prospect research
Source: https://relevanceai.com/docs/guides/sales/prospect-research-use-case
Automate company and contact research so reps walk into every call already prepared.
Reps spend hours digging through LinkedIn, company websites, and news to prep for a single call. Relevance can produce the same brief in seconds — at whatever level of automation you're ready for.
## When this pays off
Reps run more than five discovery calls a week and prep is eating their selling time.
Some calls get deeply prepped, others get a quick scan — output quality is inconsistent.
Inbound leads need quick context before a rep is assigned.
Every meeting starts with the same baseline brief, not whatever the rep happens to find.
## The shape of this use case
A prospect research workflow takes a company name or contact and returns a structured brief.
Company domain, contact email, or CRM record.
Web search, [LinkedIn](/docs/integrations/popular-integrations/linkedin), news, your CRM, and any internal knowledge — ICP, personas, battle cards.
A brief covering company overview, recent news, key contacts, likely pain points, and conversation hooks.
Returned inline, posted to [Slack](/docs/integrations/popular-integrations/slack), written back to the CRM, or attached to a calendar event.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Sales Researcher](https://marketplace.relevanceai.com/listing/4b454347-0656-4fee-9c15-8fb2f2713424)** — or **[Lia](https://marketplace.relevanceai.com/listing/ba230945-e61a-4fb0-8c47-7e240f18456d)** for LinkedIn-first. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your reps can use on day one:
* *"Research Acme Corp ahead of my 2pm call. Pull recent news, the buyer's LinkedIn, and any open deals in HubSpot."*
* *"Summarize the last three meetings with Globex and what's still open."*
* *"Who at Initech should I be talking to if we're selling into RevOps?"*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed won-deal signals back into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so it tracks what closes.
## Common pitfalls
Gate the trigger on lifecycle stage so you don't burn credits re-researching closed-won customers.
Without an ICP or persona in knowledge, the output reads like a Wikipedia summary. Add the lens.
Set a freshness window — e.g. re-research only if the last brief is more than 30 days old — instead of regenerating on every interaction.
Web search returns whatever ranks, not what's true. Cite sources in the brief so reps can spot-check.
# Demo prep and pre-call briefs
Source: https://relevanceai.com/docs/guides/solution-engineering/demo-prep
Account-aware technical briefs the SE can read in five minutes before any call.
SEs walk into demos blind more often than they'd admit — they know the prospect's name and the deal size, not their tech stack, integration patterns, or what their team has been Googling. A demo-prep Agent builds the brief the SE wishes they had, every time.
## When this pays off
SEs run 4+ demos a day and prep blurs into the prior one.
The CRM has firmographics; the SE needs tech stack, scale, and likely integration patterns.
SEs use the same demo flow for every prospect because there's no time to tailor.
AE-to-SE deal handoffs lose detail. The SE rediscovers what the AE already learned.
## The shape of this use case
A demo-prep Agent takes a calendar event + opportunity and returns a structured technical brief.
Calendar event, opportunity record, attendees, deal stage, prior conversation notes.
CRM, prior call notes, public tech stack signals, past similar deals, your demo playbook.
A one-page brief — account context, likely tech stack, integration angles, suggested demo flow, anticipated objections.
Emailed to the SE before the call, attached to the calendar event, posted in [Slack](/docs/integrations/popular-integrations/slack) to the deal channel.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[Pre-Meeting Prepper](https://marketplace.relevanceai.com/listing/e2bc9eb0-6afd-4e24-b2ba-16160259981a)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your SEs can use on day one:
* *"Demo with Acme tomorrow — what's their tech stack, what integration angles should I lean on, and what objections has the AE flagged?"*
* *"Globex is on my calendar next Tuesday. Walk me through how to position our enterprise SSO story for their auth setup."*
* *"What's the right demo flow for a mid-market manufacturing prospect comparing us against Competitor X?"*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt) and your demo playbook, battle cards, and objection docs in [Knowledge](/docs/build/knowledge/create-knowledge).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed back which brief sections SEs use into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so briefs sharpen over time.
## Common pitfalls
A five-page brief doesn't get read in the five minutes before a call. Cap the length and force the prompt to prioritize.
Without segment-specific Knowledge, the brief recommends the same demo flow for every prospect. Branch on segment and use real exemplars.
The CRM hasn't been updated since the discovery call but the brief reads as if it were live. Have the Agent disclose when the freshest signal is and flag stale data.
The brief ignores what the AE already learned because notes live in another tool. Pull AE notes into the source set explicitly.
# Technical discovery summaries
Source: https://relevanceai.com/docs/guides/solution-engineering/discovery-summaries
Post-call writeups that turn an hour of conversation into a structured summary with action items.
The richest part of a deal is the technical discovery call — and the writeup is usually a CRM note half the team won't read. A discovery Agent turns the transcript into a structured summary: requirements, decisions, open questions, next steps. Everyone joining the next call walks in with the same picture.
## When this pays off
The SE meant to write up the call. Three days later, it's vibes-in-a-CRM-note.
The next SE / AE on the deal can't pick up where the last call left off because the writeup is too sparse.
"We'll send you the SAML doc" — and then nobody does, because it wasn't tracked.
The next call repeats discovery because the last one wasn't captured well.
## The shape of this use case
A discovery Agent takes a call recording or transcript and returns a structured summary.
Call recording or transcript, opportunity context, prior call notes.
[Fireflies](/docs/integrations/popular-integrations/fireflies) or other transcript source, CRM history, your discovery framework / MEDDICC template.
A structured summary — requirements, technical decisions, open questions, action items per party, links to relevant Knowledge.
Written back to the CRM as a structured note, posted in the deal [Slack](/docs/integrations/popular-integrations/slack) channel, emailed to attendees with a "did we get this right?" prompt.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open **[Nate, Meeting Notetaker](https://marketplace.relevanceai.com/listing/693db710-3d82-4269-9bce-ab6c9199e122)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your SEs can use on day one:
* *"Summarize this discovery call with Acme — pull out their requirements, our open questions, and the action items per side."*
* *"What were the technical concerns raised on the Globex call last week, and which ones did we resolve?"*
* *"Walk me through the SSO discussion from yesterday's Initech call — what did they say their constraint was?"*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your discovery framework in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed back which sections SEs reference into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so summaries track what matters.
## Common pitfalls
Generic LLM summarization smooths out the specifics. Force the prompt to preserve technical terms, exact constraints, and the customer's literal phrasing.
Action items without an owner and a due date don't get done. Require the Agent to assign and date each.
Sending an inaccurate summary to the customer hurts trust. Keep SE review on the customer-facing copy until you've watched it for several deals.
Some constraints are stated as "wishes" but they're really hard requirements. Have the prompt flag any ambiguous language for SE review.
# Solution Engineering
Source: https://relevanceai.com/docs/guides/solution-engineering/getting-started
Put AI Agents to work across pre-sales technical work — RFPs, demos, discovery — so SEs spend time architecting solutions, not chasing documents.
Solution engineers spend half their time on document work — RFP responses, security questionnaires, demo prep — and half on the strategic conversations that actually win deals. AI Agents take the document work so SEs can focus on the architecture and the relationships.
## Start with a Marketplace template
The Marketplace ships pre-built Agents you can clone in one click. Adapt them to your products, your security posture, your standard demo flow. Or [build a custom Agent from scratch](/docs/build/introduction).
Pre-call research for discovery and demo prep — pulls company, tech stack, and stakeholder context before you walk in.
Upload an RFP or security questionnaire plus your knowledge sources — get a filled draft back with citations and trust scores.
The full catalog of Agents — RFP, security review, demo prep, discovery synthesis.
Click **Clone Agent** on any listing, connect the systems it needs (CRM, document storage, security reference docs), and run on a real opportunity.
## Pick your path
How hands-on do you want to be? Pick a tab — the rest of the page is written for you.
You don't need to touch the builder. Open the cloned Agent above, ask in plain English, and let it work across the systems it's connected to.
## Sharpen the answers with knowledge
Upload your security questionnaire archive, prior RFP responses, architecture diagrams, and standard demo scripts. Every conversation references them — sharper output, no new setup.
Upload context once. Every conversation references it.
## Make it run on its own
When the same kinds of opportunities keep landing, set a trigger — every new SE-flagged deal gets a demo-prep brief, every inbound RFP triggers a first-pass response. One toggle, no code, no builder.
Schedule runs, fire on CRM events, listen to webhooks.
## Ready to go further?
When prompting and templates stop being enough — when you want the Agent to follow your exact security posture and orchestrate multi-doc deliverables — pick the **Build visually** tab above.
You're comfortable in product UIs. You don't want to wire up an Agent from scratch, but you do want it to draft RFP answers in your exact voice and reference your real architecture decisions. Open the cloned Agent in the builder and shape every piece.
## Connect the tools it needs
SE Agents work best when they can read from and write to the systems your team already uses.
* **CRM** — [HubSpot](/docs/integrations/popular-integrations/hubspot) or [Salesforce](/docs/integrations/popular-integrations/salesforce) for opportunity context
* **Document storage** — [Google Drive](/docs/integrations/popular-integrations/google-drive), [Notion](/docs/integrations/popular-integrations/notion), [Confluence](/docs/integrations/popular-integrations/confluence) for prior RFPs and architecture docs
* **Security reference** — your past security questionnaires, SOC 2 evidence, policy docs
* **Comms** — [Gmail](/docs/integrations/popular-integrations/gmail), [Slack](/docs/integrations/popular-integrations/slack) for delivery and internal review
See more about [Integrations](/docs/integrations/introduction).
## Shape every surface
Each piece below changes how the Agent behaves. Run it on a real opportunity between every change — small iterations beat big rewrites.
Edit the system prompt to match your team's tone, your security posture, your standard demo flow.
Add or remove the actions the Agent can take — search past RFPs, query the CRM, draft response docs, run another Agent.
Upload prior RFP responses, security artifacts, architecture diagrams, demo scripts. The Agent draws on these whenever it works.
Run the Agent automatically — on a schedule, when a new opportunity needs SE involvement, when an RFP lands.
Get notified when a security question can't be answered confidently or when a demo prep flags missing info.
Persistent context across deals — prior architecture discussions, previously raised security concerns, repeated objections.
## Chain Agents into a workforce
When a single Agent isn't enough — discovery summary, then demo prep, then technical proposal — wire them together on the Workforce canvas.
Drag, connect, and run multi-Agent pipelines without code.
## Test before you trust
Set up evals so a wrong security answer or hallucinated architecture detail gets caught before it lands in front of a prospect.
Define test cases in the UI. Run them on every change.
## Ready to go further?
When clicking through the builder starts to feel slow — when you'd rather have your AI coding assistant build and edit Agents for you, drop into custom Python or JS code blocks, or call Agents from your own app via the SDK — pick the **Build with AI** tab above.
You already work in an AI coding environment. Clicking through a UI to edit RFP response logic feels slow. Have your AI assistant build, shape, and orchestrate Agents directly from your editor.
## MCP & Plugins
Connect your AI coding environment to Relevance AI over MCP. Describe what you want in natural language; your AI assistant reads and writes your Relevance workspace — system prompts, Tools, knowledge, triggers, workforces, evals.
The fastest setup. Install the Relevance AI plugin and build Agents from your terminal.
Connect from Claude Desktop, Cursor, VS Code, ChatGPT, OpenAI Codex, or any MCP client.
Clone the skills repo so your coding assistant has built-in knowledge of Relevance patterns.
The full reference for what you can do programmatically.
## The four levels in solution engineering
How the [autonomy ladder](/docs/guides) plays out across pre-sales:
An SE asks the Agent to answer a specific security question or summarize prior architecture work for an account — the Agent returns a draft with sources.
An SE asks for an 80-question security questionnaire response — the Agent drafts all 80, the SE reviews and finalizes.
A new opportunity hits Stage 2 → discovery summary, demo prep, and a first-draft technical proposal all generate, the SE reviews and refines.
You set the objective — "improve technical win rate" — and the Workforce drafts RFP answers, discovery summaries, and demo prep, with its drafting criteria tuned through evals against win/loss outcomes.
## Zoom into a single use case
Each use case below is a working entry point — clone a template, then run it, shape it visually, or build with AI depending on which tab fit you.
Pull from your archive of prior answers to draft consistent, accurate responses to questionnaires.
Account-aware technical briefs the SE can read in five minutes before any call.
Post-call writeups that turn an hour of conversation into a structured summary with action items.
## See it in production
# RFP and security questionnaire responses
Source: https://relevanceai.com/docs/guides/solution-engineering/rfp-responses
Pull from your archive of prior answers to draft consistent, accurate responses to questionnaires.
Every SE team has the same archive — last year's RFPs, last quarter's security questionnaires, the architecture answers written six different ways across six different deals. An RFP Agent reads each new question and pulls the best prior answer, adapts it to the deal context, and flags anything that needs human judgment.
## When this pays off
The data-residency answer exists in 12 prior RFPs, all slightly different. New responses pick whatever's easiest to find.
An 80-question security questionnaire eats two SE days. The deal slows because the document is the bottleneck.
Security or compliance answers vary by who wrote them, not by what's true. Risky for trust and contracts.
"Have we answered this before?" requires a 20-minute hunt across Drive, Notion, and Slack.
## The shape of this use case
An RFP Agent takes a question + opportunity context and returns a drafted answer with sources.
Question text, opportunity context (segment, geography, deal size), prior-answer archive.
Past RFP and security questionnaire responses, policy docs, architecture artifacts, product changelog.
A drafted answer with citations to source documents and a confidence indicator — high-confidence answers ready to send, low-confidence flagged for SE review.
Drafted into the response doc (Google Doc, [Notion](/docs/integrations/popular-integrations/notion), Loopio export), posted in [Slack](/docs/integrations/popular-integrations/slack) for SE review on flagged answers.
## Where to start
Two ways in, depending on whether you want something running today or built to your exact spec.
Open the **[AI RFP Response Generator](https://marketplace.relevanceai.com/listing/d1092947-1746-4df1-9596-255d13796a2c)**. More in the [Marketplace](/docs/get-started/marketplace/introduction).
Start from scratch in the [builder](/docs/build/introduction), or by describing it in Claude Code or Cursor with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
Either way, these are prompts your SEs can use on day one:
* *"What's our standard answer to 'describe your data residency options'? Cite past responses."*
* *"This question is asking about SOC 2 controls around access. Pull the right answer and adapt it for an enterprise EU customer."*
* *"Walk me through these 30 questions from Acme's questionnaire — flag the ones that need real SE attention."*
## Where to take it
Once it's running, deepen it in three moves:
Shape it with a [prompt](/docs/build/agents/build-your-agent/prompt), your prior-response archive in [Knowledge](/docs/build/knowledge/create-knowledge), and [Bulk Schedule](/docs/build/agents/give-your-agent-tasks/bulk-schedule).
Wrap it in a [workflow](/docs/build/workforces/create-a-workforce) that fires on a [trigger](/docs/build/agents/build-your-agent/triggers).
Feed back which answers customers accepted into the Agent's [evals](/docs/build/agents/build-your-agent/evals) so it promotes the strong ones.
## Common pitfalls
The Agent confidently states a control you don't have. Force citations to actual policy / past-answer documents and fail visibly when the question isn't covered.
Last year's accurate answer is this year's misrepresentation. Tag prior responses with dates and have the Agent prefer recent over old when in conflict.
Some questions need legal sign-off. Always route security and contractual answers through human review until you've watched it for several deals.
A "yes" to a feature in mid-market might be a "yes, but" in enterprise. Have the Agent read the opportunity record and adapt — not just look up the question.
# Add Integrations
Source: https://relevanceai.com/docs/integrations/add-integrations
Integrations transform your AI agents into powerful workflow automation tools by connecting them with external services and platforms.
## Browsing and filtering integrations
The **Integrations & API Keys** browser displays all available integrations. Use the search bar to find a specific service by name, or filter by category tag — CRM, Communication, AI Models, Automation & Integration, and more. Multiple tags can be selected at once.
## Setting Up Integrations
To begin using integrations with your AI agents:
1. Navigate to the **Integrations & API Keys** page from the left-hand menu of your Relevance AI account.
2. Browse the available integrations and select the service you want to connect.
3. Follow the authentication steps to authorize the connection.
4. Once connected, the integration will appear in your list of available connections.
## Adding Triggers to Agents
Triggers allow your agents to automatically activate when specific events occur in connected platforms:
1. Go to the Agent Settings page for the agent you want to configure.
2. Select Agent Profile from the menu.
3. Locate the Triggers section.
4. Click "Add Trigger" and select from the available trigger options.
5. Configure the trigger settings according to your needs.
6. Save your changes.
## Popular Integrations
### Slack Integration
Connect your agents to Slack to enable them to:
* Monitor channels for specific messages or keywords.
* Send notifications or updates to designated channels.
* Respond to direct messages or mentions.
* Perform actions based on Slack events.
### Google Calendar Integration
Link your agents with Google Calendar to:
* Schedule meetings and appointments.
* Send calendar invites to participants.
* Check availability before scheduling.
* Provide reminders for upcoming events.
### HubSpot Integration
Connect to HubSpot to allow your agents to:
* Create and update contact records.
* Track customer interactions.
* Manage deals and opportunities.
* Access customer data for personalized responses.
# Email warmups
Source: https://relevanceai.com/docs/integrations/integration-examples/email-warmups
Use case: Warm up your email before starting your email marketing campaigns.
## Why do you need to warmup your email inbox?
Email warmups refer to the process of gradually increasing the volume of emails sent from a new or unused email account to build a positive sender reputation with internet service providers (ISPs).
A warmedup email inbox helps you to avoid spam filters and ensure better deliverability rates.
We recommend that you create an email account especially for your email inbox manager agents. So warming up their inbox before sending out emails from their account will help your email marketing/inbox management campaigns start successfully.
## How to warmup your emails?
The process usually involvesn sending a small number of emails initially and slowly increasing the quantity over time. Start by sending a few emails to active, engaged recipients like colleagues who are likely to open and interact with your agent's emails.
We recommend starting with 4-8 warm-up emails per day per account with a target reply rate of 30%. After two weeks, you can increase the warm-up volume to 20-30 emails per day per account, with a higher target reply rate of 70% when engaging in outreach.
The maximum recommended warm-up email volume is 50 emails per day, with a reply rate of a max of 60%.
## Add email warmup integration to your Relevance account
You can use an in-built Relevance integration to warm up your chosen email account, by activating the email warmup integration.
Here is a video walking you through the process of doing this:
This is one of our flagship agent templates, BDR Bosh (enterprise only).
Step-by-step-process:
1. On the "Integrations" page.
2. Click on the "Google (Gmail, calendar & API)" integration.
3. Click on the 3 dot menu next to the email you want to warm up, then click on "Email Warmup Settings".
* Sender name: This is who all your email warmup emails are going to come from. This could be your name, or just be a name you use to be able to classify the email warmup emails in your inbox.
* App password, get it from the documentation link. When you click on that, make sure you’re in the right account first. Setup 2fa. Create and manage app passwords. Create a new password, call it Email Warmup. Copy paste the app password.
4. Click on 3 dots next to your email account, and click on "Email warmup settings" again.
You will now see basic statistics on how your email warmup is going.
You can start and stop your email warmups at any time.
# Integrations
Source: https://relevanceai.com/docs/integrations/introduction
Connect your AI agents with external tools and services to create powerful, automated workflows across your entire tech stack.
## Overview
Integrations serve as bridges between your AI agents and the external services you rely on daily. By establishing these connections, you can create seamless workflows that span across multiple platforms, allowing your agents to access data from and perform actions within your entire digital ecosystem.
For new users, it's important to understand that integrations enable four key capabilities:
1. **Connecting external services** to your Relevance AI account
2. **Setting up triggers** that automatically activate your agents based on external events
3. **Using pre-built actions** that allow your agents to interact with external platforms
4. **Creating custom API calls** for advanced integration scenarios
Let's explore each of these capabilities in detail.
## Native vs. Pipedream integrations
Integrations fall into two types:
* **Native integrations** are built directly by Relevance AI. They offer deeper support, including pre-built tool steps and trigger events designed to work with agents out of the box.
* **Pipedream integrations** extend the catalog to 2,000+ services via a Pipedream connection. They support authentication and API access for a wide range of platforms not covered by native integrations.
Start with native integrations when available — they come with ready-made actions and triggers that require less configuration.
## 1. Connecting Integrations
The first step in leveraging integrations is connecting your external services to Relevance AI:
1. Navigate to the **Integrations & API Keys** page from the left-hand menu of your Relevance AI account
2. Browse the available integrations and select the service you want to connect
3. Click on the integration card to begin the connection process
4. Follow the authentication steps to authorize the connection (typically involves logging into the service or providing API credentials)
5. Once connected, the integration will appear as "Connected" in your list of available integrations
Each integration may have specific configuration options depending on the service. The platform guides you through the necessary steps to establish a secure and functional connection.
### Connecting LLM Accounts
A particularly valuable integration option is connecting your own Large Language Model (LLM) accounts:
1. Go to the **Integrations & API Keys** page in the left-hand menu
2. Look for the LLM provider you want to connect (such as OpenAI, Anthropic, or Google)
3. Click on the provider and enter your API key
4. Once connected, you can use your own LLM account with your agents
This capability allows you to leverage your existing LLM subscriptions and manage usage under your own account, giving you greater control over your AI resources and potentially reducing costs.
## 2. Setting Up Triggers
Triggers are events from integrated platforms that automatically activate your agents. This transforms your agents from reactive tools that wait for instructions into proactive assistants that respond to events in your digital environment.
### How to Set Up Triggers:
1. Go to the **Agent Settings** page for the agent you want to configure
2. Select **Agent Profile** from the menu
3. Locate the **Triggers** section
4. Click **"Add Trigger"** and select from the available trigger options
5. Configure the trigger settings according to your needs
6. Save your changes
### Common Trigger Examples:
* **Email Integrations (Gmail, Outlook)**: Trigger an agent when you receive an email matching specific criteria
* **CRM Integrations (HubSpot, Salesforce)**: Activate an agent when a new contact is created or a deal stage changes
* **Support Integrations (Freshdesk, Zendesk)**: Start an agent workflow when a new support ticket is created
* **Messaging Integrations (Slack, WhatsApp Business)**: Trigger an agent when a message is received in a specific channel
For example, with the HubSpot integration, you could set up a trigger that activates your sales assistant agent whenever a new lead is created in your CRM. The agent could then automatically research the lead, prepare a personalized outreach message, and schedule a follow-up task.
## 3. Tools & Tool Steps (Actions)
This is where integrations truly shine! Once connected, integrations provide a library of pre-built actions that your agents can use to interact with external platforms. These actions can be incorporated into your agent's workflows at any point, not just as triggers.
### How to Add Integration Actions to Your Agent:
1. Go to the **Agent Settings** page for your agent
2. Select **Tools** under "Connected Resources" in the sidebar
3. Click **"+ Add tool"** to open the tool library
4. Search for the integration name (e.g., "HubSpot" or "Slack")
5. Browse the available actions for that integration
6. Select the action you want to add and click **"+ Add"**
7. Configure any required parameters for the action
8. Save your changes
### Examples of Powerful Integration Actions:
**Slack Integration Actions:**
* Send a message to a specific channel
* Create a new channel
* Search for messages
* Update a message
* Upload a file
* Create a poll
* And many more!
**Google Calendar Integration Actions:**
* Create a new event
* Check availability
* Update an existing event
* Send calendar invites
* Get upcoming events
* Delete events
* And many more!
**HubSpot Integration Actions:**
* Create or update contacts
* Add notes to contact records
* Create deals
* Update deal stages
* Create tasks
* Search for contacts
* Get contact properties
* And many more!
**Notion Integration Actions:**
* Create a new page
* Update page content
* Search for pages
* Create databases
* Add items to databases
* Comment on pages
* And many more!
These actions are the building blocks of powerful workflows. For example, your agent could use the HubSpot "Get Contact" action to retrieve customer information, then use the "Create Task" action to set up a follow-up, and finally use the Slack "Send Message" action to notify your sales team.
The beauty of these actions is that they can be used in any combination and at any point in your agent's workflow. You're not limited to a predefined sequence - you can create custom workflows that perfectly match your business processes.
## 4. Using the Integration's API Tool Step (Advanced)
For advanced users who need more flexibility than the pre-built actions provide, Relevance AI offers direct API access to your connected integrations:
1. Create a new tool in the **Tools** section
2. Scroll down to **Tool Steps**
3. Click **"+ Add Step"**
4. Search for and select the integration's API tool step (e.g., "HubSpot API")
5. Select your connected account from the dropdown
6. Configure the API endpoint, method, and parameters
7. Save your tool
This advanced capability allows you to access any functionality exposed by the integration's API, even if there isn't a pre-built action for it yet. It's perfect for custom workflows that require specialized interactions with your external services.
## Creating Powerful Cross-Platform Workflows
The true power of integrations comes from combining multiple actions across different platforms into cohesive workflows. Here's an example of how you might use integrations to automate a lead nurturing process:
1. A new lead is created in HubSpot (trigger)
2. Your agent uses the Google Search action to research the lead's company
3. The agent uses the HubSpot action to add research notes to the contact record
4. The agent uses the Gmail action to send a personalized introduction email
5. The agent uses the Google Calendar action to schedule a follow-up task
6. The agent uses the Slack action to notify the sales team about the new lead
All of this happens automatically, without any manual intervention required. These workflows can dramatically increase efficiency, reduce human error, and ensure consistent execution of your business processes.
## Best Practices for Using Integrations
To get the most out of your integrations:
1. **Start with clear goals**: Define what you want to achieve with each integration before setting it up
2. **Begin with simple workflows**: Start with basic trigger-action combinations before building complex multi-step processes
3. **Test thoroughly**: Always test your integration workflows with sample data before deploying them
4. **Monitor performance**: Regularly check that your integrations are functioning as expected
5. **Secure your credentials**: Follow security best practices when connecting integrations, especially when using API keys
6. **Document your workflows**: Keep track of how data flows between systems for easier troubleshooting and optimization
## Related Features
[Agent Triggers](https://relevanceai.com/docs/build/agents/customise-agent/triggers) - Learn more about setting up events that automatically activate your agents based on specific conditions or actions.
[Tools](https://relevanceai.com/docs/get-started/core-concepts/tools) - Discover how to enhance your agents with specialized tools that extend their capabilities and allow them to perform specific tasks.
[Agent Configuration](https://relevanceai.com/docs/build/agents/agent-configuration) - Explore the complete process of setting up and customizing your AI agents to work with integrations and other features.
## Frequently asked questions (FAQs)
There is no hard limit on the number of integrations you can connect. You can connect as many services as you need to support your workflows.
Yes, you can connect multiple accounts from the same service. This is useful if you need to work with different accounts for different purposes or clients.
The system will attempt to reconnect and, if unsuccessful, will notify you of the issue. Your agents will continue to function with their other capabilities while the integration is being restored.
While Relevance AI continually expands its integration library, you can also use webhook integrations or API tool steps to connect with services that don't have dedicated integrations yet.
When you add an API key to a supported integration (e.g. Firecrawl, Lusha, Airtop), it's automatically used by all tool steps that require it. No extra configuration needed.
# Anthropic LLM models
Source: https://relevanceai.com/docs/integrations/llm-integrations/anthropic
Learn more about Anthropic LLM models and how to connect your AWS Bedrock or Google Cloud Platform account to access Anthropic models
Anthropic's Claude LLM models are focused on safe, reliable, and ethical AI responses. They are often better at reasoning and 'thoughtful' tasks.
They're good for detailed explanations, structured outputs, and sensitive industries.
Credits charged per 1,000 tokens processed if you do not connect your AWS Bedrock account.
Anthropic models can process each of the following files:
* .jpg
* .jpeg
* .png
* .webp
* .gif
## Setting Up AWS Bedrock with Relevance
Relevance supports two secure methods for connecting your AWS Bedrock account to access Anthropic models. Choose the option that best fits your organization's security requirements.
### Key Benefits
**Cross-Region Inference**: Ensure that you pick a model that has cross region inferencing available.
**Usage Oversight**: Both setup methods provide access to all supported Anthropic Claude models available in your selected AWS regions. You will be able to have increased cost control and insight into model usage.
### Option 1: IAM Credentials (Quick Setup)
**Best for**: Testing, proof-of-concepts, and organizations with flexible security policies.
#### Prerequisites
* AWS account with Anthropic models enabled in Bedrock
* Administrative access to create IAM users and policies
### Setup Steps
In your AWS console, create a new policy with these permissions:
```json theme={null}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel*"
],
"Resource": [
"arn:aws:bedrock:*:*:inference-profile/*",
"arn:aws:bedrock:*::foundation-model/anthropic.*"
]
}
]
}
```
* Create a new IAM user in your AWS account
* Attach the policy created in step 1
* Generate access keys for this user
In your Relevance dashboard:
1. Navigate to **Integrations & API Keys** → **AWS Bedrock**
2. Enter your credentials:
* **Access Key ID**
* **Secret Access Key**
* **Region** (your preferred AWS region)
3. Select your desired Claude model
### Option 2: Role Assumption (Enterprise Security)
**Best for**: Enterprise organisations requiring enhanced security, short-lived credentials, and detailed usage tracking.
#### Prerequisites
* Enterprise Relevance plan
* AWS account with Anthropic models enabled in Bedrock
* Administrative access to create IAM roles and policies
Reach out to your Relevance Account Executive to initiate the role assumption setup. They will coordinate with our implementation team to exchange the necessary account details.
Create an IAM role in your AWS account with this trust policy:
```json theme={null}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::root"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"sts:ExternalId": "relevance:"
}
}
}
]
}
```
Create a policy with Bedrock permissions and attach it to your role:
```json theme={null}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel*"
],
"Resource": [
"arn:aws:bedrock:*:*:inference-profile/*",
"arn:aws:bedrock:*::foundation-model/anthropic.*"
]
}
]
}
```
In your Relevance dashboard:
1. Navigate to **Integrations** → **AWS Bedrock**
2. Enter your configuration:
* **Region** (your preferred AWS region)
* **Role ARN** (the ARN of the role you created)
If you run into any issues with either of these options, please reach out to your Account Executive or [our support team](https://relevanceai.com/docs/get-started/support).
***
## AWS Bedrock Guardrails (Optional)
You can optionally configure AWS Bedrock Guardrails to apply content filtering and safety controls to your model invocations. Guardrails allow you to implement safeguards for your generative AI applications.
### Prerequisites
Before configuring guardrails in Relevance AI, you must:
1. Create a guardrail in AWS Bedrock console
2. Note the Guardrail ID or ARN
3. Optionally note the specific version you want to use
4. Enable Cross-region inferencing on the guardrail
For instructions on creating guardrails, see the [AWS Bedrock Guardrails documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html).
***
### Configuration
In the Relevance AI dashboard under **Project Settings > API Keys**, add the following:
| Key Name | Value | Required |
| -------------------------------- | -------------------------- | ------------------------------------------------- |
| AWS Bedrock Guardrail Identifier | Your guardrail ID or ARN | Yes (if using guardrails) |
| AWS Bedrock Guardrail Version | Version number (e.g., "1") | No (defaults to DRAFT if you don't have versions) |
***
### IAM Policy Update
If you're using guardrails, add the following permission to your IAM policy:
```json theme={null}
{
"Effect": "Allow",
"Action": [
"bedrock:ApplyGuardrail"
],
"Resource": [
"arn:aws:bedrock:::guardrail/",
"arn:aws:bedrock:::guardrail-profile/"
]
}
```
Remember to add this permission to both the IAM user policy (Option 1) or the IAM role policy (Option 2) depending on which setup method you're using.
***
### Important considerations
#### Multi-Region Support
For optimal performance and availability, ensure your AWS policies include permissions for multiple regions. Use `*` in the region field or explicitly list all regions where you want Bedrock access.
#### Model Availability
Different Claude models are available in different AWS regions. Verify model availability in your chosen region using the [AWS Bedrock documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html).
#### Security Precedence
If both IAM credentials and role ARN are configured, Relevance will automatically use the more secure role assumption method.
### Additional Resources
* [AWS Bedrock Inference Profiles Prerequisites](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-prereq.html)
* [Cross-Region Inference Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)
* [Supported Models by Region](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html)
***
## Accessing Claude models using Vertex AI on Google Cloud Platform
If you use Google Cloud Platform, you can connect your Vertex AI API key to Relevance AI, which will allow you to use your Google Cloud Platform credits as opposed to your Relevance AI credits for Claude models.
You can do this by following these steps:
In Google Cloud Console, enable the Vertex AI API by following the instructions [here](https://cloud.google.com/vertex-ai/docs/featurestore/setup#configure_project).
Enable the Claude model you want to use via [https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/claude](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/claude) (click on the model card, then Enable)
Create a service account in the Google Cloud Console following the instructions at [https://cloud.google.com/iam/docs/service-accounts-create](https://cloud.google.com/iam/docs/service-accounts-create). **Make note of the project ID used to create the account.** The service account can have any name and description desired.
Give the service account the Vertex AI Service Agent IAM role. This means the service account is permitted to use Vertex AI and call LLMs in Google Cloud.
Create a JSON private key for the service account, and download the key file.
In the key file, extract the client\_email and private\_key fields exactly as they are written, removing the quotation marks.
The client\_email should be an email address that normally ends with iam.gserviceaccount.com.
The private\_key should be formatted as follows:
```shell theme={null}
-----BEGIN PRIVATE KEY-----\nLOTS OF LETTERS AND NUMBERS HERE\n-----END PRIVATE KEY-----\n
```
Log into Relevance AI and head to 'Integrations & API Keys'. Search for Google Cloud Platform, and add the Client Email and Private Key, and the Project ID from earlier in step 3.
Once your Google Cloud Platform details are added correctly, you will not be charged Relevance AI credits for Anthropic Claude models under the `gcp-vertexai` group of models.
# Azure LLM models
Source: https://relevanceai.com/docs/integrations/llm-integrations/azure
Learn more about Azure LLM models
Azure's LLM models are good for custom deployments hosted on Azure with higher context limits — ideal for large and detailed inputs.
Enterprises needing private deployment, security, or very large tasks.
Credits charged per 1,000 tokens sent or received.
# Google's Gemini LLM models
Source: https://relevanceai.com/docs/integrations/llm-integrations/gemini
Learn more about Google's Gemini LLM models and how to access them via Google AI Studio and Google Cloud Platform
Google's Gemini LLM models are known for strong coding ability and task complexity handling (especially Google Gemini 2.5 models).
Software development agents, complex task execution.
Credits charged per 1,000 tokens processed.
Gemini models can process each of the following files:
* .pdf
* .jpg
* .jpeg
* .png
* .webp
* .gif
* .wav
* .mp3
* .aac
* .ogg
* .aiff
* .flac
* .mp4
* .mpeg
* .mov
* .avi
* .flv
* .mpg
* .webm
* .wmv
## Understanding pricing & context caching
Gemini models automatically cache repeated input tokens (like agent instructions and tool definitions) in multi-turn conversations, charging them at **90% less** than uncached tokens. This happens automatically with no code changes required.
### Pricing example: Gemini 1.5 Pro
| Token Type | Cost per 1,000 tokens |
| ------------------------- | --------------------- |
| **Uncached input tokens** | 0.315 credits |
| **Cached input tokens** | 0.0315 credits |
| **Output tokens** | 1.26 credits |
**Example:** An agent with 19,000 tokens of instructions makes two calls:
* **First call:** 19,000 input (uncached) + 2,000 output = 8.51 credits
* **Second call:** 6,000 input (uncached) + 13,000 input (cached) + 1,500 output = 4.19 credits
* **Without caching**, the second call would cost 7.88 credits
* **Savings: 47% reduction** on the second call
### Why UI numbers may look different
The task credit breakdown displays **uncached input tokens only**. Cached tokens are charged separately at the lower rate but not shown in the breakdown. The **total cost is accurate** and includes both.
If you see "6,000 input tokens" in the UI, there may be additional cached tokens charged at 90% less. Your actual costs are **lower than expected** because of automatic caching.
**No markup policy:** Relevance AI passes through Google's exact pricing, including all caching discounts. We do not add any markup to Vendor Credits.
For technical details about Gemini's context caching implementation, see [Gemini's Context Caching Documentation](https://ai.google.dev/gemini-api/docs/caching).
If you connect your own Google AI Studio or Google Cloud Platform credentials, you'll see the same caching behavior and cost savings directly in your Google billing.
## Accessing Gemini models using Google AI Studio
If you use Google AI Studio, you can add your API key to Relevance AI, which will allow you to use your Google AI Studio credits as opposed to your Relevance AI credits.
You can add your Google AI Studio API key to Relevance AI by following these steps:
1. Generate your API key at [Google AI Studio](https://aistudio.google.com/welcome)
2. Log into Relevance AI and head to 'Integrations & API Keys'
3. Search for 'Google AI Studio Gemini API Key' and add your API key
Once you've successfully added your API key, you will not be charged Relevance AI credits when you use Google Gemini models in your LLM Tool steps and Agents.
## Accessing Gemini models using Vertex AI on Google Cloud Platform
If you use Google Cloud Platform, you can connect your Vertex AI API key to Relevance AI, which will allow you to use your Google Cloud Platform credits as opposed to your Relevance AI credits.
You can do this by following these steps:
In Google Cloud Console, enable the Vertex AI API by following the instructions [here](https://cloud.google.com/vertex-ai/docs/featurestore/setup#configure_project).
Create a service account in the Google Cloud Console following the instructions at [https://cloud.google.com/iam/docs/service-accounts-create](https://cloud.google.com/iam/docs/service-accounts-create). **Make note of the project ID used to create the account.** The service account can have any name and description desired.
Give the service account the Vertex AI Service Agent IAM role. This means the service account is permitted to use Vertex AI and call LLMs in Google Cloud.
Create a JSON private key for the service account, and download the key file.
In the key file, extract the client\_email and private\_key fields exactly as they are written, removing the quotation marks.
The client\_email should be an email address that normally ends with iam.gserviceaccount.com.
The private\_key should be formatted as follows:
```shell theme={null}
-----BEGIN PRIVATE KEY-----\\nLOTS OF LETTERS AND NUMBERS HERE\\n-----END PRIVATE KEY-----\\n
```
Log into Relevance AI and head to 'Integrations & API Keys'. Search for Google Cloud Platform, and add the Client Email and Private Key, and the Project ID from earlier in step 2.
Optionally, if the Gemini models are deployed into a particular Google Cloud Region, enter the region. Otherwise, leave it blank. If you enter a region that isn't deployed properly, calling models will fail. See [https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations) for a list of regions and what the string should look like.
Once your Google Cloud Platform details are added correctly, you will not be charged Relevance AI credits for Google Gemini models.
# OpenAI LLM models
Source: https://relevanceai.com/docs/integrations/llm-integrations/openai
Learn more about OpenAI LLM models
OpenAI's LLM models are known for advanced conversational abilities, creative writing, and broad general knowledge.
Versatile agents, customer support, brainstorming.
Credits charged per 1,000 tokens used for prompts + replies if you do not connect your own OpenAI API key / account.
OpenAI models can process each of the following files:
* .pdf
* .jpg
* .jpeg
* .png
* .webp
* .gif
## Understanding pricing & implicit caching
OpenAI models automatically cache repeated input tokens (like agent instructions and tool definitions) in multi-turn conversations, charging them at **90% less** than uncached tokens. This happens automatically with no code changes required.
### Pricing example: GPT-4o
| Token Type | Cost per 1,000 tokens |
| ------------------------- | --------------------- |
| **Uncached input tokens** | 0.63 credits |
| **Cached input tokens** | 0.063 credits |
| **Output tokens** | 5 credits |
**Example:** An agent with 19,000 tokens of instructions makes two calls:
* **First call:** 19,000 input (uncached) + 2,000 output = 21.97 credits
* **Second call:** 6,000 input (uncached) + 13,000 input (cached) + 1,500 output = 12.10 credits
* **Without caching**, the second call would cost 19.47 credits
* **Savings: 38% reduction** on the second call
### Why UI numbers may look different
The task credit breakdown displays **uncached input tokens only**. Cached tokens are charged separately at the lower rate but not shown in the breakdown. The **total cost is accurate** and includes both.
If you see "6,000 input tokens" in the UI, there may be additional cached tokens charged at 90% less. Your actual costs are **lower than expected** because of automatic caching.
**No markup policy:** Relevance AI passes through OpenAI's exact pricing, including all caching discounts. We do not add any markup to Vendor Credits.
For technical details about OpenAI's prompt caching implementation, see [OpenAI's Prompt Caching Documentation](https://platform.openai.com/docs/guides/prompt-caching).
If you connect your own OpenAI API key, you'll see the same caching behavior and cost savings directly in your OpenAI billing.
# OpenRouter LLM models
Source: https://relevanceai.com/docs/integrations/llm-integrations/openrouter
Learn more about OpenRouter LLM models
OpenRouter models are a unified access point to a wide variety of open models like Meta’s LLaMA family, Google Gemini models, and others.
Exploring experimental or emerging models.
Credits charged per 1,000 tokens used, depending on selected model. [Create an OpenRouter account here](https://openrouter.ai/).
# Agent skills
Source: https://relevanceai.com/docs/integrations/mcp/agent-skills
Give your AI coding assistant built-in knowledge of Relevance AI by cloning the agent skills repository.
The [Relevance AI agent skills](https://github.com/RelevanceAI/agent-skills) repository is a local reference that teaches your AI coding assistant how to work with Relevance AI. Clone it once and your assistant gets detailed context on agents, tools, workforces, knowledge, analytics, and evals — without needing to figure things out from scratch.
Agent skills work alongside the [MCP server](/docs/integrations/mcp/mcp-server). The MCP server gives your assistant the **ability** to call Relevance AI tools. Agent skills give it the **knowledge** to use them well.
***
## Quick start
Choose the path that matches your AI coding assistant:
```bash Claude Code theme={null}
git clone https://github.com/RelevanceAI/agent-skills ~/.claude/skills/relevance-ai
```
```bash OpenAI Codex theme={null}
git clone https://github.com/RelevanceAI/agent-skills ~/.agents/skills/relevance-ai
```
```bash Cursor / VS Code / Others theme={null}
git clone https://github.com/RelevanceAI/agent-skills .agents/skills/relevance-ai
```
The agent skills provide context, but your assistant still needs the MCP server to actually interact with your Relevance AI project. Follow the setup for your client on the [MCP Server](/docs/integrations/mcp/mcp-server) page.
Ask your AI assistant to list your agents or tools:
```
> List all my Relevance AI agents
```
If the assistant returns your agents, you're all set.
***
## What's included
The agent skills repository contains structured reference documentation that your AI assistant reads on-demand:
The main skill definition — covers all 46 MCP tools, critical usage rules, and workflow patterns your assistant should follow.
Detailed guides for agents, tools, workforces, knowledge, analytics, and evals that the assistant reads when working on specific tasks.
### Topics covered
Creating agents, system prompts, actions, memory, triggers, and troubleshooting.
Building tools, transformations, OAuth configuration, versioning, and patterns.
Multi-agent orchestration concepts, setup, and debugging.
Knowledge table operations — creating tables, adding rows, querying data.
Usage metrics and reporting capabilities.
Testing agent behavior with evaluation cases.
***
## Keeping skills up to date
The agent skills repository is a standard Git repo. Pull the latest changes periodically:
```bash theme={null}
cd ~/.agents/skills/relevance-ai # or ~/.claude/skills/relevance-ai
git pull
```
***
## How it works
When your AI assistant encounters a Relevance AI task, it reads the relevant files from the agent skills repository to understand:
* **Which MCP tools to call** — the skill definition maps tasks to specific tool names
* **What parameters to use** — reference docs include required fields and correct formats
* **What pitfalls to avoid** — critical rules like "always fetch full agent config before updating" prevent common mistakes
This means your assistant can handle complex workflows (like creating an agent with tools, triggers, and a system prompt) correctly on the first try, rather than through trial and error.
Agent skills follow the [Agent Skills open standard](https://github.com/anthropics/agent-skills). Any AI coding assistant that supports this convention can use them.
# Claude Code plugin
Source: https://relevanceai.com/docs/integrations/mcp/claude-code
Use the Relevance AI Claude Code plugin to build and manage your agents directly from your terminal.
The [Relevance AI Claude Code plugin](https://github.com/RelevanceAI/cc-plugin) is the fastest way to build Relevance AI agents from your terminal with [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins). It bundles the MCP server along with built-in skills that teach Claude Code how to work with agents, tools, workforces, knowledge, analytics, and evals — all from your terminal.
## Quick start
Install from the Claude Code marketplace:
```bash theme={null}
claude plugin marketplace add RelevanceAI/cc-plugin
claude plugin install relevance-ai@cc-plugin
```
Requires Claude Code version **1.0.33** or later.
Run `/mcp` from within Claude Code, select the **relevance-ai** server, and click **Authenticate** to log in via your browser.
Authentication is required only once.
You're ready to go. Try one of the example prompts below or describe what you want to build.
***
## What the plugin includes
Full access to your Relevance AI project's agents, tools, and knowledge.
Pre-configured prompts and workflows for agents, tools, workforces, triggers, and evaluations.
Claude Code understands Relevance AI's data model, so you can describe what you want in plain language.
***
## Example prompts
Once authenticated, you can start building immediately. Here are some things to try:
```
> Create a BDR agent that qualifies inbound leads from HubSpot
```
```
> Set up a workforce where a triage agent routes support tickets to specialist agents
```
```
> Build a tool that enriches a company URL with a one-paragraph summary
```
```
> Create a tool that generates personalized cold emails from LinkedIn profiles
```
```
> Pull the last 20 conversations for my Support Agent and identify failures
```
```
> My BDR agent is letting unqualified leads through — review its instructions and fix it
```
Use `/plan` in Claude Code to have Claude plan the work before executing — recommended for complex builds.
***
## Working with multiple projects
If you work across multiple Relevance AI projects, add separate MCP server entries for each:
```bash theme={null}
claude mcp add relevance-project-1 --transport http https://mcp.relevanceai.com/
claude mcp add relevance-project-2 --transport http https://mcp.relevanceai.com/
```
Each entry authenticates independently against its own project. This lets you access tools and agents across all your projects without needing to log out and back in.
***
## Troubleshooting
* Ensure you are running Claude Code version **1.0.33** or later
* Try running `claude plugin marketplace add RelevanceAI/cc-plugin` again
* Check your internet connection
* Run `/mcp` and select the **relevance-ai** server to re-authenticate
* Make sure you have an active Relevance AI account with access to the project
* Try removing and re-adding the plugin
* Verify you have completed authentication via `/mcp`
* Check that your Relevance AI project has tools and agents configured
* Try restarting Claude Code
# OpenAI Codex
Source: https://relevanceai.com/docs/integrations/mcp/codex
Connect OpenAI Codex to Relevance AI using the MCP server and agent skills.
[OpenAI Codex](https://openai.com/index/codex/) is OpenAI's cloud-based coding agent. You can connect it to Relevance AI by adding the MCP server and cloning the agent skills repository — giving Codex full access to your agents, tools, workforces, and knowledge.
***
## Quick start
Register the Relevance AI MCP server with Codex:
```bash theme={null}
codex mcp add relevance-ai --url https://mcp.relevanceai.com/
```
Log in to your Relevance AI account:
```bash theme={null}
codex mcp login relevance-ai
```
This opens your browser to authenticate. You only need to do this once per project.
Give Codex built-in knowledge of Relevance AI by cloning the [agent skills repository](https://github.com/RelevanceAI/agent-skills):
```bash theme={null}
git clone https://github.com/RelevanceAI/agent-skills ~/.agents/skills/relevance-ai
```
This provides Codex with detailed context on how to work with agents, tools, workforces, knowledge, and more — so it can handle complex tasks correctly on the first try.
Learn more about what's included in the agent skills on the [Agent Skills](/docs/integrations/mcp/agent-skills) page.
You're ready to go. Try one of the example prompts below or describe what you want to build.
***
## Example prompts
Once connected, you can start building immediately:
```
> Create a BDR agent that qualifies inbound leads from HubSpot
```
```
> Set up a workforce where a triage agent routes support tickets to specialist agents
```
```
> Build a tool that enriches a company URL with a one-paragraph summary
```
```
> Create a tool that generates personalized cold emails from LinkedIn profiles
```
```
> Pull the last 20 conversations for my Support Agent and identify failures
```
```
> My BDR agent is letting unqualified leads through — review its instructions and fix it
```
***
## Working with multiple projects
If you work across multiple Relevance AI projects, add a separate MCP server entry for each:
```bash theme={null}
codex mcp add relevance-project-1 --url https://mcp.relevanceai.com/
codex mcp login relevance-project-1
codex mcp add relevance-project-2 --url https://mcp.relevanceai.com/
codex mcp login relevance-project-2
```
Each entry authenticates independently against its own project.
***
## Troubleshooting
* Ensure you have run `codex mcp add relevance-ai --url https://mcp.relevanceai.com/`
* Check that authentication completed successfully with `codex mcp login relevance-ai`
* Verify your internet connection and that `https://mcp.relevanceai.com/` is accessible
* Make sure you have an active Relevance AI account
* Check that you have access to the project you are trying to connect to
* Try re-authenticating with `codex mcp login relevance-ai`
* Verify you have completed authentication
* Check that your Relevance AI project has tools and agents configured
* Try removing and re-adding the MCP server
* Confirm the agent skills are cloned to the correct path: `~/.agents/skills/relevance-ai`
* Run `ls ~/.agents/skills/relevance-ai/SKILL.md` to verify the files exist
* Pull the latest version: `cd ~/.agents/skills/relevance-ai && git pull`
# MCP client
Source: https://relevanceai.com/docs/integrations/mcp/mcp-client
Connect external MCP servers to your Relevance AI Agents, giving them access to Tools and resources from other services.
The MCP client integration lets you connect remote MCP servers to your Relevance AI Agents — either through preset connections (Notion, Canva, Atlassian) or by manually connecting any custom server URL. This gives your Agents access to Tools and resources hosted on external platforms without rebuilding them in Relevance AI.
This page is about connecting external MCP servers **to** Relevance AI Agents. If you want to use Relevance AI **from** an AI client like Claude or Cursor, see [MCP & Plugins](/docs/get-started/core-concepts/mcp-plugins).
## Setting up an MCP connection for Agents
Agents can connect to remote MCP servers to run Tools and read resources exposed by those servers. You can choose from preset connections for popular services or connect your own custom MCP server.
Open the Agent you want to connect.
Navigate to the **Tools** tab in the Agent builder.
Click **Add MCP**.
* **Preset connections**: Select from Notion, Canva, or Atlassian — follow the OAuth flow to authorize access and Tools are configured automatically.
* **Custom connection**: Click **Connect my own**, add the server URL, label the connection, and enter any required authentication details.
The connection label you provide will appear in Tool descriptions as `(MCP: connection-name)`. This helps Agents distinguish between Tools from different connections, especially when using multiple instances of the same MCP server.
Once connected, the Agent automatically fetches and displays the available Tools from the MCP server. Tools appear in the conversation task view and can be referenced in the Agent's core instructions.
Local MCP server support (e.g. JSON configuration) is not available.
## Connecting multiple instances of the same MCP server
You can connect the same MCP server URL multiple times within a project. Each connection operates independently with its own authentication credentials, label, and configuration. Tools from each connection display `(MCP: connection-name)` in their descriptions so Agents can distinguish which connection a Tool belongs to.
This is useful when you need different authentication contexts (e.g. separate user credentials for different data access), environment separation (staging vs production), or multi-tenant setups where each connection uses different tenant credentials.
### Best practices
Choose labels that clearly indicate the purpose or context of each connection, such as `github-prod`, `github-staging`, or `linear-team-a`, `linear-team-b`.
When building Agents that use multiple instances of the same server, include guidance in the Agent's core instructions about when to use Tools from each connection.
## Troubleshooting
* Verify the MCP server URL is correct and the server is online
* Check that any required authentication credentials are entered correctly
* Ensure the external MCP server supports the Streamable HTTP transport
* Confirm the Tools are listed in the Agent's Tools tab after connecting
* Check that the external MCP server has not revoked access or changed credentials
* Try disconnecting and reconnecting the MCP server in the Agent builder
* The external MCP server may be temporarily unavailable — try again later
* Check that the server URL does not require VPN or network access that Relevance AI cannot reach
* For preset connections, try disconnecting and reconnecting to refresh the OAuth token
* Contact the MCP server provider if the issue persists
## Frequently asked questions (FAQs)
You can connect any remote MCP server that supports the Streamable HTTP transport. This includes servers from services like Linear, Notion, GitHub, and any custom MCP servers you host.
Yes. You can add multiple MCP server connections to a single Agent, giving it access to Tools and resources from several external services at once.
You can also connect the same MCP server URL multiple times with different labels and credentials. This is useful for environment separation (staging vs production), different authentication contexts, or multi-tenant setups. See [connecting multiple instances](#connecting-multiple-instances-of-the-same-mcp-server) for details.
No. Relevance AI only supports remote MCP servers accessible via a public URL. Local MCP servers running on your machine (e.g. via JSON configuration) are not supported.
# MCP server
Source: https://relevanceai.com/docs/integrations/mcp/mcp-server
Connect to Relevance AI from Claude Desktop, Cursor, VS Code, ChatGPT, and other MCP-compatible AI clients.
The Relevance AI MCP server gives any MCP-compatible AI client direct access to your agents, tools, and knowledge. Connect from the AI tools you already use and start building.
The MCP server is available at:
```
https://mcp.relevanceai.com/
```
For Claude Code, we recommend using the [Relevance AI plugin](/docs/integrations/mcp/claude-code) instead of a manual MCP connection — it includes built-in skills and context that make the experience significantly better.
This page is about using Relevance AI **from** external AI clients. If you want to connect an external MCP server **to** a Relevance AI agent, see [MCP Client](/docs/integrations/mcp/mcp-client).
***
## Supported clients
1. Open Claude Desktop
2. Go to **Settings** → **Connectors**
3. Click **Add connector**
4. Enter the server URL: `https://mcp.relevanceai.com/`
5. Follow the authentication prompts to connect your Relevance AI project
1. Navigate to the [Connectors page](https://claude.ai/settings/connectors) in Claude.ai
2. Click **Add connector**
3. Enter the server URL: `https://mcp.relevanceai.com/`
4. Follow the authentication prompts
ChatGPT supports MCP servers through Developer Mode, available on Pro, Team, Enterprise, and Edu plans.
1. Open ChatGPT **Settings**
2. Go to **Connectors** → **Advanced** → **Developer Mode**
3. Click **Add connector**
4. Enter the server URL: `https://mcp.relevanceai.com/`
5. Set Authentication to **OAuth** and follow the login flow
Once connected, the Relevance AI tools will be available in both Chat and Deep Research modes.
1. Open Cursor Settings
2. Navigate to the **MCP** tab
3. Click **Add new MCP server**
4. Use the following configuration in your `mcp.json`:
```json theme={null}
{
"mcpServers": {
"relevance-ai": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
}
}
}
```
Add the following to your VS Code settings (`.vscode/mcp.json`):
```json theme={null}
{
"mcpServers": {
"relevance-ai": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
}
}
}
```
Add the following to your Windsurf MCP configuration:
```json theme={null}
{
"mcpServers": {
"relevance-ai": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
}
}
}
```
Register the MCP server, then log in:
```bash theme={null}
codex mcp add relevance-ai --url https://mcp.relevanceai.com/
codex mcp login relevance-ai
```
See the [OpenAI Codex](/docs/integrations/mcp/codex) page for the full setup, including cloning the agent skills.
Add the following to your Zed settings (`settings.json`):
```json theme={null}
{
"language_models": {
"mcp": {
"servers": {
"relevance-ai": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
}
}
}
}
}
```
Add the following MCP configuration in your v0 project settings:
```json theme={null}
{
"mcpServers": {
"relevance-ai": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
}
}
}
```
If you prefer to add the MCP server directly without the plugin:
```bash theme={null}
claude mcp add relevance-prod --transport http https://mcp.relevanceai.com/
```
Once added, run `/mcp` from within Claude Code. You will see the new MCP server in the list. Select it to connect and follow the authentication steps.
For any MCP-compatible client, use the server URL:
```
https://mcp.relevanceai.com/
```
If your client requires an `npx` command, use:
```bash theme={null}
npx -y mcp-remote https://mcp.relevanceai.com/
```
***
## Authentication
When you first connect, you will be prompted to authenticate with your Relevance AI account. Authentication is **per project** — you will be connected to a specific Relevance AI project after logging in.
### Working with multiple projects
If you work across multiple Relevance AI projects, add a separate MCP server entry for each:
```json Cursor theme={null}
{
"mcpServers": {
"relevance-project-1": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
},
"relevance-project-2": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
}
}
}
```
```json VS Code theme={null}
{
"mcpServers": {
"relevance-project-1": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
},
"relevance-project-2": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
}
}
}
```
```json Windsurf theme={null}
{
"mcpServers": {
"relevance-project-1": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
},
"relevance-project-2": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.relevanceai.com/"]
}
}
}
```
Each entry authenticates independently against its own project, so you can access tools and agents across all your projects without logging out and back in.
Alternatively, you can use a single connection and log out / log back in to switch projects — but the multi-connection approach above is preferred for convenience.
***
## Access control
When you authenticate via OAuth, the level of access your MCP session gets depends on your project role. Some roles have a fixed mode; others can opt in to a restriction.
### Run-Only mode
Run-Only mode limits the MCP session to viewing and running existing agents. Write and destructive tools are removed from the tool list server-side — they are not present in the session at all, not merely hidden on the client.
The OAuth consent screen shows a **Run-Only mode** toggle for Member, Editor, and Admin users. The toggle defaults to off (full access). Viewer and Chat users do not see the toggle — their access mode is fixed and cannot be changed.
| Project role | MCP access mode | Configurable? |
| :----------- | :-------------- | :--------------------------------------- |
| Admin | Full access | Yes — opt into run-only at OAuth consent |
| Editor | Full access | Yes — opt into run-only at OAuth consent |
| Member | Full access | Yes — opt into run-only at OAuth consent |
| Viewer | Run-only | No — forced, cannot disable |
| Chat | Chat mode | No — forced, cannot disable |
To guarantee that a user's MCP session cannot create, edit, or delete assets: assign them the Viewer or Chat project role. The restriction is enforced server-side regardless of which MCP client they use.
Chat role users cannot set up dynamic (user-level) OAuth connections via MCP. If an agent requires dynamic authentication, assign the user a Member role in a dedicated project instead.
MCP access is bounded by your project role — the API enforces a ceiling so a session never grants more than the role allows.
***
## Add agent skills
The MCP server gives your AI assistant the ability to call Relevance AI tools, but it doesn't know *how* to use them well. For better results, pair it with the [agent skills](/docs/integrations/mcp/agent-skills) repository — a local reference that teaches your assistant how to work with agents, tools, workforces, knowledge, and more.
***
## Handling long-running agent executions
When triggering agents via MCP, you have two execution modes available depending on how long your agent takes to complete.
### Execution modes
The `relevance_trigger_agent` tool waits for the agent to finish and returns the result directly. It has a 120-second timeout, so use it for agents that complete quickly — single-step agents with minimal tool usage and no workforce nodes.
The `relevance_trigger_agent_async` and `relevance_poll_agent_result` tools work together with no timeout limit. The trigger returns immediately with a conversation ID, which you then poll to check status and retrieve results. Use this for agents with workforce nodes, multi-step chains, external API calls, or any execution expected to exceed 2 minutes.
If you encounter timeout errors with `relevance_trigger_agent`, switch to the async pattern. Agents with workforce nodes should always use async execution.
### Async execution workflow
Call `relevance_trigger_agent_async` with your agent parameters. This returns immediately with a `conversation_id`.
Use `relevance_poll_agent_result` with the `conversation_id` to check the execution status. Poll every 3-5 seconds until the status is `complete` or `failed`.
The status will be `working` or `in progress` while the agent is executing, `complete` when results are available, or `failed` if an error occurred. Once complete, the poll response contains the agent's output.
***
## Troubleshooting
* Make sure you have an active Relevance AI account
* Check that you have access to the project you are trying to connect to
* Try removing and re-adding the MCP server connection
* Verify that you have tools configured in your Relevance AI project
* Check that you are authenticated to the correct project
* Try disconnecting and reconnecting the MCP server
* Ensure you have a stable internet connection
* Check that `https://mcp.relevanceai.com/` is accessible from your network
* Try removing and re-adding the MCP server connection in your client
* Try clearing the auth cache: `rm -rf ~/.mcp-auth`
Timeout errors from `relevance_trigger_agent` mean your agent exceeded the 120-second synchronous limit. Switch to `relevance_trigger_agent_async` and `relevance_poll_agent_result` instead. See [handling long-running agent executions](#handling-long-running-agent-executions) for the full workflow. Agents with workforce nodes, multi-step chains, or complex workflows should always use the async pattern.
***
## Frequently asked questions (FAQs)
The Model Context Protocol (MCP) is an open standard that allows AI clients to connect to external tools and data sources. It provides a standardized way for AI assistants to access your Relevance AI workspace.
The MCP server itself is free. You will be billed for any Relevance AI usage (agent runs, tool executions, etc.) according to your plan.
Yes. You can connect to the Relevance AI MCP server from as many clients as you like simultaneously. Each client authenticates independently.
Authentication tokens may expire after a period of inactivity. If you are prompted to re-authenticate, simply follow the login flow again.
Run-Only mode is the primary way to restrict MCP access. Assign a user the Viewer or Chat project role to force them into a restricted mode automatically — Viewers get run-only access (no write or destructive operations), and Chat users are limited to an even narrower set of tools. Member, Editor, and Admin users can opt into run-only mode from the toggle on the OAuth consent screen. For finer-grained control — such as exposing only a specific subset of agents — organize your tools across separate projects and authenticate each connection to the appropriate project. See [Access control](#access-control) for the full role matrix.
# Airtop
Source: https://relevanceai.com/docs/integrations/popular-integrations/airtop
Connect your Airtop browser automation account with Relevance AI to automate web interactions, data extraction, and browser-based tasks.
Connect your Airtop browser automation platform with Relevance AI to enable web automation capabilities for your AI agents and tools. The Airtop integration allows you to control browser windows, interact with web pages, extract content, and capture screenshots through automated workflows.
## Overview
The Airtop integration enables your AI agents and tools to perform browser automation tasks, including:
* Creating and managing browser windows
* Navigating to web pages and loading URLs
* Interacting with page elements (clicking, typing, scrolling)
* Extracting data from web pages
* Capturing screenshots
* Monitoring pages for specific conditions
This connection enables your agents to interact with websites at scale and with precision.
## Connecting the Integration
To connect the Airtop integration with Relevance AI:
1. Navigate to your Relevance AI dashboard and select **"Integrations & API Keys"** from the main menu.
2. Find and select **"Airtop"** from the available integrations.
3. Click **"Connect"** to begin the authorization process.
4. Provide your Airtop API key:
* Log in to your Airtop account at [Airtop](https://www.airtop.ai/)
* Navigate to the **API** section in your account dashboard
* Click **"Create API Key"** or **"Generate API Key"**
* Provide a descriptive name for your API key (e.g., "Relevance AI Integration")
* Copy the generated API key immediately
5. Paste your API key into the Relevance AI connection form.
6. Click **"Save"** to establish the connection.
API keys are only shown once when created. Make sure to copy and securely store your API key before closing the dialog. If you lose it, you'll need to create a new one.
Once connected, you'll see a confirmation message indicating successful integration. Your Airtop account will be available for use with Airtop browser automation tool steps.
## Use the integration's Tool steps
You can build custom tools that perform browser automation activities using Airtop Tool steps:
1. Create a new tool in Relevance AI.
2. Scroll down to Tool steps.
3. Search for "Airtop" to see all available Airtop browser automation tool steps.
4. Add the desired tool step (e.g., "Airtop - Create Window", "Airtop - Click Element", etc.).
5. Configure the parameters according to your needs.
6. This gives you access to Airtop's browser automation capabilities, allowing you to automate web interactions and data extraction.
You can find detailed information about each Airtop tool step in the [Airtop Browser Automation Tool steps](/docs/build/tools/tool-steps/airtop-browser-automation/window-management) documentation.
## Frequently asked questions (FAQs)
Check Airtop's current pricing plans. Some features may require a paid subscription, while basic browser automation may be available on free tiers. Refer to Airtop's documentation for the most current information.
If you revoke or delete your API key in Airtop, any Relevance AI tools using that integration will stop working. You'll need to create a new API key and update it in Relevance AI to restore functionality.
Yes, once set up, you can use Airtop browser automation tool steps in both Tools and Agents. Agents can call these steps to automate web interactions and data extraction.
# Apollo
Source: https://relevanceai.com/docs/integrations/popular-integrations/apollo
Apollo is a B2B sales intelligence and engagement platform for finding, enriching, and engaging prospects.
Apollo is a B2B sales intelligence and engagement platform with a large database of contacts and companies. With Relevance AI's Apollo integration, you can build agents that search for prospects, enrich contact and organization data, and manage deals — all using your connected Apollo account.
The Apollo integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not Apollo. If you have a question or issue with using Apollo in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about Apollo, you can reach out to Apollo support directly.
## Connect the integration
1. Go to the **Integrations** page in the sidebar of your Relevance AI dashboard.
2. Click on **Apollo** from the available integrations.
3. Click **Add Integration**.
4. Enter your Apollo API key when prompted.
5. Once authenticated, your Apollo account will appear as a connected integration.
You can find your Apollo API key in your Apollo account under **Settings → Integrations → API**. You need at least a Basic plan to access the API.
## Tool steps for Apollo
The Apollo integration provides actions for prospecting, contact management, deal tracking, and data enrichment. These actions can be used as tool steps in your agents' workflows.
### Contact and account management
Search Apollo's database for contacts matching criteria like job title, company, location, or industry.
Create a new contact record in Apollo.
Update an existing contact record with new information.
Search for company accounts in Apollo by name, domain, industry, or other criteria.
Create a new company account record in Apollo.
Update an existing company account record.
### Deal management
Retrieve deals from Apollo, with optional filters by stage, owner, or account.
Create a new deal record in Apollo and associate it with a contact or account.
Update an existing deal's stage, value, or other attributes.
### Person and organization enrichment
Enrich a contact record with data from Apollo's database, including phone numbers, email addresses, job title, and social profiles.
Enrich a company record with firmographic data including employee count, revenue, industry, and technology stack.
Type "Apollo" in the tool step search bar to see all available Apollo actions when building your tools.
## Phone number retrieval
The **Enrich Person** tool step supports phone number retrieval via Apollo's `reveal_phone_number` and `run_waterfall_phone` options. When you enable these options, Relevance AI handles the underlying webhook flow automatically and returns the phone numbers directly in the enrichment response — no additional configuration required on your end.
This means you can use Apollo's phone number enrichment the same way as any other enrichment field, and the result will include phone numbers when Apollo can locate them.
## Use the integration's API tool step (Advanced)
In addition to the pre-built tool steps, you can make custom API calls to any Apollo endpoint using the Apollo API Call tool step.
### How to use the Apollo API Call tool step
Create a new tool in Relevance AI, or open an existing tool you want to add Apollo functionality to.
1. Scroll down to **Tool steps**.
2. Search for **Apollo API Call** in the tool step search bar.
3. Add it to your workflow.
Select your connected Apollo account from the dropdown.
Set the HTTP method, endpoint path, and any request body parameters. Refer to [Apollo's API documentation](https://apolloio.github.io/apollo-api-docs/) for available endpoints and required fields.
Run a test to confirm the call returns the expected data before deploying your agent.
## Example use cases
Build an agent that takes an inbound lead's email or LinkedIn URL, uses Apollo to enrich the contact with job title, phone number, company details, and funding data, then posts a research summary to Slack or updates your CRM before the sales rep's first call.
Create an agent that searches Apollo's database for contacts matching your ideal customer profile — filtering by industry, company size, seniority, and location — then exports the list to a Google Sheet or pushes it into HubSpot as new leads.
Deploy an agent that monitors your CRM for trigger events (e.g., a contact replies to an email) and automatically creates or updates the corresponding deal in Apollo, keeping both systems in sync without manual data entry.
Build an agent that enriches a batch of contacts with Apollo before they enter an outreach sequence, ensuring each contact has a verified phone number and current job title. Contacts missing key data can be flagged for manual review.
## Frequently asked questions (FAQs)
Yes, you need an active Apollo account with API access. Apollo offers a free plan with limited credits, and paid plans with higher limits. You'll need to generate an API key from your Apollo account settings to connect it to Relevance AI.
1. Log in to your Apollo account.
2. Go to **Settings → Integrations → API**.
3. Copy your existing API key or generate a new one.
4. Use this key when connecting Apollo to Relevance AI.
Keep your API key secure and do not share it publicly.
No. When you use the `reveal_phone_number` or `run_waterfall_phone` options in the Enrich Person tool step, Relevance AI manages the webhook flow automatically. Phone numbers are returned directly in the enrichment response when Apollo can locate them.
If Apollo cannot find data for a contact or organization, the enrichment response will be empty or will indicate no match. Design your agent to handle these cases — for example, by trying alternative identifiers, using a fallback data source, or flagging the record for manual review.
Yes, Apollo's enrichment endpoints consume credits from your Apollo plan. Phone number reveal requests consume additional credits depending on your plan. Monitor your Apollo credit usage in your Apollo account dashboard.
# Canva
Source: https://relevanceai.com/docs/integrations/popular-integrations/canva
Elevate your visual content creation capabilities with the Canva integration for Relevance AI.
## Connect the Integration
Setting up the Canva integration with Relevance AI is straightforward:
1. Navigate to the Integrations section in your Relevance AI dashboard
2. Find and select "Canva" from the available integrations
3. Click "Connect"
4. You'll be redirected to Canva to authorize the connection
5. Log in to your Canva account (or create one if needed)
6. Review and approve the permissions requested
7. Once authorized, you'll be redirected back to Relevance AI with the integration active
After connecting, your Relevance AI agents will be able to interact with your Canva account, accessing templates, creating designs, and managing your Canva projects.
## Setting up Triggers
The Canva integration can be configured as a trigger for your AI agents, allowing them to automatically respond to events in your Canva account. This creates powerful workflows where design activities can initiate AI-driven processes.
To set up a Canva trigger *(coming soon)*:
1. Navigate to your agent's configuration page (”Agent profile”)
2. Under "Triggers" choose "Canva" from the available trigger sources
3. Select the specific event you want to trigger your agent:
* New design created
* Design shared with you
* Design comment added
* Design published
4. Configure any additional trigger parameters
5. Save your trigger configuration
With triggers properly configured, your agent can automatically perform tasks like:
* Generating social media copy when a new social post design is created
* Notifying team members when designs are ready for review
* Creating documentation when marketing materials are finalized
* Scheduling content distribution when designs are published
## Tools & Tool Steps
The Canva integration provides a rich set of actions that your agents can use to interact with Canva. These actions can be incorporated into your agent's workflows to automate design-related tasks.
### Available Canva Actions
Your agents can leverage numerous Canva actions, including:
* **Create Design**: Generate new designs from templates or from scratch
* **Edit Design**: Modify existing designs with new text, images, or elements
* **Export Design**: Download designs in various formats (PNG, JPG, PDF)
* **List Templates**: Browse available Canva templates by category
* **Add Brand Kit**: Upload and manage brand assets like logos and colors
* **Schedule Posts**: Plan social media content publication
* **Manage Folders**: Organize designs into project folders
* **Share Design**: Collaborate with team members on designs
* **Add Comments**: Provide feedback on designs
* **Search Elements**: Find graphics, photos, and other design elements
These actions give your agents the ability to handle complex design workflows without manual intervention. For example, an agent could:
1. Create a new social media post from a template
2. Customize it with your brand colors and logo
3. Add text based on marketing copy it generated
4. Export the design in multiple formats
5. Share it with your marketing team for approval
The integration supports a wide range of design types including social media posts, presentations, flyers, business cards, infographics, and many more. Your agents can work with any design format supported by Canva.
## Use the Integration's API Tool Step (Advanced)
For advanced users who need more customized functionality, the Canva API tool step provides direct access to Canva's API capabilities:
1. Create a new tool in Relevance AI
2. Scroll down to Tool-steps
3. Add "Canva API" tool-step
4. Select your connected Canva account in the dropdown
5. Configure the API request with the appropriate endpoint, method, and parameters
6. Test and save your custom tool
Using the API directly allows for more sophisticated interactions with Canva, such as:
* Batch processing multiple designs
* Creating custom design workflows
* Implementing advanced design automation
* Integrating with other services in your workflow
## Related Features
[Knowledge Base Integration](https://relevanceai.com/docs/build/knowledge/create-knowledge) - Store design guidelines, brand assets, and marketing strategies that your agents can reference when creating Canva designs.
[Slack Integration](https://relevanceai.com/docs/integrations/slack) - Connect your design workflow to Slack for seamless team collaboration. Agents can notify team members when designs are ready for review or automatically share completed designs in relevant channels.
[Email Integration](https://relevanceai.com/docs/integrations/outlook) - Enable your agents to send designs directly to clients or team members via email, streamlining the approval and delivery process.
## Best Practices
* **Maintain Brand Consistency**: Store your brand guidelines in a knowledge base for your agents to reference when creating designs
* **Template Organization**: Create and categorize templates in Canva for different use cases to help your agents select the right starting point
* **Clear Instructions**: When requesting designs, provide specific details about the intended audience, purpose, and key messages
* **Approval Workflows**: Set up multi-step approval processes for important designs
* **Asset Management**: Keep your brand assets organized in Canva for easy access by your agents
By integrating Canva with Relevance AI, you can automate design workflows, maintain brand consistency, and scale your visual content creation—all while leveraging the intelligence of your AI agents to deliver compelling visual communications.
# Chrome Extension
Source: https://relevanceai.com/docs/integrations/popular-integrations/chrome-extension
Extract content from any web page and send it directly to an AI agent chat in Relevance AI.
The Relevance AI Chrome Extension lets you extract content from any web page and send it directly to an AI agent chat, without copy-pasting.
Install the extension from the [Chrome Web Store](https://chromewebstore.google.com/detail/relevance-ai/oeejdfhhhceikclacdlikdgfenhehgcp).
### Supported browsers
Any Chromium-based browser that supports Manifest V3 is compatible. Firefox is not supported.
## Installation and setup
### Installing the extension
1. Open the [Chrome Web Store listing](https://chromewebstore.google.com/detail/relevance-ai/oeejdfhhhceikclacdlikdgfenhehgcp) in a supported browser.
2. Click **Add to Chrome** and confirm the prompt.
3. The Relevance AI icon appears in your browser toolbar. Pin it for easy access.
### Signing in
Click the extension icon in your toolbar, then click **Sign in to send to chat**. An OAuth popup opens through `app.relevanceai.com/auth` where you authorize the extension with your Relevance AI account. Tokens are stored locally and refreshed automatically, so you stay signed in across browser sessions.
### Selecting a project and region
After signing in, click your user avatar in the extension popup header to open a dropdown where you can switch projects and regions. Your selection persists across sessions.
## Using the extension
### Main workflow
Navigate to the page you want to extract content from.
Click the toolbar icon, or use the keyboard shortcut: **Mac:** `Cmd+Shift+S` / **Windows/Linux:** `Ctrl+Shift+S`
The extension automatically extracts content from the page and displays it in an editable text area. Edit as needed.
Click **Start new chat** to open a new agent conversation with the content as the first message.
Click **Open in Chat** to jump directly to the conversation in Relevance AI.
### Use the extension without opening the popup
You can also trigger the extension without opening the popup:
1. Right-click anywhere on a page, or right-click on selected text.
2. Choose **Send to Chat** from the context menu.
3. The extension popup opens with content pre-loaded.
While content is pending, a badge notification ("1") appears on the extension icon as a reminder.
## Content extraction
The extension uses a multi-stage extraction pipeline that selects the appropriate method based on the page type.
Extracts name, headline, company, location, about section, experience, education, skills, and profile URL. Handles LinkedIn's single-page app navigation, including iframe-based content.
Uses Mozilla Readability (the same library as Firefox Reader View) to extract the title, author, published date, and body text, plus the canonical URL. Works on most news sites and blog platforms.
Extracts the page title, meta description, body text (up to 4,000 characters), and structured data including JSON-LD and Open Graph tags.
If you have text selected on the page when you open the extension, that selection is included alongside the page extraction.
Extracted content is formatted as markdown and wrapped with metadata before being sent to the agent. When you click **Start new chat**, the extension calls the TriggerWorkforceChat API to create a new conversation, and the extracted content becomes the first message.
The extension cannot extract content from browser-internal pages such as `chrome://`, `about:`, or other extension pages.
## Permissions and network access
Read the current tab's URL and extract page content. Only used when you actively open the extension or trigger it via the context menu.
Adds the **Send to Chat** option to your browser's right-click menu.
Stores authentication tokens, your project selection, and other preferences in local browser storage. Nothing is transmitted to a third party.
Detects tab URL changes to handle LinkedIn's single-page app navigation and the OAuth callback after sign-in.
## Frequently asked questions (FAQs)
Try clicking the refresh button in the content area to re-run extraction. For pages that extract poorly, you can manually edit the content in the text area before sending.
Click your user avatar in the extension popup header and select **Sign out** from the dropdown.
Content is sent directly to your Relevance AI account as the first message in a new agent chat. It is not stored by the extension beyond what is needed to display it in the popup before you send.
The extension creates a new chat session in your selected project. The agent that handles the chat depends on your project configuration in Relevance AI.
# Confluence Cloud
Source: https://relevanceai.com/docs/integrations/popular-integrations/confluence
Confluence is a powerful collaboration platform that helps teams organize, create, and share knowledge.
Confluence is a powerful collaboration platform that helps teams organize, create, and share knowledge. With Relevance AI's Confluence integration, you can seamlessly connect your Confluence workspace to your AI agents, enabling them to access, create, and update Confluence content, making your knowledge management workflows more efficient and intelligent.
The Confluence integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not Atlassian (Confluence's parent company). If you have a question / issue with using Confluence in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question / issue that is only about Confluence, you can [reach out to Atlassian support](https://support.atlassian.com/contact/).
## Connect the integration
Connecting your Confluence account to Relevance AI is a straightforward process:
1. Go to the **Integrations & API Keys** page in the sidebar of your Relevance AI dashboard.
2. Click on "Confluence" from the available integrations.
3. Click on the "Add Integration" button.
4. In the pop-up window, sign into your Atlassian account.
5. Grant the necessary permissions for Relevance AI to access your Confluence workspace.
6. Once authenticated, your Confluence account will appear as a connected integration.
## Tool steps for Confluence
The Confluence integration provides a rich set of actions that your agents can use to interact with your Confluence workspace. These actions can be incorporated into your agent's workflows as tool steps, enabling sophisticated knowledge management capabilities.
## Use the integration's API tool step (Advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform Confluence-specific activities using the Confluence API Call tool step:
1. Create a new tool in Relevance AI.
2. Scroll down to Tool-steps.
3. Add the Confluence API Tool step.
4. Select your connected Confluence account in the dropdown.
5. Configure the API endpoint, method, and parameters according to your needs.
This advanced approach gives you full access to the Confluence REST API, allowing you to implement custom functionality beyond what's available in the standard actions.
**Check API Documentation for Required Headers**
The Confluence API Call Tool step does **not** automatically add headers to your requests. Many Confluence REST API v2 endpoints require the `accept: application/json` header to function properly.
**Always check the [Confluence API documentation](https://developer.atlassian.com/cloud/confluence/rest/v2/intro/) for your specific endpoint** to see which headers are required, and add them manually in the Headers section of the API Call Tool step.
### Adding Required Headers
When using the Confluence API Call Tool step, you must manually add any headers required by the endpoint you're calling. The tool does not add these automatically.
Before configuring your API call, visit the [Confluence REST API documentation](https://developer.atlassian.com/cloud/confluence/rest/v2/intro/) and find your specific endpoint. Look for the "Request" section to see which headers are required.
Many endpoints require the `accept: application/json` header, but requirements vary by endpoint.
In your tool configuration, add the Confluence API Call Tool step and select your connected Confluence account.
Set up your API endpoint and method. For example, to get a page by ID:
* **Method**: GET
* **Endpoint**: `/wiki/api/v2/pages/{id}?body-format=storage`
In the Headers section of the API Call Tool step, add any headers specified in the API documentation. For most Confluence REST API v2 endpoints, this includes:
```json theme={null}
{
"accept": "application/json"
}
```
This header tells the Confluence API to return responses in JSON format. Without it, many endpoints will fail with errors.
**Why is this header needed?**
The `accept: application/json` header tells the Confluence API what format you want the response in. Most REST API v2 endpoints require this header to return data in JSON format, which the tool can then process. Without this header, the API may return an error or data in an unexpected format.
### Example API Call Configurations
Here are examples of calling the Confluence API with both object and array request bodies.
**Use case**: Get a page by ID
This endpoint requires the `accept: application/json` header according to the [Atlassian documentation](https://developer.atlassian.com/cloud/confluence/rest/v2/api-group-page/#api-pages-id-get).
**API Method**: GET
**Endpoint**: `/wiki/api/v2/pages/{id}?body-format=storage`
**Headers** (must be added manually):
```json theme={null}
{
"accept": "application/json"
}
```
**Path Parameters**:
* `id`: The ID of the Confluence page you want to retrieve
**Expected Response**:
```json theme={null}
{
"id": "123456",
"status": "current",
"title": "Page Title",
"spaceId": "789012",
"body": {
"storage": {
"value": "Page content here
",
"representation": "storage"
}
}
}
```
**Use case**: Bulk update page properties
Some Confluence endpoints require array bodies for bulk operations. This example shows updating multiple page properties at once.
**API Method**: PUT
**Endpoint**: `/wiki/api/v2/pages/{id}/properties`
**Headers** (must be added manually):
```json theme={null}
{
"accept": "application/json",
"content-type": "application/json"
}
```
**Body** (array format):
```json theme={null}
[
{
"key": "status",
"value": "reviewed"
},
{
"key": "priority",
"value": "high"
},
{
"key": "last-updated-by",
"value": "automation-bot"
}
]
```
**Path Parameters**:
* `id`: The ID of the Confluence page
This endpoint demonstrates the array body support added in PR #12797. The API Call tool step now accepts both JSON objects `{}` and JSON arrays `[]` as top-level request bodies.
**Best Practice**: Always consult the [Confluence API documentation](https://developer.atlassian.com/cloud/confluence/rest/v2/intro/) for your specific endpoint before configuring your API call. The documentation will specify all required headers, parameters, and request body formats (including whether an object or array is expected).
## Example use cases
Here are some ways you can leverage the Confluence integration with your agents:
1. **Documentation Assistant**: Create an agent that automatically updates technical documentation in Confluence when new features are released or code changes are made.
2. **Knowledge Summarizer**: Build an agent that monitors specific Confluence spaces and creates executive summaries of new content added during the week.
3. **Content Organizer**: Deploy an agent that automatically adds appropriate labels to new Confluence pages based on their content analysis.
4. **Meeting Notes Processor**: Create an agent that takes meeting notes, formats them according to your team's template, and posts them to the relevant Confluence space.
5. **Knowledge Gap Identifier**: Build an agent that analyzes your Confluence content and identifies areas where documentation is missing or outdated.
## Related Features
* Knowledge Integration - Use Confluence as a knowledge source for your agents, enabling them to access and reference your team's documentation when responding to queries.
* Slack Integration - Combine Confluence and Slack integrations to create powerful workflows where agents can update documentation and notify team members about changes.
* Document Processing - Leverage document processing tools alongside Confluence integration to extract, analyze, and organize information from various sources into your knowledge base.
## Frequently asked questions (FAQs)
The integration requires permissions to read and write content, access spaces, and manage page properties in your Confluence workspace. You can review the specific permissions during the authentication process.
Yes, you can configure your tools and triggers to only interact with specific spaces by setting the appropriate filters and parameters.
The most common issue is missing required headers. The API Call Tool does **not** automatically add headers to your requests.
To troubleshoot:
1. **Check the API documentation**: Visit the [Confluence API documentation](https://developer.atlassian.com/cloud/confluence/rest/v2/intro/) for your specific endpoint and verify which headers are required. Most REST API v2 endpoints require `accept: application/json`.
2. **Add headers manually**: In the Headers section of the API Call Tool step, add all required headers as specified in the documentation.
3. **Verify your connection**: Ensure your Confluence account is properly connected in Relevance AI.
4. **Check permissions**: Confirm you have the necessary permissions for the endpoint you're calling.
5. **Validate the endpoint**: Make sure your endpoint URL and parameters are correctly formatted according to the API documentation.
6. **Use the correct API version**: The REST API v2 is recommended for new integrations.
Not necessarily. While many Confluence REST API v2 endpoints require the `accept: application/json` header, requirements vary by endpoint.
**Always check the official [Confluence API documentation](https://developer.atlassian.com/cloud/confluence/rest/v2/intro/)** for your specific endpoint to see which headers are required. The documentation will clearly specify all required headers in the "Request" section of each endpoint.
Remember: The API Call Tool does not add any headers automatically, so you must manually add all required headers specified in the documentation.
The request body format depends on what the specific Confluence API endpoint expects:
* **Object bodies** `{}` are used for most single-item operations (creating a page, updating a single property)
* **Array bodies** `[]` are required for bulk operations or specific endpoints that expect multiple items (like updating multiple page properties at once)
Always check the [Confluence API documentation](https://developer.atlassian.com/cloud/confluence/rest/v2/intro/) for your endpoint to see which format is required. The documentation will show example request bodies in the correct format.
# Content Snare
Source: https://relevanceai.com/docs/integrations/popular-integrations/content-snare
Automate client onboarding, information collection, and document gathering workflows with the Content Snare integration.
Content Snare is a client information gathering and content management platform used by digital agencies, accountants, lawyers, and consultants to streamline collecting documents and information from clients. It eliminates email back-and-forth and reduces information gathering time significantly through structured, trackable requests.
Key concepts in Content Snare:
* **Clients** — individual client profiles that requests are sent to
* **Requests** — customized information collection forms sent to clients
* **Templates** — reusable request structures for repeatable workflows
This is a native OAuth integration. It replaces the older Pipedream-based method and requires no manual API token configuration.
## Connect the integration
Go to the **Integrations** page in your Relevance AI dashboard.
Search for or scroll to **Content Snare** in the integrations list and select it.
Click **Add Integration**.
You will be redirected to Content Snare to authorize access. Log in to your Content Snare account and grant the requested permissions.
Once authorized, you will be redirected back to Relevance AI. The integration will appear as connected and is ready to use.
## Tools & tool steps
The following pre-built tool steps are available once you connect Content Snare.
### Client management
Creates a new client profile in your Content Snare account. Use this when onboarding a new client — typically triggered by a new contact being added to your CRM or a form submission.
Required inputs include the client's name and email address. Optional fields allow you to set additional profile details.
### Request management
Initiates an information collection request and sends it to a specific client. Use this to trigger a document or data gathering workflow — for example, sending a tax document request after a new engagement is created.
You specify the client, the template to use, and any deadline or customization options.
### Advanced
A generic tool step for making direct calls to the Content Snare API. Use this when you need to access an endpoint not covered by the dedicated tool steps — for example, listing existing requests, retrieving client details, or checking request status.
Authentication is handled automatically via OAuth. You provide the HTTP method, endpoint path, and any request body or query parameters.
## Use the integration's API tool step (advanced)
The **Content Snare API Call** tool step gives you access to any endpoint in the Content Snare Partner API. This is useful when the dedicated tool steps don't cover your specific workflow.
### Example: create a client
```json theme={null}
POST /partner_api/v1/clients
{
"name": "Acme Corp",
"email": "contact@acmecorp.com"
}
```
### Example: create a request
```json theme={null}
POST /partner_api/v1/requests
{
"client_id": "abc123",
"template_id": "tmpl_456",
"name": "2024 Tax Documents",
"due_date": "2025-03-31"
}
```
OAuth handles authentication automatically — you do not need to include any authorization headers manually.
Content Snare enforces rate limits of 50 read requests and 20 write requests per 10 seconds. Build in error handling for 429 responses if your workflow sends many requests in quick succession.
For the full list of available endpoints and request/response schemas, see the [Content Snare Partner API documentation](https://api.contentsnare.com/partner_api/v1/documentation).
## Example use cases
Trigger a Content Snare request automatically when a new project is created. Collect brand assets, copy, logins, and briefing documents without chasing clients over email.
Send a tax document request to each client at the start of the filing season. Use templates to standardize what's collected and track completion status across your client list.
Automate intake workflows by sending a Content Snare request when a new matter is opened. Collect identification documents, signed forms, and background information before the first meeting.
Kick off engagements by sending a structured discovery questionnaire. Combine with a CRM integration so requests are sent automatically when a deal moves to a new stage.
### CRM-triggered workflows
Combine Content Snare with CRM integrations such as Salesforce or HubSpot to create end-to-end onboarding automation. When a new contact is created or a deal reaches a certain stage, an agent can create the client in Content Snare and immediately send an information request — with no manual steps required.
## Frequently asked questions
The OAuth flow grants Relevance AI access to create and manage clients and requests in your Content Snare account. The exact scopes are defined by Content Snare's Partner API and cover the operations needed for the available tool steps.
Yes. You can add multiple Content Snare connections from the Integrations page — for example, if you manage separate Content Snare accounts for different business units. Each connection is authorized independently and can be selected when configuring tool steps.
Authentication uses OAuth 2.0 only. There is no option to configure manual API tokens for this integration. If you need to rotate or revoke access, disconnect and reconnect the integration from the Integrations page.
Content Snare returns a 429 status code when rate limits are exceeded (50 read or 20 write requests per 10 seconds). Your tool or agent should handle this response and retry after a short delay. Avoid designing workflows that send large batches of write requests simultaneously.
If the integration fails to connect or becomes disconnected, try removing the integration from the Integrations page and reconnecting. Make sure you are logging in to the correct Content Snare account during the OAuth flow. If the issue persists, [contact Relevance AI support](/docs/get-started/support).
# Fireflies.ai
Source: https://relevanceai.com/docs/integrations/popular-integrations/fireflies
Connect Fireflies.ai to Relevance AI to access meeting transcripts, retrieve meeting data, and upload audio files for transcription
Fireflies.ai is an AI-powered meeting assistant that automatically transcribes, summarizes, searches, and analyzes voice conversations. It works across major video conferencing platforms including Zoom, Google Meet, Microsoft Teams, Webex, and more, providing 90%+ accuracy in transcription.
With the Fireflies integration in Relevance AI, you can access meeting transcripts, retrieve meeting data, and upload audio files for transcription directly within your AI workflows.
## Connect the integration
Connecting your Fireflies.ai account to Relevance AI is a straightforward process:
1. Go to the "Integrations" page in the sidebar of your Relevance AI dashboard.
2. Click on "Fireflies" from the available integrations.
3. Click on the "Add Integration" button.
4. In the pop-up window, sign into your Fireflies.ai account.
5. Grant the necessary permissions for Relevance AI to access your Fireflies.ai data.
6. Once authenticated, your Fireflies.ai account will appear as a connected integration.
## Tool steps for Fireflies
The Fireflies.ai integration provides a set of actions that your agents can use to interact with your meeting transcripts and audio processing. These actions can be incorporated into your agent's workflows as tool steps.
### Meeting Retrieval
Retrieve specific meeting details using a meeting ID
Access the most recent meeting transcripts
### Audio Processing
Upload audio files for transcription
Type "Fireflies" in the tool step search bar to see all available Fireflies.ai actions when building your tools.
## Use the integration's API tool step (Advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform Fireflies-specific activities using the Fireflies API Call tool step.
### How to use the API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add Fireflies.ai functionality to.
1. Scroll down to Tool-steps
2. Search for "Fireflies API Call" in the tool step search bar
3. Add the Fireflies API Call tool step to your workflow
Select your connected Fireflies.ai account from the dropdown menu.
Configure the API endpoint, method, and parameters according to your needs. Fireflies.ai uses a GraphQL API, so you'll typically use POST requests with GraphQL queries.
Test your configuration to ensure it works correctly before deploying.
### Example: Retrieve Meeting Transcript
Here's a practical example of using the Fireflies API Call tool step to retrieve a meeting transcript:
**Configuration**:
```json theme={null}
{
"endpoint": "/graphql",
"method": "POST",
"body": {
"query": "query Transcript($transcriptId: String!) { transcript(id: $transcriptId) { title date sentences { text speaker_name } } }"
}
}
```
This configuration:
* Uses the POST method for GraphQL queries
* Retrieves transcript details including title, date, and speaker-identified sentences
* Returns structured data that can be used in subsequent workflow steps
You can find Fireflies.ai's complete API documentation at [https://docs.fireflies.ai/](https://docs.fireflies.ai/).
### Common API endpoints
The main endpoint for all Fireflies.ai API operations is `/graphql`. Common queries include:
* **Get transcript**: Retrieve full transcript with speaker identification
* **List transcripts**: Get a list of all available transcripts
* **Get user info**: Retrieve current user information
[View API Documentation](https://docs.fireflies.ai/)
## Example use cases
Here are some ways you can leverage the Fireflies.ai integration with your agents:
Automatically send meeting summaries and transcripts to team members after calls, ensuring everyone stays informed even if they couldn't attend.
Extract key information from sales meetings and update your CRM automatically, capturing important details like customer pain points, budget discussions, and next steps.
Identify and create tasks from action items mentioned in meetings, automatically assigning them to the right team members with relevant context.
Aggregate meeting data to track trends, topics, and team engagement over time, helping you understand communication patterns and improve meeting effectiveness.
Maintain searchable archives of important meetings for compliance purposes, with easy retrieval of specific conversations when needed.
Analyze training sessions and onboarding calls to improve processes, identify common questions, and create better training materials.
Automatically extract and categorize customer feedback from support calls and customer meetings to inform product development.
Review sales call transcripts to identify successful patterns, coaching opportunities, and best practices to share across the team.
## Follow along on YouTube
Watch this tutorial to see how to turn meeting notes into content using Fireflies and Relevance AI:
## Frequently asked questions (FAQs)
Fireflies.ai requires access to your meeting recordings and transcripts. The specific permissions depend on your video conferencing platform and Fireflies.ai account settings. Typically, you'll need to grant Fireflies.ai permission to join meetings and access recordings.
Fireflies.ai supports all major video conferencing platforms including:
* Zoom
* Google Meet
* Microsoft Teams
* Webex
* GoToMeeting
* RingCentral
* And many others
It can also transcribe uploaded audio files from any source.
Fireflies.ai provides 90%+ accuracy in transcription, with support for multiple languages and accents. Accuracy may vary based on audio quality, speaker clarity, background noise, and technical terminology.
Yes, you can access historical meetings stored in your Fireflies.ai account using the "Find Meeting by ID" tool step. All meetings that have been transcribed by Fireflies.ai are available through the integration.
Meeting IDs can be found in your Fireflies.ai dashboard. Each transcribed meeting has a unique ID that you can use with the "Find Meeting by ID" tool step.
Rate limits depend on your Fireflies.ai plan. Refer to your Fireflies.ai account settings or contact Fireflies.ai support for specific rate limit information.
Yes, you can add multiple Fireflies.ai integrations to your Relevance AI workspace, each connected to a different Fireflies.ai account.
# Firmable
Source: https://relevanceai.com/docs/integrations/popular-integrations/firmable
Firmable is a B2B sales intelligence platform specializing in Australian and New Zealand markets, providing accurate company and contact data for ANZ businesses.
Firmable is a B2B sales intelligence platform specializing in Australian and New Zealand markets, providing accurate company and contact data for ANZ businesses. With Relevance AI's Firmable integration, you can seamlessly enrich your leads with verified contact and company information specific to the AU/NZ region, enabling your AI agents to automate prospect research, qualify leads, and build comprehensive sales pipelines with locally-verified data.
The Firmable integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not Firmable. If you have a question or issue with using Firmable in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about Firmable, you can [reach out to Firmable support](https://www.firmable.com/contact).
## Connect the integration
Connecting your Firmable account to Relevance AI is a straightforward process:
1. Go to the "Integrations" page in the sidebar of your Relevance AI dashboard.
2. Click on "Firmable" from the available integrations.
3. Click on the "Add Integration" button.
4. Enter your Firmable API key when prompted.
5. Once authenticated, your Firmable account will appear as a connected integration.
You can find your Firmable API key in your Firmable account settings under API Access. If you don't have a Firmable account yet, you can [sign up here](https://www.firmable.com/).
## Tool steps for Firmable
The Firmable integration provides a comprehensive set of actions that your agents can use to enrich leads, find contacts, and gather company intelligence specific to Australian and New Zealand markets. These actions can be incorporated into your agent's workflows as tool steps, enabling sophisticated sales automation and prospect research capabilities for ANZ businesses.
### People Enrichment
Enrich existing contact records with verified email addresses, phone numbers, and professional details using LinkedIn URL, email, or LinkedIn slug
Search for contacts matching specific criteria such as company, position, seniority, or department across Firmable's ANZ database
### Company Intelligence
Enrich company records with firmographic data using LinkedIn, domain, ABN (Australian Business Number), or website
### Advanced API Access
Make custom API calls to access any Firmable API endpoint for advanced use cases
Type "Firmable" in the tool step search bar to see all available Firmable actions when building your tools.
## Use the integration's API tool step (Advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform Firmable-specific activities using the Firmable API Call tool step.
### How to use the Firmable API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add Firmable functionality to.
1. Scroll down to Tool-steps
2. Search for "Firmable API Call" in the tool step search bar
3. Add the Firmable API Call tool step to your workflow
Select your connected Firmable account from the dropdown menu.
Configure the API endpoint, method, and parameters according to your needs:
* **Method**: Select the HTTP method (GET, POST)
* **Endpoint**: Enter the API endpoint path (e.g., `/enrich/person`)
* **Body**: Add any required request body data with search criteria
Test your configuration to ensure it works correctly before deploying.
### Example: Enriching a Contact by LinkedIn URL
Here's a practical example of using the Firmable API Call tool step to enrich a contact using their LinkedIn profile:
**API Endpoint**: `POST /enrich/person`
**Configuration**:
```json theme={null}
{
"method": "POST",
"endpoint": "/enrich/person",
"body": {
"linkedin_url": "https://www.linkedin.com/in/john-doe-au"
}
}
```
This configuration:
* Uses the POST method to request contact enrichment
* Specifies the `/enrich/person` endpoint for individual contact lookup
* Provides the LinkedIn URL as the search parameter
* Returns verified contact information including email addresses, phone numbers, job title, company details, and location data specific to Australian and New Zealand professionals
You can find Firmable's complete API documentation at [https://www.firmable.com/api-documentation](https://www.firmable.com/api-documentation).
### Common Firmable API Endpoints
Here are some commonly used Firmable API endpoints you can use with the API Call tool step:
* **Enrich by LinkedIn URL**: `POST /enrich/person` with `{"linkedin_url": "https://linkedin.com/in/username"}`
* **Enrich by email**: `POST /enrich/person` with `{"email": "user@example.com.au"}`
* **Enrich by LinkedIn slug**: `POST /enrich/person` with `{"linkedin_slug": "john-doe-au"}`
Returns: Email addresses, phone numbers, job title, company, location, and professional details for ANZ contacts
[View API Documentation](https://www.firmable.com/api-documentation)
* **Enrich by domain**: `POST /enrich/company` with `{"domain": "example.com.au"}`
* **Enrich by LinkedIn**: `POST /enrich/company` with `{"linkedin_url": "https://linkedin.com/company/example"}`
* **Enrich by ABN**: `POST /enrich/company` with `{"abn": "12345678901"}`
* **Enrich by website**: `POST /enrich/company` with `{"website": "https://example.com.au"}`
Returns: Company size, industry, location, ABN, employee count, technologies used, and firmographic data for Australian and New Zealand businesses
[View API Documentation](https://www.firmable.com/api-documentation)
* **Search by company**: `POST /search/people` with `{"company": "Acme Corp"}`
* **Search by position**: `POST /search/people` with `{"position": "Sales Manager"}`
* **Search by seniority**: `POST /search/people` with `{"seniority": "Director"}`
* **Search by department**: `POST /search/people` with `{"department": "Marketing"}`
Useful for building prospect lists of decision-makers within target ANZ companies
[View API Documentation](https://www.firmable.com/api-documentation)
* **Combined search criteria**: Use multiple filters together for precise targeting
* **Location filtering**: Target specific Australian states or New Zealand regions
* **Company size filtering**: Focus on SMBs or enterprise accounts
Allows sophisticated prospect discovery across the ANZ market
[View API Documentation](https://www.firmable.com/api-documentation)
## Example use cases
Here are some ways you can leverage the Firmable integration with your agents for Australian and New Zealand markets:
Create an agent that automatically enriches incoming leads from Australian and New Zealand markets with verified contact information. The agent can take a LinkedIn URL, email address, or company ABN, use Firmable to gather phone numbers, job titles, and company details, then update your CRM with the enriched ANZ-specific data.
Build an agent that conducts deep research on Australian businesses before sales calls. Given a company ABN, domain, or LinkedIn profile, the agent uses Firmable to gather company information, key decision-makers, and organizational structure, then compiles a comprehensive research brief tailored to the ANZ market.
Deploy an agent that automatically qualifies Australian leads using ABN lookups. The agent uses Firmable to verify company legitimacy, gather company size and industry data, then scores and routes leads to the appropriate sales representatives based on your ANZ qualification criteria.
Create an agent that builds targeted prospect lists for Australian and New Zealand outbound campaigns. The agent searches Firmable's database for contacts matching your ideal customer profile (job title, company size, industry, location within AU/NZ), enriches the results, and exports them to your sales engagement platform.
Build an agent that maintains data quality for your ANZ contacts in your CRM. The agent identifies incomplete or outdated contact records for Australian and New Zealand businesses, uses Firmable to find current information including ABN verification, and automatically updates your CRM with verified local data.
Deploy an agent that supports ABM campaigns targeting Australian and New Zealand accounts. The agent uses Firmable to identify key decision-makers within target ANZ companies, gather their contact information, and map out the organizational structure for strategic regional outreach.
Create an agent that helps recruiters find and contact qualified candidates in Australia and New Zealand. The agent searches for professionals with specific skills and experience in the ANZ market, uses Firmable to find their contact information, and prepares personalized outreach messages.
Build an agent that identifies and researches potential business partners across Australia and New Zealand. The agent finds companies in complementary industries within the ANZ region, uses Firmable to identify partnership decision-makers, and gathers contact information for cross-border outreach.
## Best practices
**Always ensure compliance with Australian and New Zealand data privacy regulations:**
* Comply with the Australian Privacy Act and New Zealand Privacy Act
* Only use Firmable data for legitimate business purposes
* Include proper opt-out mechanisms in your outreach
* Store enriched data securely and delete when no longer needed
* Review Firmable's terms of service and acceptable use policy
* Respect the Australian Spam Act 2003 and New Zealand's Unsolicited Electronic Messages Act
Firmable provides ANZ-compliant data, but you're responsible for how you use it.
**Optimize your Firmable credit usage:**
* Each enrichment request consumes Firmable credits
* Cache enriched data to avoid duplicate lookups
* Implement logic to check if data already exists before enriching
* Monitor your credit usage through Firmable's dashboard
* Set up alerts when credits are running low
* Prioritize high-value prospects for enrichment
**Maximize the quality of enriched ANZ data:**
* Provide as much information as possible in your search queries (LinkedIn URL + email is better than email alone)
* Validate enriched data before using it in outreach
* Implement fallback logic when Firmable doesn't find a match
* Regularly update enriched data as contact information changes
* Verify ABN numbers for Australian companies to ensure legitimacy
* Consider regional variations in job titles and company structures between AU and NZ
**Leverage Firmable's ANZ market specialization:**
* Use location filters to target specific Australian states or New Zealand regions
* Consider time zones when scheduling outreach (AEST, AEDT, NZST, NZDT)
* Tailor messaging to local business culture and practices
* Use ABN lookups for Australian companies to verify business registration
* Understand the differences between Australian and New Zealand business environments
**Handle API rate limits gracefully:**
* Firmable enforces rate limits to ensure service quality
* Implement retry logic with exponential backoff for rate limit errors
* Distribute enrichment tasks over time for large datasets
* Monitor API response codes and handle errors appropriately
* Contact Firmable support if you need higher limits for enterprise use
## Frequently asked questions (FAQs)
Firmable is a B2B sales intelligence platform specializing in Australian and New Zealand markets. It provides verified contact and company information specifically for ANZ businesses. Using Firmable with Relevance AI allows you to automate lead enrichment, prospect research, and data quality maintenance at scale for the AU/NZ region, with unique features like ABN lookups for Australian companies.
Yes, you need an active Firmable account with API access. You can sign up for Firmable at [https://www.firmable.com/](https://www.firmable.com/). You'll need to generate an API key from your Firmable account settings to connect it to Relevance AI.
To get your Firmable API key:
1. Log in to your Firmable account
2. Navigate to Settings or Account Settings
3. Look for "API Access" or "API Keys"
4. Generate a new API key or copy your existing key
5. Use this key when connecting Firmable to Relevance AI
Keep your API key secure and never share it publicly.
The beta status indicates that while the Firmable integration is fully functional and available for use, we're still gathering user feedback and may make refinements to improve the experience. We recommend testing your workflows thoroughly before deploying them in production. If you encounter any issues or have suggestions, please contact our support team.
An ABN (Australian Business Number) is a unique 11-digit identifier for businesses operating in Australia. Firmable's company enrichment tool can look up Australian companies using their ABN, which is particularly useful for:
* Verifying business legitimacy
* Finding company details for Australian businesses
* Enriching leads with official business registration data
Simply provide the 11-digit ABN in the company enrichment tool step to retrieve comprehensive company information.
Yes, Firmable specializes in both Australian and New Zealand markets. The platform provides comprehensive B2B data for companies and contacts across both countries, making it ideal for businesses targeting the ANZ region. You can filter searches by country or specific regions within AU/NZ.
Credit usage depends on the type of enrichment and the data returned. Typically:
* Person enrichment: 1-2 credits per successful lookup
* Company enrichment: 1 credit per successful lookup
* Search operations: Credits vary based on result volume
Check your Firmable plan details for specific credit allocations and pricing. You can monitor your credit usage in your Firmable dashboard.
If Firmable doesn't find information for a contact or company, the API will return an empty result or indicate no match was found. Your agent should include logic to handle these cases, such as:
* Trying alternative search parameters (e.g., LinkedIn URL instead of email)
* Using fallback data sources
* Flagging the record for manual research
* Skipping to the next record in bulk operations
Not all ANZ contacts are in Firmable's database, so plan for partial match rates.
Yes, but you must comply with all applicable laws and regulations:
* Follow the Australian Spam Act 2003 and New Zealand's Unsolicited Electronic Messages Act
* Include proper identification and opt-out mechanisms
* Only contact people with legitimate business interest
* Respect do-not-contact lists and preferences
* Review Firmable's acceptable use policy
Firmable provides the data, but you're responsible for how you use it in compliance with ANZ regulations.
Firmable maintains high data accuracy through continuous verification and updates specific to Australian and New Zealand markets. However, contact information can change over time. Best practices:
* Use the most recent enrichment data available
* Implement email verification before sending campaigns
* Update your records regularly
* Verify ABN numbers for Australian companies
* Have a process for handling bounced emails or wrong numbers
* Consider that ANZ business data may update less frequently than global databases
Yes! Firmable can enrich LinkedIn profiles for Australian and New Zealand professionals. You can provide a LinkedIn URL or LinkedIn slug to the Firmable people enrichment tool step, and it will return verified contact information including email addresses and phone numbers. This is particularly useful for ANZ sales prospecting and recruitment workflows.
* **Enrichment tool steps**: Used when you have specific identifying information (LinkedIn URL, email, ABN, domain) and want to retrieve that specific contact or company's details
* **Search tool steps**: Used when you want to discover contacts matching certain criteria (company, position, seniority, department) within the ANZ market
Use enrichment for data completion, search for prospecting and list building.
Yes! You can build agents that connect Firmable with popular CRMs like Salesforce, HubSpot, and others available in Relevance AI. Your agent can:
* Pull ANZ contacts from your CRM
* Enrich them with Firmable
* Update the CRM with enriched data including ABN numbers
* All automatically on a schedule or trigger
Check our [integrations page](/docs/integrations/introduction) for available CRM connections.
Yes, Firmable enforces rate limits to ensure service quality for all users. The specific limits depend on your Firmable plan. If you hit rate limits:
* Your agent will receive a rate limit error
* Implement retry logic with delays
* Distribute enrichment tasks over time
* Contact Firmable support if you need higher limits
Design your workflows to handle rate limits gracefully.
# Freshdesk
Source: https://relevanceai.com/docs/integrations/popular-integrations/freshdesk
Interact with your Freshdesk with Relevance.
Connect your Freshdesk customer support platform with Relevance AI to supercharge your support operations with intelligent automation. The Freshdesk integration enables your AI agents to handle support tickets, respond to customer inquiries, and streamline your customer service workflow.
## Overview
The Freshdesk integration allows you to connect your Freshdesk account with Relevance AI, enabling your AI agents to interact with your customer support platform. This powerful connection transforms how you handle support tickets by automating responses, categorizing issues, and providing intelligent assistance to both customers and support teams.
With this integration, you can build AI agents that monitor your Freshdesk tickets, respond to common inquiries automatically, escalate complex issues to human agents, and maintain a seamless support experience across your organization.
## Connecting the Integration
To connect the Freshdesk integration with Relevance AI:
1. Navigate to your Relevance AI dashboard and select **Integrations & API Keys** from the main menu.
2. Find and select "Freshdesk" from the available integrations.
3. Click "Connect" to begin the authorization process.
4. Enter your Freshdesk domain (e.g. yourcompany.freshdesk.com).
5. Provide your Freshdesk API key:
* Log in to your Freshdesk account.
* Go to your profile settings.
* Find your API key in the "API Settings" section.
* Copy the API key.
6. Paste your API key into the Relevance AI connection form.
7. Click "Authorize" to establish the connection.
8. Once connected, you'll see a confirmation message indicating successful integration.
## Setting Up Triggers
You can also trigger your Agent using Freshdesk. To do this, head to your Agent and click 'Triggers', then select the 'Freshdesk' Trigger.
## Use the integration's API tool step (advanced)
You can build custom tools that perform Freshdesk-specific activities using the Freshdesk API Call tool step:
1. Create a new tool in Relevance AI.
2. Scroll down to Tool steps.
3. Add the Freshdesk API Tool step.
4. Select your connected Freshdesk account in the dropdown.
5. Configure the API endpoint, method, and parameters according to your needs.
6. This advanced approach gives you full access to the Freshdesk REST API, allowing you to implement custom functionality
You can find Freshdesk's API documentation [here](https://developers.freshdesk.com/api/#introduction).
# GitHub
Source: https://relevanceai.com/docs/integrations/popular-integrations/github
GitHub is the world's leading platform for version control and collaborative software development.
GitHub is the world's leading platform for version control and collaborative software development. With Relevance AI's GitHub integration, you can connect your GitHub repositories to your AI agents, enabling them to manage code, issues, pull requests, and workflows. Your agents can also respond automatically to GitHub events like new issues, pull requests, commits, and more through instant webhook triggers.
The GitHub integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not GitHub. If you have a question or issue with using GitHub in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about GitHub, you can [reach out to GitHub support](https://support.github.com/).
## Connect the integration
Connecting your GitHub account to Relevance AI is a straightforward process:
1. Go to the "Integrations" page in the sidebar of your Relevance AI dashboard.
2. Click on "GitHub" from the available integrations.
3. Click on the "Add Integration" button.
4. In the pop-up window, sign into your GitHub account.
5. Grant the necessary permissions for Relevance AI to access your GitHub repositories.
6. Once authenticated, your GitHub account will appear as a connected integration.
## Triggers for GitHub
The GitHub integration allows you to set up triggers that automatically activate your AI agents when specific events occur in your repositories. Most GitHub triggers are **instant** (webhook-based), meaning your agents respond in real-time as soon as events happen — whether it's a new issue being opened, a pull request being merged, or a workflow run completing. This enables event-driven automation that keeps your development workflows moving without manual intervention.
The following trigger options are available, organized by category:
Monitor changes at the repository level.
* **New repository (Instant)** — Triggers when a new repository is created in your account or organization. Useful for applying default settings, adding collaborators, or creating initial issues.
* **New fork (Instant)** — Triggers when someone forks your repository. Use this to track adoption, send welcome messages, or log fork activity.
* **New star (Instant)** — Triggers when a user stars your repository. Ideal for tracking growth milestones or sending thank-you notifications.
* **New watcher (Instant)** — Triggers when a user starts watching your repository for notifications.
* **New tag (Instant)** — Triggers when a new tag is pushed to a repository. Useful for initiating release workflows or changelog generation.
Respond to activity on issues and pull requests.
* **New issue (Instant)** — Triggers when a new issue is opened. Perfect for auto-labeling, assigning issues to the right team member, or sending acknowledgment replies.
* **Updated issue (Instant)** — Triggers when an issue is modified (title, body, labels, assignees, or status). Use this to sync issue state with external project management tools.
* **New pull request (Instant)** — Triggers when a pull request is opened or ready for review. Ideal for starting automated code review, running checks, or notifying reviewers.
* **Updated pull request (Instant)** — Triggers when a pull request is modified or changes state (e.g., converted to draft, marked ready, or closed).
* **New comment (Instant)** — Triggers when a comment is added to an issue or pull request. Useful for extracting action items, detecting questions, or routing feedback.
* **New label on issue (Instant)** — Triggers when a label is applied to an issue. Use this to route issues into category-specific workflows.
* **New review request (Instant)** — Triggers when a reviewer is requested on a pull request. Useful for notifying reviewers or starting pre-review automation.
* **New pull request review (Instant)** — Triggers when a review is submitted on a pull request (approved, changes requested, or commented).
React to new code activity in your repositories.
* **New commit (Instant)** — Triggers when a new commit is pushed to any branch. Use this to run linting, update changelogs, or notify downstream systems.
* **New push (Instant)** — Triggers on any push to a repository, including multiple commits. Useful for triggering CI/CD steps or deployment checks.
* **New branch (Instant)** — Triggers when a new branch is created. Ideal for setting up branch-specific configurations or notifying the team.
Monitor GitHub Actions activity.
* **Workflow run completed (Instant)** — Triggers when a GitHub Actions workflow run finishes, whether it succeeded, failed, or was cancelled. Use this to send alerts on failure or trigger post-deployment steps.
* **Workflow job completed (Instant)** — Triggers when an individual job within a workflow run completes. Useful for fine-grained monitoring of CI pipeline steps.
Track team and contributor activity.
* **New collaborator (Instant)** — Triggers when a collaborator is added to a repository. Useful for onboarding automation or access auditing.
* **New mention (Instant)** — Triggers when your account is mentioned in an issue, pull request, or comment. Use this to route mentions to the right team or create follow-up tasks.
Automate workflows around GitHub Projects.
* **Project item status changed (Instant)** — Triggers when the status of an item in a GitHub Project (v2) changes. Use this to sync project state with external tools or notify stakeholders.
* **New card in column (Instant)** — Triggers when a card is added to a specific column in a classic GitHub Project board.
Additional triggers for releases, gists, and discussions.
* **New release (Instant)** — Triggers when a new release is published. Ideal for triggering release announcement workflows or documentation updates.
* **New gist (Instant)** — Triggers when a new gist is created in your account. Use this to catalog or share snippets automatically.
* **New discussion (Instant)** — Triggers when a new discussion is opened in a repository. Useful for monitoring community activity or routing questions to support.
* **New discussion comment (Instant)** — Triggers when a comment is added to a discussion. Use this to detect follow-up questions or escalate unresolved topics.
## Tool steps for GitHub
The GitHub integration provides a comprehensive set of actions that your agents can use to interact with your repositories and development workflows. These actions can be incorporated into your agent's workflows as tool steps, enabling sophisticated development automation capabilities.
### Repository management
Create a new GitHub repository
Retrieve information about a repository
Access files and folders in a repository
Star a repository
### Branch & commit operations
Create a new branch in a repository
Retrieve details about a specific commit
List commits in a repository
Create new files or update existing ones
### Issue management
Create a new issue in a repository
Add a comment to an existing issue
Update an existing issue
Retrieve assignees for an issue
Search for issues and PRs across repositories
### Pull request operations
Create a new pull request
Get reviewers for a pull request
Update the status of a project item
### Workflow automation
Trigger a workflow run
Enable a GitHub Actions workflow
Disable a GitHub Actions workflow
Get details about a workflow run
List workflow runs for a repository
### Gist management
Create a new gist
Update an existing gist
List all gists for a user
### Release management
List releases for a repository
Type "GitHub" in the tool step search bar to see all available GitHub actions when building your tools.
## Use the integration's API tool step (advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform GitHub-specific activities using the GitHub API Call tool step.
**Required Header:** When using the GitHub API Call tool step, you must include the header `accept: application/vnd.github+json` or you may encounter errors like `'Please enter a value for 'response_body' field'`.
### How to use the GitHub API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add GitHub functionality to.
1. Scroll down to Tool-steps
2. Search for "GitHub API Call" in the tool step search bar
3. Add the GitHub API Call tool step to your workflow
Select your connected GitHub account from the dropdown menu.
Configure the API endpoint, method, and parameters according to your needs:
* **Method**: Select the HTTP method (GET, POST, PUT, DELETE, PATCH)
* **Endpoint**: Enter the API endpoint path (e.g., `/repos/{owner}/{repo}/collaborators/{username}`)
* **Body**: Add any required request body data
**This is the critical step!** In the Headers section, add:
```json theme={null}
{
"accept": "application/vnd.github+json"
}
```
This header tells GitHub's API what format to return the response in. Without it, the API may not return a properly formatted response, causing errors in your tool.
Test your configuration to ensure it works correctly before deploying.
### Example: Managing repository collaborators
Here's a practical example of using the GitHub API Call tool step to add a collaborator to a repository:
**API Endpoint**: `PUT /repos/{owner}/{repo}/collaborators/{username}`
**Configuration**:
```json theme={null}
{
"method": "PUT",
"endpoint": "/repos/myorg/myrepo/collaborators/johndoe",
"headers": {
"accept": "application/vnd.github+json"
},
"body": {
"permission": "push"
}
}
```
This configuration:
* Uses the PUT method to add or update a collaborator
* Specifies the repository owner, name, and collaborator username
* **Includes the required `accept` header**
* Sets the permission level to "push" (can also be "pull", "triage", "maintain", or "admin")
You can find GitHub's complete API documentation at [https://docs.github.com/en/rest](https://docs.github.com/en/rest).
### Common GitHub API endpoints
Here are some commonly used GitHub API endpoints you can use with the API Call tool step:
* **Check permissions**: `GET /repos/{owner}/{repo}/collaborators/{username}/permission`
* **Add collaborator**: `PUT /repos/{owner}/{repo}/collaborators/{username}`
* **Remove collaborator**: `DELETE /repos/{owner}/{repo}/collaborators/{username}`
[View API documentation](https://docs.github.com/en/rest/collaborators/collaborators)
* **Get contents**: `GET /repos/{owner}/{repo}/contents/{path}`
* **Create/update file**: `PUT /repos/{owner}/{repo}/contents/{path}`
* **Delete file**: `DELETE /repos/{owner}/{repo}/contents/{path}`
[View API documentation](https://docs.github.com/en/rest/repos/contents)
* **List issues**: `GET /repos/{owner}/{repo}/issues`
* **Get issue**: `GET /repos/{owner}/{repo}/issues/{issue_number}`
* **Create issue**: `POST /repos/{owner}/{repo}/issues`
* **Update issue**: `PATCH /repos/{owner}/{repo}/issues/{issue_number}`
[View API documentation](https://docs.github.com/en/rest/issues/issues)
* **List PRs**: `GET /repos/{owner}/{repo}/pulls`
* **Get PR**: `GET /repos/{owner}/{repo}/pulls/{pull_number}`
* **Create PR**: `POST /repos/{owner}/{repo}/pulls`
* **Update PR**: `PATCH /repos/{owner}/{repo}/pulls/{pull_number}`
* **Merge PR**: `PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge`
[View API documentation](https://docs.github.com/en/rest/pulls/pulls)
* **List branches**: `GET /repos/{owner}/{repo}/branches`
* **Get branch**: `GET /repos/{owner}/{repo}/branches/{branch}`
* **Create branch**: `POST /repos/{owner}/{repo}/git/refs`
[View API documentation](https://docs.github.com/en/rest/branches/branches)
**Remember**: Always include the `accept: application/vnd.github+json` header in your API calls!
## Example use cases
Here are some ways you can use the GitHub integration with your agents:
When the New Issue trigger fires, an agent analyzes the issue content and automatically applies labels (bug, feature request, documentation), assigns it to the appropriate team member based on the affected area, and posts an initial response with relevant links or questions — all before a human has seen it.
When the New Pull Request trigger fires, an agent reviews the diff for common issues — security vulnerabilities, missing tests, style violations — and posts inline comments with specific suggestions. The agent can request changes or approve based on configurable thresholds.
When the Workflow Run Completed trigger fires with a failed status, an agent posts a summary to your team's chat channel, links to the failed job logs, and creates a GitHub issue with reproduction steps if the same workflow has failed multiple times in a row.
Create an agent that reviews pull requests, checks for common issues, adds comments with suggestions, and requests changes when necessary. The agent can analyze code quality, security vulnerabilities, and adherence to coding standards.
Deploy an agent that automatically generates comprehensive release notes by analyzing commits, pull requests, and issues between releases, formatting them according to your team's standards.
Create an agent that performs routine maintenance tasks like closing stale issues, updating dependencies, archiving old branches, and ensuring repository settings comply with organizational policies.
Build an agent that automates developer onboarding by creating repositories from templates, setting up branch protection rules, adding team members with appropriate permissions, and creating initial issues for setup tasks.
Deploy an agent that keeps documentation in sync across multiple repositories, automatically updates README files when changes are detected, and ensures documentation standards are maintained.
Create an agent that monitors repositories for security compliance, checks for exposed secrets, ensures branch protection is enabled, and alerts teams when security policies are violated.
Build an agent that orchestrates complex GitHub Actions workflows, triggers deployments based on specific conditions, monitors workflow runs, and handles failures with automatic retries or notifications.
## Frequently asked questions (FAQs)
The integration requires permissions to read and write to repositories, manage issues and pull requests, and access workflow information. You can review the specific permissions during the authentication process. You can also configure fine-grained access tokens in GitHub to limit access to specific repositories.
This error typically occurs when the required `accept: application/vnd.github+json` header is missing from your GitHub API Call tool step. Make sure to add this header in the Headers section of your API call configuration.
**Solution**: Add the following header to your API call:
```json theme={null}
{
"accept": "application/vnd.github+json"
}
```
Yes, you can configure your tools and triggers to only interact with specific repositories by setting the appropriate repository parameters. Additionally, you can use GitHub's fine-grained personal access tokens to limit access at the GitHub level.
When you connect your GitHub account through the Integrations page, Relevance AI handles authentication automatically. When using the GitHub API Call tool step, simply select your connected GitHub account from the dropdown, and authentication will be handled for you.
Pre-built tool steps (like "Create Issue" or "Create Pull Request") are designed for specific, common tasks and have simplified interfaces with guided inputs. The GitHub API Call tool step gives you full access to GitHub's REST API, allowing you to implement any functionality available in the API, including advanced or custom operations not covered by pre-built steps.
Yes. The GitHub integration includes instant (webhook-based) triggers that activate your agents when specific events occur in your repositories — such as new pull requests, issues, or commits. Set up these triggers directly from the Triggers section in Relevance AI; no manual webhook configuration in GitHub is required.
Yes, GitHub enforces rate limits on API calls. For authenticated requests, the limit is typically 5,000 requests per hour. Your agents should be designed to handle rate limiting gracefully. You can check your current rate limit status using the `/rate_limit` endpoint.
The GitHub integration is designed to work with GitHub.com. For GitHub Enterprise Server installations, you may need to use the generic API Tool step with custom authentication. Contact our support team for assistance with GitHub Enterprise configurations.
# Gmail
Source: https://relevanceai.com/docs/integrations/popular-integrations/gmail
Connect and create emails with Relevance AI's Gmail integration
## Overview
Connect your Gmail account to Relevance AI and supercharge your email workflow with AI agents that can read, respond to, and take action on your emails. The Gmail integration enables you to automate email-related tasks, create powerful workflows, and save valuable time.
## Connect the integration
Setting up the Gmail integration with Relevance AI is straightforward:
1. Go to the **Integrations & API Keys** page in the sidebar of your Relevance AI dashboard.
2. Click on "Gmail" from the available integrations.
3. Click the "Add Integration" button.
4. In the pop-up window, sign into your Gmail account and authorize Relevance AI to access your emails.
5. Follow any additional prompts to complete the connection process.
6. Once connected, you'll see your Gmail account listed under connected integrations.
## Setting up triggers
The Gmail integration allows you to set up triggers that automatically activate your AI agents when specific email events occur. This enables your agents to respond to emails in real-time without manual intervention.
To set up Gmail as a trigger:
1. Create or edit an agent in Relevance AI.
2. Navigate to the "Triggers" section in "Agent Profile".
3. Select "Gmail" as the trigger source.
4. Configure the trigger conditions based on your needs:
* **New Email**: Trigger when any new email arrives in your inbox
* **Emails with Specific Labels**: Trigger only for emails with certain Gmail labels
* **Emails from Specific Senders**: Trigger for emails from particular email addresses
* **Emails with Specific Subject Lines**: Trigger based on keywords in subject lines
* **Unread Emails**: Trigger only for unread messages
5. Set the frequency of checking for new emails (e.g., immediately, every 5 minutes, hourly).
6. Save your trigger configuration.
Once set up, your agent will automatically start working whenever the specified email conditions are met, allowing for seamless email automation.
## Tools & Tool Steps
The Gmail integration provides a rich set of actions that your AI agents can use to interact with your email account. These actions can be incorporated into your agent's workflow to perform various email-related tasks.
Here are some of the key Gmail actions available:
### Read Emails
* **Get Email Content**: Retrieve the full content of specific emails
* **Search Emails**: Find emails matching specific criteria
* **Get Email Attachments**: Access files attached to emails
* **Get Email Metadata**: Extract information like sender, recipients, date, etc.
* **Get Email Thread**: Retrieve entire conversation threads
### Compose and Send Emails
* **Send Email**: Create and send new emails
* **Reply to Email**: Respond to existing email threads
* **Forward Email**: Forward messages to other recipients
* **Draft Email**: Create draft emails without sending
* **Schedule Email**: Compose emails to be sent at a later time
### Email Management
* **Apply Labels**: Organize emails with Gmail labels
* **Mark as Read/Unread**: Change the read status of emails
* **Archive Email**: Move emails out of the inbox
* **Move to Folder**: Organize emails into different folders
* **Delete Email**: Remove unwanted emails
* **Star/Flag Email**: Mark important emails for follow-up
### Advanced Actions
* **Extract Information**: Parse email content for specific data
* **Analyze Sentiment**: Determine the tone and sentiment of emails
* **Categorize Emails**: Automatically sort emails by type or priority
* **Set Reminders**: Create follow-up reminders for important emails
* **Create Tasks**: Generate tasks based on email content
These are just some examples of the many actions available. The Gmail integration is highly versatile, allowing your agents to perform virtually any task you would normally do manually in your Gmail account.
## Use the integration's API tool step (advanced)
For more advanced use cases, you can leverage the Gmail API directly using the Gmail API Call tool step:
1. Create a new tool in Relevance AI.
2. Scroll down to Tool-steps.
3. Add the Gmail API tool-step.
4. Select your connected Gmail account in the dropdown.
With the Gmail API tool step, you can:
1. **Access Advanced Gmail Features**: Utilize Gmail API endpoints not covered by standard actions
2. **Custom Email Processing**: Create specialized workflows for unique email handling requirements
3. **Batch Operations**: Perform actions on multiple emails simultaneously
4. **Complex Filtering**: Implement sophisticated email filtering logic
5. **Integration with Other Services**: Connect your email workflows with other tools and platforms
### Example: Custom Email Processing with Gmail API
Here's an example of using the Gmail API tool step to implement a custom email processing workflow:
```json theme={null}
// Example of using Gmail API to process emails with specific criteria
{
"method": "GET",
"endpoint": "users/me/messages",
"params": {
"q": "is:unread from:important-client@example.com",
"maxResults": 10
}
}
```
This API call retrieves up to 10 unread emails from a specific sender, which your agent can then process according to your business rules.
## Frequently asked questions (FAQs)
Relevance AI requires permission to read, send, and manage your emails to provide full functionality. You can review these permissions during the connection process.
Yes, you can connect multiple Gmail accounts to Relevance AI and configure different agents to work with specific accounts.
Yes, Relevance AI maintains strict security protocols. Your email data is encrypted and only accessed as needed for the functions you authorize.
Yes, you can configure triggers and actions to work only with specific labels, senders, or other criteria to limit the scope of emails your agent processes.
Yes, emails sent by your agent will appear in your Gmail sent folder, maintaining a complete record of all communications.
## Gmail Assistant
The Gmail Assistant is a pre-built agent available from the [Marketplace](https://app.relevanceai.com/marketplace) that handles email tasks through plain English. Search, send, organize, and manage your inbox through simple conversation — no manual clicking through Gmail required.
Search "Gmail Assistant" in the Marketplace to clone it and start managing your inbox through conversation
# Gong
Source: https://relevanceai.com/docs/integrations/popular-integrations/gong
Connect Gong to Relevance AI to access call recordings, transcripts, and revenue intelligence data.
Gong is a revenue intelligence platform that records, transcribes, and analyzes sales calls and customer conversations. It surfaces insights from your team's interactions to help you understand deal health, coaching opportunities, and customer sentiment.
With the native Gong integration in Relevance AI, your agents can retrieve call data, pull transcripts, and interact with Gong's API directly — without any third-party connectors.
## Connect the integration
1. Go to the **Integrations & API Keys** page in the sidebar of your Relevance AI dashboard.
2. In the **Integrations** section, search for **Gong**.
3. Click **Gong** — the native integration with the blue tick.
4. In the pop-up window, sign into your Gong account and authorize the requested permissions.
5. Once authenticated, your Gong account appears as a connected integration.
You need a Gong account with API access enabled. Gong API access typically requires Technical Admin permissions — check with your Gong administrator if you cannot complete the authorization.
## Tool steps for Gong
The Gong integration provides a range of tool steps that your agents can use to interact with your call data and Engage flows. Add these to any tool in the tool builder by searching for "Gong" in the tool step search bar.
Select a category below, then expand any tool step to see what it does.
Retrieve a list of calls from your Gong account, filterable by date range, participants, and other criteria.
Fetch detailed metadata and analytics for a specific call, including duration, participants, talk ratios, and engagement metrics.
Pull the full transcript for a call, with speaker-identified turns and timestamps.
Add a call record to Gong, such as uploading recordings from other platforms or logging external conversations.
Retrieve the Gong Engage flows in your account.
Retrieve the folders that organize your Gong Engage flows.
Add prospects to a Gong Engage flow.
See which flows a set of prospects are currently assigned to.
Remove prospects from a flow using their CRM ID.
Remove prospects from a flow using the flow instance ID.
Call a specific Gong API endpoint.
Make any request to the Gong REST API. Use this when you need functionality beyond the pre-built tool steps.
### How to add a tool step
Type "Gong" in the tool step search bar to see all available Gong actions when building your tools.
## Frequently asked questions (FAQs)
You need a Gong account with API access. In most organizations, this requires Technical Admin permissions in Gong. Contact your Gong administrator if the OAuth authorization fails or you do not see an API access option in your Gong settings.
Yes. You can add multiple Gong integrations to your Relevance AI workspace, each authenticated with a different Gong account.
If you previously used Pipedream-based Gong actions, migrate to the native tools — they offer the same functionality with a simpler OAuth-based connection. Connect the native Gong integration via OAuth (see steps above), then replace any Pipedream-based Gong tool steps in your tools with the equivalent native tool steps. The native tools do not require a separate Pipedream account.
Native tool steps have a blue tick beside them in the tool step search bar. Use these in preference to the Pipedream-based actions.
The integration can only access calls that have already been processed and indexed in Gong. There is typically a short delay after a call ends before it is available via the API. Real-time call access is not supported.
Gong enforces API rate limits based on your Gong plan and usage tier. If you encounter rate limit errors, reduce the frequency of API calls or contact Gong support to review your limits.
# Google Analytics (GA4)
Source: https://relevanceai.com/docs/integrations/popular-integrations/google-analytics
Connect Google Analytics 4 to Relevance AI to automate reporting, track conversions, and manage properties with AI agents
Google Analytics 4 (GA4) is Google's analytics platform for measuring traffic, engagement, and conversions across your websites and apps. With the Google Analytics integration in Relevance AI, you can connect your GA4 properties to AI agents that run custom reports, create key events for conversion tracking, manage properties programmatically, and query the GA4 APIs directly.
This integration is built by Relevance AI. For integration-specific support, contact [Relevance AI support](/docs/get-started/support). For Google Analytics platform issues, visit [Google Analytics Help](https://support.google.com/analytics).
## Connect the integration
The Google Analytics integration uses OAuth to authenticate with your Google account. You only need to complete this process once per Google account.
Select **Integrations & API Keys** from the left sidebar in your Relevance AI dashboard.
Browse the integrations directory and click on **Google Analytics**.
Click the **Connect** button to start the OAuth flow.
You'll be redirected to Google's authentication page. Select the Google account that has access to the GA4 properties you want to use.
Review the permissions Relevance AI is requesting. These are needed to read analytics data and manage your GA4 properties on your behalf.
Click **Allow** to grant access. You'll be redirected back to Relevance AI.
Your Google Analytics account will now appear as connected in the Integrations dashboard and will be available for use in your agents and tools.
You can connect multiple Google accounts if you manage GA4 properties across different Google logins. Each connected account appears separately in the integrations list.
Your Google account must have at least **Viewer** access to the GA4 properties you want to query. To create properties or key events, you need **Editor** or **Administrator** access on those properties.
## Tools & tool steps
The Google Analytics integration provides four tool steps that your agents can use. Search for "Google Analytics" in the tool step search bar when building your tools.
### Run Reports
Retrieve analytics data from a GA4 property by specifying metrics (quantitative measurements) and dimensions (data categories). Use this to pull traffic data, engagement stats, conversion counts, or any other GA4 report data into your agent workflows.
**Key inputs:**
* **Property ID**: The GA4 property to query (e.g., `properties/123456789`)
* **Metrics**: What to measure — for example, `sessions`, `activeUsers`, `conversions`, `screenPageViews`
* **Dimensions**: How to break down the data — for example, `date`, `country`, `sessionSource`, `pagePath`
* **Date range**: The time period to report on
* **Filters**: Optional dimension or metric filters to narrow results
**What are metrics and dimensions?**
In GA4, *metrics* are numeric values (how much, how many), and *dimensions* are attributes used to categorize or segment that data. For example, `sessions` is a metric and `country` is a dimension — together they give you sessions by country.
### Create Key Events
Create a key event in a GA4 property. Key events mark the actions that matter most to your business — they were called "conversions" in Universal Analytics (UA) and earlier versions of GA4. Creating a key event tells GA4 to highlight that event in reports and use it as a conversion signal.
**Key inputs:**
* **Property ID**: The GA4 property to add the key event to
* **Event name**: The name of the existing GA4 event to mark as a key event (e.g., `purchase`, `sign_up`, `generate_lead`)
**Note:** The event must already be collected in your GA4 property before it can be designated as a key event. You cannot create an event and mark it as a key event in the same step.
### Create GA4 properties
Create a new Google Analytics 4 property programmatically. This is useful when you're provisioning GA4 tracking for new client websites, new app launches, or when you manage analytics at scale across many sites.
**Key inputs:**
* **Display name**: The name for the new property
* **Time zone**: The reporting time zone for the property
* **Currency code**: The currency used for revenue metrics (e.g., `USD`, `EUR`)
* **Industry category**: The industry the property belongs to (optional, used for benchmarking)
**Note:** You must have **Administrator** access in the Google Analytics account where the property will be created. Properties are created under your Google Analytics account, not under a specific website — you'll still need to set up a data stream separately to start collecting data.
### Google Analytics API Call
Make a custom API call to any Google Analytics Data API or Admin API endpoint. Use this when the pre-built tool steps don't cover your specific use case.
This tool step handles OAuth authentication automatically, so you don't need to manage access tokens. See the [advanced section below](#use-the-google-analytics-api-tool-step-advanced) for full usage details and examples.
## Use the Google Analytics API Tool Step (Advanced)
For use cases beyond the pre-built tool steps, the Google Analytics API Call tool step gives you direct access to both the [GA4 Data API](https://developers.google.com/analytics/devguides/reporting/data/v1) and the [GA4 Admin API](https://developers.google.com/analytics/devguides/config/admin/v1).
### How to use the Google Analytics API Call tool step
Create a new tool in Relevance AI or open an existing one you want to add Google Analytics functionality to.
Scroll down to **Tool-steps**, search for "Google Analytics API", and add the **Google Analytics API Call** tool step to your workflow.
Choose your connected Google Analytics account from the dropdown.
Set the HTTP method, endpoint path, and request body:
* **Method**: The HTTP method (`GET`, `POST`, `DELETE`, etc.)
* **Endpoint**: The API path, starting from the base URL (e.g., `v1beta/properties/123456789:runReport`)
* **Body**: The JSON request body (for POST requests)
Run a test to confirm the API call returns the expected data before using it in production.
### Example: Run a custom report
This example retrieves the top 10 pages by page views for the past 30 days.
**API**: `POST https://analyticsdata.googleapis.com/v1beta/properties/{propertyId}:runReport`
```json theme={null}
{
"method": "POST",
"endpoint": "v1beta/properties/123456789:runReport",
"body": {
"dateRanges": [
{ "startDate": "30daysAgo", "endDate": "today" }
],
"dimensions": [
{ "name": "pagePath" }
],
"metrics": [
{ "name": "screenPageViews" }
],
"orderBys": [
{
"metric": { "metricName": "screenPageViews" },
"desc": true
}
],
"limit": 10
}
}
```
### Example: Create a key event
This example marks the `purchase` event as a key event on a GA4 property.
**API**: `POST https://analyticsadmin.googleapis.com/v1beta/properties/{propertyId}/keyEvents`
```json theme={null}
{
"method": "POST",
"endpoint": "v1beta/properties/123456789/keyEvents",
"body": {
"eventName": "purchase"
}
}
```
### Example: Query real-time data
This example retrieves how many users are active on the site right now, broken down by country.
**API**: `POST https://analyticsdata.googleapis.com/v1beta/properties/{propertyId}:runRealtimeReport`
```json theme={null}
{
"method": "POST",
"endpoint": "v1beta/properties/123456789:runRealtimeReport",
"body": {
"dimensions": [
{ "name": "country" }
],
"metrics": [
{ "name": "activeUsers" }
]
}
}
```
Replace `123456789` with your actual GA4 property ID. You can find this in your GA4 account under **Admin** > **Property Settings**.
## Common GA4 API endpoints
The GA4 Data API base URL is `https://analyticsdata.googleapis.com/`.
* **Run report**: `POST v1beta/properties/{propertyId}:runReport`
* **Run real-time report**: `POST v1beta/properties/{propertyId}:runRealtimeReport`
* **Run pivot report**: `POST v1beta/properties/{propertyId}:runPivotReport`
* **Batch run reports**: `POST v1beta/properties/{propertyId}:batchRunReports`
* **Get metadata** (available metrics and dimensions): `GET v1beta/properties/{propertyId}/metadata`
[View Data API documentation](https://developers.google.com/analytics/devguides/reporting/data/v1/rest)
The GA4 Admin API base URL is `https://analyticsadmin.googleapis.com/`.
* **List properties**: `GET v1beta/properties?filter=parent:accounts/{accountId}`
* **Get property**: `GET v1beta/properties/{propertyId}`
* **Create property**: `POST v1beta/properties`
* **Update property**: `PATCH v1beta/properties/{propertyId}`
* **Delete property**: `DELETE v1beta/properties/{propertyId}`
[View Admin API — properties documentation](https://developers.google.com/analytics/devguides/config/admin/v1/rest/v1beta/properties)
* **List key events**: `GET v1beta/properties/{propertyId}/keyEvents`
* **Create key event**: `POST v1beta/properties/{propertyId}/keyEvents`
* **Get key event**: `GET v1beta/properties/{propertyId}/keyEvents/{keyEventId}`
* **Delete key event**: `DELETE v1beta/properties/{propertyId}/keyEvents/{keyEventId}`
[View Admin API — key events documentation](https://developers.google.com/analytics/devguides/config/admin/v1/rest/v1beta/properties.keyEvents)
* **List data streams**: `GET v1beta/properties/{propertyId}/dataStreams`
* **Get data stream**: `GET v1beta/properties/{propertyId}/dataStreams/{dataStreamId}`
* **Create data stream**: `POST v1beta/properties/{propertyId}/dataStreams`
* **Update data stream**: `PATCH v1beta/properties/{propertyId}/dataStreams/{dataStreamId}`
[View Admin API — data streams documentation](https://developers.google.com/analytics/devguides/config/admin/v1/rest/v1beta/properties.dataStreams)
## Example use cases
Build an agent that runs GA4 reports on a schedule, compiles key metrics (sessions, conversions, revenue), and delivers formatted summaries to Slack, email, or a Google Sheet. The agent can compare performance week-over-week or month-over-month and flag significant changes automatically.
Create an agent that reads from a CRM or project management tool and automatically creates GA4 key events when new business goals are defined. This removes the manual step of updating GA4 settings each time your team identifies a new conversion action to track.
Deploy an agent that provisions GA4 properties at scale — useful for agencies managing analytics for multiple clients or organizations rolling out tracking across many regional sites. The agent creates properties, applies consistent settings, and logs the property IDs for reference.
Connect GA4 data to internal dashboards by having an agent pull specific metrics and dimensions on demand. The agent can combine data from multiple GA4 properties, apply business logic, and write results to a database or BI tool for visualization.
Set up an agent that monitors GA4 metrics and sends alerts when values cross defined thresholds — for example, when bounce rate exceeds 80%, when daily sessions drop by more than 20% compared to the previous week, or when conversion rate falls below a target. The agent runs reports at regular intervals and routes alerts to the appropriate channel.
Build an agent that combines GA4 data with data from your CRM, advertising platforms, or marketing automation tools. For example, pull GA4 conversion data alongside HubSpot lead data to get a full picture of how web traffic translates into pipeline, or combine GA4 session data with ad spend data to calculate cost per session by channel.
Create an agent that retrieves GA4 conversion data (key events, revenue) alongside campaign spend data from advertising platforms, then calculates return on ad spend (ROAS), cost per acquisition (CPA), and other ROI metrics. Results can be written to a spreadsheet or sent as a periodic report.
Deploy an agent that runs detailed GA4 reports segmented by user attributes — device type, location, traffic source, landing page — and identifies patterns in how different audience segments engage with your site. The agent can surface insights about which segments convert at higher rates or where users drop off in key flows.
## Best practices
* **Request minimal permissions**: OAuth grants access to all GA4 properties in your Google account. Where possible, use a dedicated Google account with access only to the properties your agent needs, rather than a personal account with access to many unrelated properties.
* **Respect rate limits**: The GA4 Data API enforces quotas per property, including limits on requests per day, tokens per day, and concurrent requests. Design your agents to batch reports where possible and avoid making redundant API calls. See [GA4 API quotas](https://developers.google.com/analytics/devguides/reporting/data/v1/quotas) for current limits.
* **Account for data processing delays**: GA4 data is typically processed within 24–48 hours. Real-time reports show data from the last 30 minutes but exclude some processed signals. If your use case requires fully processed data (including attribution and session stitching), query for dates at least 48 hours in the past.
* **Use property IDs, not names**: Property names can change but property IDs don't. Store and reference properties by their numeric ID (visible in GA4 Admin > Property Settings) rather than by display name.
* **Handle empty responses**: GA4 reports return no rows when there's no matching data for the requested dimensions and date range. Make sure your agent handles empty result sets gracefully rather than treating them as errors.
## Frequently asked questions (FAQs)
To connect the integration, your Google account must have at least **Viewer** access on the GA4 properties you want to query. To create key events or manage property settings, you need **Editor** access. To create new properties, you need **Administrator** access on the Google Analytics account.
You can check your access level in GA4 under **Admin** > **Account Access Management** or **Property Access Management**.
Yes. You can connect multiple Google accounts by completing the OAuth flow once for each account. Each connected account will appear separately in your Relevance AI integrations list, and you can select which account to use when configuring individual tool steps.
Key events are the actions you've identified as important to your business — for example, purchases, form submissions, or sign-ups. In GA4, you first collect an event (via your tracking code or Google Tag Manager), then designate it as a key event to highlight it in reports and use it for conversion measurement. Key events were called "conversions" in Universal Analytics and in earlier versions of GA4; Google renamed them to key events in 2024.
The GA4 Data API enforces per-property quotas including:
* **Core reporting**: 200,000 tokens per day, 40,000 tokens per hour, 10 concurrent requests
* **Real-time reporting**: 75,000 tokens per day, 15,000 tokens per hour
Tokens are consumed based on the complexity of your queries. Simple queries use fewer tokens than complex ones with many dimensions or large date ranges. See the [GA4 quotas documentation](https://developers.google.com/analytics/devguides/reporting/data/v1/quotas) for full details.
GA4 processes most data within 24 hours, but full processing (including attribution, session stitching, and some conversions) can take up to 48 hours. Real-time data is available within minutes but represents a subset of the fully processed data. If you need accurate, fully processed metrics, query for dates at least 48 hours in the past.
No. Universal Analytics properties stopped processing new data in July 2023. The Google Analytics integration in Relevance AI connects to GA4 only. Historical UA data is no longer accessible via the API.
In Google Analytics, go to **Admin** > **Property Settings**. Your property ID is the numeric ID shown at the top of the page (e.g., `123456789`). When using the API, you reference it as `properties/123456789`.
Creating GA4 properties requires **Administrator** access on the Google Analytics account (not just the property). If you receive a permission error, check your access level under **Admin** > **Account Access Management** and ensure your connected Google account has Administrator rights on the account where you want to create the property.
## Additional resources
Complete reference for querying GA4 analytics data, including all available metrics, dimensions, and report types
Reference for managing GA4 properties, data streams, key events, and account configuration
Learn how key events work in GA4 and how to use them for conversion measurement
Details on GA4 Data API rate limits, quota types, and how tokens are calculated
## Remove the integration
To disconnect your Google Analytics account from Relevance AI:
1. Navigate to **Integrations & API Keys** from the left sidebar.
2. Find your Google Analytics connection in the integrations list.
3. Click on the integration to expand its details.
4. Click the three-dot menu and select **Remove**.
Removing the integration revokes Relevance AI's access to your Google Analytics data. Any agents or tools using Google Analytics tool steps will stop working until you reconnect. Removing the integration from Relevance AI does not affect your Google Analytics account or data in any way.
***
Contact our support team for assistance with the Google Analytics integration
Discover other integrations to extend your agent workflows
# Google Calendar
Source: https://relevanceai.com/docs/integrations/popular-integrations/google-calendar
Connect your Google Calendar from Relevance AI
## Overview
The Google Calendar integration allows you to seamlessly connect your AI agents with your Google Calendar, enabling powerful automation for scheduling, event management, and calendar-based workflows. This integration bridges the gap between your AI agents and your calendar, allowing for intelligent scheduling assistance, automated event creation, and calendar-based decision making.
## Connecting the Google Calendar Integration
To connect the Google Calendar integration to Relevance AI:
1. Select **Integrations & API Keys** from the left sidebar
2. Find and click on "Google Calendar" in the integrations directory
3. Click "Connect"
4. You'll be redirected to Google's authentication page
5. Select the Google account you want to connect
6. Review and approve the requested permissions
7. Once authenticated, you'll be redirected back to Relevance AI with your Google Calendar now connected
Your Google Calendar integration will now be available for use with your AI agents. You can connect multiple Google Calendar accounts if needed, and manage all connections from the Integrations dashboard.
## Setting Up Triggers with Google Calendar
Google Calendar can serve as a powerful trigger for your AI agents, initiating workflows based on calendar events. Here's how to set up calendar-based triggers:
1. Navigate to your Agent Profile
2. In the trigger section, select "Google Calendar"
3. Configure trigger settings:
* Select which calendar(s) to monitor
* Set any filtering criteria (e.g., only events with specific keywords)
* For time-based triggers, specify the advance notice period
4. Save your trigger configuration
Once set up, your AI agent will automatically activate when the specified calendar events occur, enabling workflows like:
* Sending meeting preparation materials before scheduled calls
* Following up after appointments with summary notes
* Blocking focus time when calendar shows you're busy
* Rescheduling conflicting appointments
## Tools & Tool Steps
The Google Calendar integration provides a rich set of actions that your AI agents can use throughout their workflows. These actions allow your agents to interact with your calendar in sophisticated ways:
### Event Management Actions
* **Create Event**: Schedule new events on your calendar with customizable details
* **Update Event**: Modify existing events (time, location, description, etc.)
* **Delete Event**: Remove events from your calendar
* **Get Event Details**: Retrieve comprehensive information about specific events
### Calendar Query Actions
* **List Events**: Retrieve events within a specified date range
* **Find Available Time**: Identify open slots in your calendar for scheduling
* **Check Availability**: Determine if a specific time period is free or busy
* **Search Events**: Find events matching specific criteria (keywords, attendees, etc.)
### Attendee Management
* **Add Attendees**: Invite participants to calendar events
* **Remove Attendees**: Update event guest list
* **Check Attendee Responses**: View who has accepted, declined, or not responded
### Calendar Management
* **List Calendars**: View all calendars in your Google account
* **Create Calendar**: Set up new calendars for specific purposes
* **Update Calendar Settings**: Modify calendar properties and sharing settings
These actions can be combined in powerful ways to create sophisticated calendar management workflows. For example, your agent could:
* Find available time slots, create a meeting, and send invitations
* Reschedule conflicting appointments based on priority rules
* Create follow-up tasks after calendar events conclude
* Generate meeting agendas based on event descriptions and attendees
## Using the Google Calendar API Tool Step (Advanced)
For advanced use cases requiring deeper integration with Google Calendar, you can leverage the Google Calendar API directly:
1. Create a new tool in your agent profile
2. Scroll down to Tool-steps
3. Add "Google Calendar API" tool-step
4. Select your connected Google Calendar account from the dropdown
5. Configure the API request:
* Specify the API endpoint (e.g., `/calendars/{calendarId}/events`)
* Set the HTTP method (GET, POST, PUT, DELETE)
* Define request parameters and body as needed
* Configure response handling
This approach gives you full access to the Google Calendar API capabilities, allowing for custom implementations beyond the standard actions. Some advanced use cases include:
* Creating recurring events with complex patterns
* Setting up conference solutions (Google Meet, Zoom) with custom parameters
* Managing calendar resources and room bookings
* Implementing custom notification schemes
* Working with secondary calendars and calendar groups
## Best Practices
* **Permission Management**: Only request the minimum calendar permissions needed for your agent's functionality
* **Error Handling**: Implement robust error handling for calendar conflicts and availability issues
* **User Confirmation**: For critical calendar changes, consider adding user confirmation steps
* **Time Zone Awareness**: Always account for time zone differences when scheduling across regions
* **Privacy Considerations**: Be mindful of calendar data sensitivity and implement appropriate safeguards
# Google Drive
Source: https://relevanceai.com/docs/integrations/popular-integrations/google-drive
Trigger your Agents automatically when files in Google Drive are created, modified, or deleted.
## Overview
Connect your Google Drive account to Relevance AI and configure your Agents to respond automatically when files change, or give them tool steps to read, create, and manage files directly in Drive.
The Google Drive trigger is currently rolling out in early access. If you don't see it in your account yet, it will become available soon.
## Connect the integration
1. Navigate to the "Integrations & API Keys" page in the sidebar of your Relevance AI dashboard.
2. Click on "Google Drive" from the available integrations.
3. Click the **+ Connect account** button.
4. In the pop-up window, sign into your Google account and authorize the connection.
5. Once authorized, your Google account will appear in the connected accounts list.
## Setting up triggers
The Google Drive integration lets you trigger Agents automatically when files in a Google Drive change. The trigger fires on every change within the drive (or folders) you watch — created, modified, trashed, or removed — and the event type is included in the message your Agent receives.
### What fires the trigger
A Google Drive trigger fires on each of the following events within the drive or folders you've selected:
* **File created** — a new file is added
* **File modified** — an existing file is updated
* **File deleted** — a file is moved to trash or permanently removed
Each Google Drive file gets its own ongoing conversation. When the same file changes again, your Agent picks up where it left off rather than starting a new conversation — so it has the full history for each file.
### How to set up a Google Drive trigger
The setup process differs slightly depending on whether you're configuring a trigger for an Agent or a Workforce.
#### For Agents
1. Open the Agent you want to configure in the Agent builder.
2. In the left sidebar, click the "Triggers" section.
3. Click **+ Add trigger** and select "Google Drive" from the trigger types.
4. Choose the connected Google account you want to use. If you haven't connected one yet, set it up first in the Integrations & API Keys page.
5. Select a **Drive** — defaults to "My Drive", or pick any shared drive you have access to.
6. Optionally, select one or more **Folders** to restrict the watch to only those folders. Leave empty to watch the entire drive.
7. Optionally, enable **Watch for file property changes** to also trigger on changes to custom file properties (not just content changes).
8. Save the trigger.
#### For Workforces
1. Open the Workforce you want to configure in the Workforce builder.
2. From the node tray at the bottom of the screen, drag a trigger node onto the canvas.
3. Click the trigger node to open its configuration panel on the left, then select "Google Drive" as the trigger type.
4. Choose the connected Google account you want to use. If you haven't connected one yet, set it up first in the Integrations & API Keys page.
5. Select a **Drive** — defaults to "My Drive", or pick any shared drive you have access to.
6. Optionally, select one or more **Folders** to restrict the watch.
7. Optionally, enable **Watch for file property changes**.
8. Drag a connection line from the trigger node to the Agent that should respond when the trigger fires.
## Tool steps
Beyond triggers, the Google Drive integration provides pre-built tool steps your Agents can use to read, create, and manage files in Drive. Add these in the Tool builder by searching "Google Drive" in the tool-step picker.
### File operations
* **Google Drive: Upload File** — upload a file to Google Drive
* **Google Drive: Download File** — download a file from Google Drive (specify a MIME type to export Google Workspace files like Docs, Sheets, or Slides)
* **Google Drive: Create File from Text** — create a new file from plain text
* **Google Drive: Create File from Template** — create a new Google Doc from a template, replacing placeholders
* **Google Drive: Update File** — update a file's metadata or content
* **Google Drive: Copy File** — duplicate a file
* **Google Drive: Move File** — move a file from one folder to another
* **Google Drive: Move to Trash** — send a file or folder to trash
* **Google Drive: Delete File** — permanently delete a file or folder
### Search and discovery
* **Google Drive: List Files** — list files from a specific folder
* **Google Drive: Find File** — search for a file by name
* **Google Drive: Find Folder** — search for a folder by name
* **Google Drive: Find Forms** — list or search Google Form documents
* **Google Drive: Find Spreadsheets** — search for Google Sheets by name
* **Google Drive: Get File by ID** — fetch file metadata by ID
* **Google Drive: Get Folder ID for Path** — resolve a folder path to its ID
### Folders
* **Google Drive: Create Folder** — create a new empty folder
### Shared drives
* **Google Drive: Create Shared Drive** — create a new shared drive
* **Google Drive: Get Shared Drive** — fetch metadata for a shared drive
* **Google Drive: Search Shared Drives** — search for shared drives
* **Google Drive: Update Shared Drive** — update an existing shared drive
* **Google Drive: Delete Shared Drive** — delete an empty shared drive
### Sharing and permissions
* **Google Drive: Share File or Folder** — add a sharing permission and return a sharing URL
* **Google Drive: List Access Proposals** — list pending requests for access to a file or folder
* **Google Drive: Resolve Access Proposal** — accept or deny a request for access
## Use the Google Drive API tool step (advanced)
For actions that aren't covered by a dedicated tool step, the **Google Drive API call** tool step lets your Agent make authorized requests directly to the Google Drive API.
1. Create a new Tool in Relevance AI.
2. Scroll to the Tool steps section.
3. Add the **Google Drive API call** tool step.
4. Select your connected Google account in the dropdown.
5. Configure the request — endpoint, method, parameters, and body — based on the [Google Drive API reference](https://developers.google.com/drive/api/reference/rest/v3).
## Frequently asked questions (FAQs)
Triggers fire your Agent automatically when files in Google Drive change — created, modified, or deleted. A Knowledge source gives your Agent read access to specific files so it can reference them during a conversation. You can use both together: a trigger to start the conversation, and a Knowledge source to give the Agent ongoing context.
Both. The trigger config supports selecting either My Drive or any shared drive you have access to, and the tool steps include a full set of shared-drive actions for creating, searching, and updating shared drives.
Yes. Connect each account in the Integrations & API Keys page, then choose which connected account each trigger or tool step uses.
Both work. Sign in with whichever account has access to the files or folders you want your Agent to watch or act on.
## Google Drive as a Knowledge source
You can also use Google Drive as a Knowledge source, giving your Agents direct read access to files for retrieval and reference.
[Learn more about Google Drive as a Knowledge source](/docs/build/knowledge/integrated-knowledge-sources/google-drive).
# Google Sheets
Source: https://relevanceai.com/docs/integrations/popular-integrations/google-sheets
Connect to Google Sheets from Relevance AI.
## Overview
The Google Sheets integration allows you to connect your Relevance AI agents with Google Sheets, enabling powerful data workflows between your spreadsheets and AI agents. This integration empowers you to automate data extraction, analysis, and manipulation tasks directly from your Google Sheets documents, as well as use spreadsheet data to trigger agent workflows.
## Connecting the Google Sheets Integration
To connect the Google Sheets integration with Relevance AI:
1. Click on **Integrations & API Keys** in the left sidebar
2. Find and select "Google Sheets" from the available integrations
3. Click "Connect"
4. You'll be redirected to Google's authentication page
5. Grant Relevance AI permission to access your Google Sheets
6. Once authenticated, you'll be redirected back to Relevance AI with the integration now connected
## Setting Up Triggers with Google Sheets *(coming soon)*
The Google Sheets integration can be configured to trigger your AI agents based on specific spreadsheet events or conditions:
### Trigger Types
* **New Row Added**: Activate your agent when a new row is added to a specified sheet
* **Cell Value Changed**: Trigger your agent when values in specific cells or columns are modified
* **Threshold Reached**: Start your agent when a numeric value in your sheet crosses a defined threshold
* **Scheduled Updates**: Configure your agent to process sheet data at regular intervals
### Setting Up a Trigger
1. Navigate to your agent's profile
2. Select "Google Sheets" from the trigger options
3. Choose the specific Google Sheet you want to monitor
4. Select the trigger type (e.g., New Row Added)
5. Configure any additional parameters specific to your chosen trigger
6. Save your trigger configuration
Your agent will now automatically activate when the specified condition is met in your Google Sheets document.
## Tools & Tool Steps
The Google Sheets integration provides a variety of powerful actions that your agents can perform. These actions can be incorporated into your agent's workflow as tool steps, allowing for seamless interaction with your spreadsheet data.
### Available Actions
* **Read Sheet Data**: Extract data from specific sheets, ranges, or cells
* **Write to Sheet**: Add or update data in your spreadsheets
* **Create New Sheet**: Generate new spreadsheets with specified data
* **Format Cells**: Apply formatting to cells based on conditions or data analysis
* **Filter Data**: Extract specific information based on custom criteria
* **Sort Data**: Organize spreadsheet information in meaningful ways
* **Append Rows**: Add new rows of data to existing sheets
* **Delete Data**: Remove specific cells, rows, or columns
These actions represent just a small sample of what's possible with the Google Sheets integration. The tool library contains many more specialized actions to help you build powerful data workflows.
### Using Google Sheets Actions in Your Workflow
1. In your agent's workflow, add a new tool step
2. Search for "Google Sheets" in the tool library
3. Browse the available actions and select the one you need
4. Configure the action parameters (sheet ID, range, data to write, etc.)
5. Connect this action to other steps in your workflow
## Using the Google Sheets API Tool Step (Advanced)
For advanced users who need custom functionality beyond the pre-built actions, you can leverage the Google Sheets API directly:
1. Create a new tool in your agent's workflow
2. Scroll down to Tool-steps
3. Add "Google Sheets API" tool-step
4. Select your connected Google Sheets account from the dropdown
5. Specify the API endpoint and parameters for your custom request
6. Configure how the response data should be processed
This approach gives you full access to the Google Sheets API capabilities, allowing for highly customized interactions with your spreadsheet data.
## Use Cases
### Data Analysis and Reporting
* Extract data from multiple sheets for comprehensive analysis
* Generate automated reports based on spreadsheet data
* Create visualizations and summaries of key metrics
### Data Collection and Management
* Automatically organize and categorize incoming data
* Clean and standardize information across multiple sheets
* Maintain data integrity through automated validation
### Workflow Automation
* Trigger notifications when important spreadsheet values change
* Automatically update related systems when data is modified
* Create approval workflows based on spreadsheet entries
### Customer and Lead Management
* Track customer interactions in spreadsheets and trigger follow-ups
* Analyze lead data to prioritize high-value prospects
* Generate personalized communications based on spreadsheet data
## Best Practices
* **Use Descriptive Names**: When setting up Google Sheets actions, use clear names that describe what the action does
* **Handle Errors Gracefully**: Configure error handling for cases where sheets might be unavailable or data formats unexpected
* **Limit Data Access**: Only request access to the specific sheets and data ranges your agent needs
* **Test Thoroughly**: Before deploying in production, test your Google Sheets integration with sample data
* **Monitor Usage**: Keep track of API usage to stay within Google's rate limits
## Related Features
[Data Visualization Tools](https://relevanceai.com/docs/features/data-visualization) - Combine Google Sheets data with powerful visualization capabilities to create compelling visual representations of your insights.
[Workflow Automation](https://relevanceai.com/docs/features/workflow-automation) - Learn how to build complex workflows that incorporate Google Sheets data alongside other integrations.
[Data Processing](https://relevanceai.com/docs/features/data-processing) - Discover techniques for cleaning, transforming, and analyzing data from Google Sheets within your AI workflows.
# HubSpot
Source: https://relevanceai.com/docs/integrations/popular-integrations/hubspot
Interact with your HubSpot CRM with Relevance.
## Overview
HubSpot is designed to help your manage and grow your customer relationships through a wide range of tools for marketing, sales and customer service. With Relevance AI, your agents can interact with HubSpot much like your human team would.
Below, we'll show you how to get started with the HubSpot integration, including how to connect your HubSpot account, how to trigger agentic workflows based on HubSpot workflow triggers, and how to complete common HubSpot activities with your agents.
## Connecting the Hubspot integration
To add HubSpot as an integration, all you need to do is sign-into your HubSpot account via the integrations page:
1. Go to the **Integrations & API Keys** page in the sidebar.
2. Click on "HubSpot".
3. Click on the Add Integration button.
4. In the pop-up window, sign-into your HubSpot account.
## Setup HubSpot as an Agent Trigger
A trigger is an event that triggers your agent to start working. Once you have create a new agent, you can add HubSpot as a trigger:
### Trigger your agent to start working from a HubSpot workflow
Next, we need to create a workflow in HubSpot, which will send a message to your connected agent every time an event you care about happens.
There are three parts to this process:
1. Create a HubSpot workflow.
2. Create a HubSpot trigger.
3. Create an action which sends a message to your Relevance AI agent.
#### Step 1: Create a HubSpot workflow
In HubSpot, a workflow is made up of a series of automated actions that are perform every time a specific event happens. In this example, we'll create a Contact-based workflow which sends a message to your agent when a new contact added to your HubSpot CRM meets some criteria you define (HubSpot trigger).
Let's create a contact-based workflow:
#### Step 2: Create a HubSpot workflow trigger
A HubSpot trigger is an event or condition that starts the automated workflow. In the case of a contact-based workflow, a trigger is a condition related to a contact. It can be based on a contact filling out a form, clicking a link in an email, acheiving a specific lead score, or one of their properties being updated. It's entirely up to you.
#### Step 3: Add Relevance AI Trigger action
Once your workflow and trigger is setup, you can add an action that will send a message to your agent from HubSpot (triggering your agentic workflow):
## Get your agent to complete common HubSpot activities
Besides triggering your agent to start working from HubSpot, you can also use the HubSpot API call step in the Tool builder. This tool step allows your agent to complete HubSpot-specific activities, like managing Contacts, Notes, Tasks and more.
### Use HubSpot API tool-step
You can build custom tools that perform HubSpot activities, by using the HubSpot API Call tool-step:
1. Create a new tool.
2. Scroll down to Tool-steps.
3. Add HubSpot API tool-step.
4. Select your connected HubSpot account in the dropdown.
Below are examples of common HubSpot activities your agents can perform.
#### Get an existing Contact's details.
#### Update a contact's properties.
#### Create a note (e.g. lead qual research).
#### Create a task
#### Mark a task as complete
#### Retrieve HubSpot engagements (all activities a customer has performed)
## Remove HubSpot integration
You can remove HubSpot as a Trigger in your agent settings, by clicking the three dots next to your connected account, and then "Remove".
If you want to remove the HubSpot integration completely, you can:
1. Go to the **Integrations & API Keys** page from the sidebar.
2. Select Zoom from the list.
3. Click "..." on the account you want to remove.
4. Click Remove.
***
## HubSpot Assistant
The HubSpot Assistant is a pre-built agent available from the [Marketplace](https://app.relevanceai.com/marketplace) that manages your HubSpot CRM through plain English. Handle contacts, deals, companies, and more through simple conversation.
Search "HubSpot Assistant" in the Marketplace to clone it and start managing your CRM through conversation
***
## Follow along on YouTube
We also have a number of YouTube tutorials you can use to follow along with and learn how to build Agents.
# LinkedIn
Source: https://relevanceai.com/docs/integrations/popular-integrations/linkedin
Interact with your LinkedIn account with Relevance.
Connect your LinkedIn account to Relevance AI and supercharge your networking, prospecting, and engagement capabilities with AI-powered automation. The LinkedIn Integration enables your agents to interact with LinkedIn much like a human team member would, creating a seamless bridge between your AI workforce and one of the world's most valuable professional networks.
## Connect the integration
Getting started with the LinkedIn Integration is straightforward:
1. Navigate to the "Integrations & API Keys" page in the sidebar of your Relevance AI dashboard
2. Click on "LinkedIn" from the available integrations
3. Click the "Add Integration" button
4. In the pop-up window, sign into your LinkedIn account and authorize the connection
5. Once authorized, your LinkedIn account will appear in the connected accounts list
## Setting up triggers
The LinkedIn Integration offers powerful trigger capabilities that can initiate your AI agents based on specific LinkedIn events. This allows your agents to respond automatically to important network activities.
The LinkedIn Trigger is a Premium trigger, available on the Pro plan and above.
### Available LinkedIn triggers
Set up your agents to start working when:
* **All messages received** - Triggers when any message is received on LinkedIn
* **Outreach replies only** - Triggers only when replies to outreach messages are received
Connection accept notifications are only tracked if the connection request was originally sent through Relevance AI's LinkedIn integration. This is a technical limitation of the LinkedIn integration.
These triggers are available for both agents and workforces.
### How to set up a LinkedIn trigger
The setup process differs slightly depending on whether you're configuring a trigger for an agent or a workforce. Follow the instructions below based on your use case.
#### For Agents
1. Navigate to the agent builder by selecting the agent you want to configure with a LinkedIn trigger.
2. In the left sidebar of the agent builder, locate and click on the "Triggers" section.
3. Click the "Add trigger" button, then select "LinkedIn" from the available trigger types.
4. Choose the connected LinkedIn account you want to use for this trigger from the dropdown menu. If you haven't connected a LinkedIn account yet, you'll need to do so first in the Integrations & API Keys page.
5. Select the specific trigger event you want to use:
* **All messages received** - Triggers when any message is received on LinkedIn
* **Outreach replies only** - Triggers only when replies to outreach messages are received
6. If available on your plan, configure queue work hours to control when your agent should process LinkedIn triggers. This allows you to set specific times when your agent should be active.
#### For Workforces
1. Navigate to the workforce builder by selecting the workforce you want to configure with a LinkedIn trigger.
2. In the Build section of your workforce, locate the "Triggers" section in the node palette on the left side. Drag a trigger node onto your workspace.
3. Click on the trigger node you just added to open its configuration panel, then select "LinkedIn" as the trigger type.
4. Choose the connected LinkedIn account you want to use for this trigger from the dropdown menu. If you haven't connected a LinkedIn account yet, you'll need to do so first in the Integrations & API Keys page.
5. Select the specific trigger event you want to use:
* **All messages received** - Triggers when any message is received on LinkedIn
* **Outreach replies only** - Triggers only when replies to outreach messages are received
6. If available on your plan, configure queue work hours to control when your workforce should process LinkedIn triggers. This allows you to set specific times when your agents should be active.
7. Drag a connection line from the trigger node to the agent in your workforce that should respond when the trigger activates.
## Tool steps for LinkedIn
You can also add LinkedIn Tool steps to your Tools to interact with LinkedIn to get company and profile information, and perform actions in LinkedIn.
# Lusha
Source: https://relevanceai.com/docs/integrations/popular-integrations/lusha
Lusha is a leading B2B sales intelligence and lead enrichment platform trusted by over 1.5 million users worldwide.
Lusha is a leading B2B sales intelligence and lead enrichment platform trusted by over 1.5 million users worldwide. With Relevance AI's Lusha integration, you can seamlessly enrich your leads with accurate contact and company information, enabling your AI agents to automate prospect research, qualify leads, and build comprehensive sales pipelines with verified data.
The Lusha integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not Lusha. If you have a question or issue with using Lusha in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about Lusha, you can [reach out to Lusha support](https://www.lusha.com/contact/).
## Connect the integration
Connecting your Lusha account to Relevance AI is a straightforward process:
1. Go to the "Integrations" page in the sidebar of your Relevance AI dashboard.
2. Click on "Lusha" from the available integrations.
3. Click on the "Add Integration" button.
4. Enter your Lusha API key when prompted.
5. Once authenticated, your Lusha account will appear as a connected integration.
You can find your Lusha API key in your Lusha account settings under API & Integrations. If you don't have a Lusha account yet, you can [sign up here](https://www.lusha.com/).
## Tool steps for Lusha
The Lusha integration provides a comprehensive set of actions that your agents can use to enrich leads, find contacts, and gather company intelligence. These actions can be incorporated into your agent's workflows as tool steps, enabling sophisticated sales automation and prospect research capabilities.
### Contact Enrichment
Enrich existing contact records with verified email addresses, phone numbers, and professional details
Find specific contacts based on name, company, or other identifying information
Search for contacts matching specific criteria across Lusha's database
### Company Intelligence
Enrich company records with firmographic data, employee counts, and industry information
Find specific companies based on name, domain, or other identifiers
Search for companies matching your ideal customer profile criteria
### Advanced API Access
Make custom API calls to access any Lusha API endpoint for advanced use cases
Type "Lusha" in the tool step search bar to see all available Lusha actions when building your tools.
## Use the integration's API tool step (Advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform Lusha-specific activities using the Lusha API Call tool step.
### How to use the Lusha API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add Lusha functionality to.
1. Scroll down to Tool-steps
2. Search for "Lusha API Call" in the tool step search bar
3. Add the Lusha API Call tool step to your workflow
Select your connected Lusha account from the dropdown menu.
Configure the API endpoint, method, and parameters according to your needs:
* **Method**: Select the HTTP method (GET, POST)
* **Endpoint**: Enter the API endpoint path (e.g., `/person`)
* **Body**: Add any required request body data with search criteria
Test your configuration to ensure it works correctly before deploying.
### Example: Enriching a Contact by Email
Here's a practical example of using the Lusha API Call tool step to enrich a contact using their email address:
**API Endpoint**: `POST /person`
**Configuration**:
```json theme={null}
{
"method": "POST",
"endpoint": "/person",
"body": {
"email": "john.doe@example.com"
}
}
```
This configuration:
* Uses the POST method to request contact enrichment
* Specifies the `/person` endpoint for individual contact lookup
* Provides the email address as the search parameter
* Returns verified contact information including phone numbers, job title, company details, and social profiles
You can find Lusha's complete API documentation at [https://www.lusha.com/api-documentation/](https://www.lusha.com/api-documentation/).
### Common Lusha API Endpoints
Here are some commonly used Lusha API endpoints you can use with the API Call tool step:
* **Enrich by email**: `POST /person` with `{"email": "user@example.com"}`
* **Enrich by LinkedIn**: `POST /person` with `{"linkedInUrl": "https://linkedin.com/in/username"}`
* **Enrich by name & company**: `POST /person` with `{"firstName": "John", "lastName": "Doe", "company": "Acme Corp"}`
Returns: Email addresses, phone numbers, job title, company, location, social profiles
[View API Documentation](https://www.lusha.com/api-documentation/)
* **Enrich by domain**: `POST /company` with `{"domain": "example.com"}`
* **Enrich by company name**: `POST /company` with `{"name": "Acme Corporation"}`
Returns: Company size, industry, location, revenue, technologies used, social profiles
[View API Documentation](https://www.lusha.com/api-documentation/)
* **Bulk person enrichment**: `POST /person/bulk` with array of person objects
* **Bulk company enrichment**: `POST /company/bulk` with array of company objects
Allows you to enrich multiple contacts or companies in a single API call for efficiency.
[View API Documentation](https://www.lusha.com/api-documentation/)
* **Search contacts**: Use search endpoints with filters for job title, company, location, industry
* **Find decision makers**: Search for specific roles within target companies
Useful for building prospect lists matching your ideal customer profile.
[View API Documentation](https://www.lusha.com/api-documentation/)
## Example use cases
Here are some ways you can leverage the Lusha integration with your agents:
Create an agent that automatically enriches incoming leads from your CRM or forms with verified contact information. The agent can take an email address or LinkedIn profile, use Lusha to gather phone numbers, job titles, and company details, then update your CRM with the enriched data.
Build an agent that conducts deep research on prospects before sales calls. Given a LinkedIn URL or company name, the agent uses Lusha to gather contact details, company information, and decision-maker profiles, then compiles a comprehensive research brief for your sales team.
Deploy an agent that automatically qualifies leads based on enriched data. The agent uses Lusha to gather company size, industry, and contact seniority, then scores and routes leads to the appropriate sales representatives based on your qualification criteria.
Create an agent that builds targeted prospect lists for outbound campaigns. The agent searches Lusha's database for contacts matching your ideal customer profile (job title, company size, industry, location), enriches the results, and exports them to your sales engagement platform.
Build an agent that continuously maintains data quality in your CRM. The agent identifies incomplete or outdated contact records, uses Lusha to find current information, and automatically updates your CRM with verified email addresses, phone numbers, and job titles.
Deploy an agent that supports ABM campaigns by researching target accounts. The agent uses Lusha to identify key decision-makers within target companies, gather their contact information, and map out the organizational structure for strategic outreach.
Create an agent that helps recruiters find and contact qualified candidates. The agent searches for professionals with specific skills and experience, uses Lusha to find their contact information, and prepares personalized outreach messages.
Build an agent that identifies and researches potential business partners. The agent finds companies in complementary industries, uses Lusha to identify partnership decision-makers, and gathers contact information for outreach.
## Best practices
**Always ensure compliance with data privacy regulations:**
* Only use Lusha data for legitimate business purposes
* Respect GDPR, CCPA, and other privacy regulations in your region
* Include proper opt-out mechanisms in your outreach
* Store enriched data securely and delete when no longer needed
* Review Lusha's terms of service and acceptable use policy
Lusha is GDPR and CCPA compliant, but you're responsible for how you use the data.
**Optimize your Lusha credit usage:**
* Each enrichment request consumes Lusha credits
* Use bulk enrichment endpoints when processing multiple records
* Cache enriched data to avoid duplicate lookups
* Implement logic to check if data already exists before enriching
* Monitor your credit usage through Lusha's dashboard
* Set up alerts when credits are running low
**Maximize the quality of enriched data:**
* Provide as much information as possible in your search queries (email + name + company is better than email alone)
* Validate enriched data before using it in outreach
* Implement fallback logic when Lusha doesn't find a match
* Regularly update enriched data as contact information changes
* Use Lusha's confidence scores to assess data reliability
**Handle API rate limits gracefully:**
* Lusha enforces rate limits to ensure service quality
* Implement retry logic with exponential backoff for rate limit errors
* Use bulk endpoints to reduce the number of API calls
* Distribute enrichment tasks over time for large datasets
* Monitor API response codes and handle errors appropriately
## Frequently asked questions (FAQs)
Lusha is a B2B sales intelligence platform that provides verified contact and company information. It helps sales and marketing teams find accurate email addresses, phone numbers, and company details for prospects. Using Lusha with Relevance AI allows you to automate lead enrichment, prospect research, and data quality maintenance at scale.
Yes, you need an active Lusha account with API access. You can sign up for Lusha at [https://www.lusha.com/](https://www.lusha.com/). Lusha offers various plans including a free tier with limited credits. You'll need to generate an API key from your Lusha account settings to connect it to Relevance AI.
To get your Lusha API key:
1. Log in to your Lusha account
2. Navigate to Settings or Account Settings
3. Look for "API & Integrations" or "API Access"
4. Generate a new API key or copy your existing key
5. Use this key when connecting Lusha to Relevance AI
Keep your API key secure and never share it publicly.
The beta status indicates that while the Lusha integration is fully functional and available for use, we're still gathering user feedback and may make refinements to improve the experience. We recommend testing your workflows thoroughly before deploying them in production. If you encounter any issues or have suggestions, please contact our support team.
Credit usage depends on the type of enrichment and the data returned. Typically:
* Contact enrichment: 1-2 credits per successful lookup
* Company enrichment: 1 credit per successful lookup
* Bulk operations: Credits per record in the batch
Check your Lusha plan details for specific credit allocations and pricing. You can monitor your credit usage in your Lusha dashboard.
If Lusha doesn't find information for a contact or company, the API will return an empty result or indicate no match was found. Your agent should include logic to handle these cases, such as:
* Trying alternative search parameters
* Using fallback data sources
* Flagging the record for manual research
* Skipping to the next record in bulk operations
Not all contacts are in Lusha's database, so plan for partial match rates.
Yes, but you must comply with all applicable laws and regulations:
* Follow CAN-SPAM, GDPR, CCPA, and other relevant regulations
* Include proper identification and opt-out mechanisms
* Only contact people with legitimate business interest
* Respect do-not-contact lists and preferences
* Review Lusha's acceptable use policy
Lusha provides the data, but you're responsible for how you use it.
Lusha maintains high data accuracy through continuous verification and updates. However, contact information can change over time. Best practices:
* Use the most recent enrichment data available
* Implement email verification before sending campaigns
* Update your records regularly
* Use Lusha's confidence scores when available
* Have a process for handling bounced emails or wrong numbers
Yes! Lusha specializes in enriching LinkedIn profiles. You can provide a LinkedIn URL to the Lusha enrichment tool steps, and it will return verified contact information including email addresses and phone numbers. This is particularly useful for sales prospecting and recruitment workflows.
* **Find** tool steps: Used when you have specific identifying information (email, LinkedIn URL, company domain) and want to retrieve that specific contact or company's details
* **Search** tool steps: Used when you want to discover contacts or companies matching certain criteria (job title, industry, location, company size)
Use "Find" for enrichment, "Search" for prospecting and list building.
Yes! You can build agents that connect Lusha with popular CRMs like Salesforce, HubSpot, and others available in Relevance AI. Your agent can:
* Pull contacts from your CRM
* Enrich them with Lusha
* Update the CRM with enriched data
* All automatically on a schedule or trigger
Check our [integrations page](/docs/integrations/introduction) for available CRM connections.
Yes, Lusha enforces rate limits to ensure service quality for all users. The specific limits depend on your Lusha plan. If you hit rate limits:
* Your agent will receive a rate limit error
* Implement retry logic with delays
* Use bulk endpoints when processing many records
* Contact Lusha support if you need higher limits
Design your workflows to handle rate limits gracefully.
# Marketo
Source: https://relevanceai.com/docs/integrations/popular-integrations/marketo
Marketo is a leading marketing automation platform for lead management, email marketing, and campaign analytics.
Marketo is a leading marketing automation platform that helps businesses manage leads, execute email campaigns, and analyze marketing performance. With Relevance AI's Marketo integration, you can seamlessly connect your Marketo instance to your AI agents, enabling them to retrieve campaign metrics, manage leads, access email statistics, and automate marketing workflows.
The Marketo integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not Marketo. If you have a question or issue with using Marketo in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about Marketo, you can [reach out to Adobe Marketo support](https://experienceleague.adobe.com/en/docs/marketo/using/home).
## Connect the integration
Connecting your Marketo account to Relevance AI uses API Tool Steps with 2-legged OAuth 2.0 authentication. Follow these steps to set up the connection:
You'll need three pieces of information from your Marketo instance:
1. **Client ID**
2. **Client Secret**
3. **REST API Endpoint**
To obtain these credentials:
1. Log into your Marketo instance as an administrator
2. Navigate to **Admin** > **Integration** > **LaunchPoint**
3. Click **New** > **New Service**
4. Configure the service:
* **Display Name**: Enter a name (e.g., "Relevance AI Integration")
* **Service**: Select "Custom"
* **Description**: Optional description
* **API Only User**: Select an API-only user (or create one in Admin > Users & Roles)
5. Click **Create**
6. Click **View Details** on your newly created service
7. Copy the **Client ID** and **Client Secret**
To get your REST API Endpoint:
1. Navigate to **Admin** > **Integration** > **Web Services**
2. Find the **REST API** section
3. Copy the **Endpoint** URL (e.g., `https://123-ABC-456.mktorest.com/rest`)
When configuring the Marketo API Call tool step in your tools, you'll need to provide these credentials for authentication. Keep them secure and accessible for when you build your Marketo-connected tools.
Once you've added the credentials to a tool step, test the connection by making a simple API call (e.g., retrieving leads or campaigns) to ensure everything is configured correctly.
**Authentication Method**: Marketo uses 2-legged OAuth 2.0. As of June 2025, authentication requires a Bearer token in the Authorization header. The Marketo API Call tool step handles token generation and refresh automatically.
## Tool steps for Marketo
The Marketo integration provides access to Marketo's comprehensive REST API through the API Call tool step, enabling you to interact with all Marketo endpoints and functionality.
### Marketo API Call
Make custom API calls to any Marketo REST API endpoint. This tool step provides full access to Marketo's API, allowing you to retrieve campaign metrics, manage leads, access email statistics, and more.
Type "Marketo" in the tool step search bar to find the Marketo API Call action when building your tools.
## Use the Marketo API Call tool step (Advanced)
The Marketo API Call tool step gives you complete access to Marketo's REST API, allowing you to implement any functionality available in the API, including lead management, campaign operations, email program analytics, and more.
**Authentication Required**: As of June 2025, Marketo API calls require a Bearer token in the Authorization header. The Marketo API Call tool step handles this automatically when you provide your Client ID, Client Secret, and REST API Endpoint.
### How to use the Marketo API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add Marketo functionality to.
1. Scroll down to Tool-steps
2. Search for "Marketo API Call" in the tool step search bar
3. Add the Marketo API Call tool step to your workflow
Provide your Marketo credentials:
* **Client ID**: Your Marketo API Client ID
* **Client Secret**: Your Marketo API Client Secret
* **REST API Endpoint**: Your Marketo REST API endpoint URL
The tool step will automatically handle OAuth token generation and include the Bearer token in the Authorization header.
Configure the API endpoint, method, and parameters according to your needs:
* **Method**: Select the HTTP method (GET, POST, DELETE)
* **Endpoint**: Enter the API endpoint path (e.g., `/rest/v1/leads.json`)
* **Query Parameters**: Add any required query parameters
* **Body**: Add any required request body data (for POST requests)
Test your configuration to ensure it works correctly before deploying. Verify that you're receiving the expected data from Marketo.
### Example: Get Leads from Marketo
Here's a practical example of using the Marketo API Call tool step to retrieve leads:
**API Endpoint**: `GET /rest/v1/leads.json`
**Configuration**:
```json theme={null}
{
"method": "GET",
"endpoint": "/rest/v1/leads.json",
"query_parameters": {
"filterType": "email",
"filterValues": "user@example.com"
}
}
```
This configuration:
* Uses the GET method to retrieve leads
* Filters leads by email address
* Returns lead information including custom fields
### Example: Trigger a Campaign
**API Endpoint**: `POST /rest/v1/campaigns/{campaignId}/trigger.json`
**Configuration**:
```json theme={null}
{
"method": "POST",
"endpoint": "/rest/v1/campaigns/1234/trigger.json",
"body": {
"input": {
"leads": [
{
"id": 5678
}
]
}
}
}
```
This configuration:
* Uses the POST method to trigger a campaign
* Specifies the campaign ID in the endpoint
* Provides lead IDs to trigger the campaign for
You can find Marketo's complete API documentation at [https://developer.adobe.com/marketo-apis/](https://developer.adobe.com/marketo-apis/).
## Common Marketo API endpoints
Here are some commonly used Marketo API endpoints you can use with the Marketo API Call tool step:
* **Get leads**: `GET /rest/v1/leads.json?filterType={filterType}&filterValues={filterValues}`
* **Create/update leads**: `POST /rest/v1/leads.json`
* **Get lead by filter type**: `GET /rest/v1/leads.json?filterType=id&filterValues=1,2,3`
* **Get lead activities**: `GET /rest/v1/activities/leadchanges.json`
[View API Documentation](https://experienceleague.adobe.com/en/docs/marketo-developer/marketo/rest/lead-database/leads)
* **Get campaigns**: `GET /rest/v1/campaigns.json`
* **Trigger campaign**: `POST /rest/v1/campaigns/{id}/trigger.json`
* **Schedule campaign**: `POST /rest/v1/campaigns/{id}/schedule.json`
* **Get campaign by ID**: `GET /rest/v1/campaigns/{id}.json`
[View API Documentation](https://experienceleague.adobe.com/en/docs/marketo-developer/marketo/rest/assets/smart-campaigns)
* **Get email programs**: `GET /rest/asset/v1/programs.json?type=email`
* **Get email content**: `GET /rest/asset/v1/email/{id}/content.json`
* **Get email by name**: `GET /rest/asset/v1/email/byName.json?name={name}`
* **Approve email**: `POST /rest/asset/v1/email/{id}/approveDraft.json`
[View API Documentation](https://experienceleague.adobe.com/en/docs/marketo-developer/marketo/rest/assets/emails)
* **Get email program stats**: `GET /rest/asset/v1/program/{id}/stats.json`
* **Get landing page stats**: `GET /rest/asset/v1/landingPage/{id}/stats.json`
* **Get email performance**: `GET /rest/v1/activities/emailbounced.json`
* **Get email opens**: `GET /rest/v1/activities/emailopened.json`
[View API Documentation](https://experienceleague.adobe.com/en/docs/marketo-developer/marketo/rest/endpoint-reference)
* **Get lists**: `GET /rest/v1/lists.json`
* **Add leads to list**: `POST /rest/v1/lists/{listId}/leads.json`
* **Remove leads from list**: `DELETE /rest/v1/lists/{listId}/leads.json`
* **Check list membership**: `GET /rest/v1/lists/{listId}/leads.json`
[View API Documentation](https://experienceleague.adobe.com/en/docs/marketo-developer/marketo/rest/lead-database/static-lists)
For a complete list of available endpoints, visit the [Marketo REST API Endpoint Reference](https://experienceleague.adobe.com/en/docs/marketo-developer/marketo/rest/endpoint-reference).
## Example use cases
Here are some ways you can leverage the Marketo integration with your agents:
Create an agent that automatically retrieves campaign metrics, calculates average open rates, tracks click-through rates, and generates performance reports. The agent can monitor email program statistics and alert your team when campaigns exceed or fall below performance thresholds.
Build an agent that retrieves the number of leads in your database, segments them by criteria, tracks lead growth over time, and provides insights into lead quality and distribution across different campaigns and programs.
Deploy an agent that accesses campaign email metrics including open rates, click rates, bounce rates, and unsubscribe rates. The agent can compile this data into regular reports or dashboards for marketing team review.
Create an agent that automatically updates lead scores based on engagement activities, campaign interactions, and behavioral data. The agent can retrieve lead activities, calculate scores using custom logic, and update lead records in Marketo.
Build an agent that triggers Marketo campaigns based on external events or conditions. For example, trigger a welcome campaign when a lead is created in your CRM, or launch a re-engagement campaign when leads meet specific criteria.
Deploy an agent that enriches lead data by retrieving information from external sources, updating lead records in Marketo with additional fields, and ensuring data consistency across your marketing stack.
Create an agent that retrieves campaign costs, performance metrics, and conversion data to calculate marketing ROI. The agent can track revenue attribution, cost per lead, and campaign effectiveness across different channels.
Build an agent that generates weekly or monthly marketing reports by pulling data from multiple Marketo endpoints, combining statistics, and formatting them into comprehensive reports for stakeholders.
## Frequently asked questions (FAQs)
To get your Marketo API credentials:
1. Log into Marketo as an administrator
2. Go to **Admin** > **Integration** > **LaunchPoint**
3. Create a new service with type "Custom"
4. Assign an API-only user to the service
5. View the service details to get your Client ID and Client Secret
6. Get your REST API Endpoint from **Admin** > **Integration** > **Web Services**
You'll need all three pieces of information (Client ID, Client Secret, and REST API Endpoint) to authenticate with the Marketo API.
Marketo enforces rate limits on API calls:
* **Standard limit**: 100 calls per 20 seconds
* **Daily quota**: Varies by subscription (typically 10,000-50,000 calls per day)
Your agents should be designed to handle rate limiting gracefully. The Marketo API will return a 606 error code when rate limits are exceeded. Consider implementing retry logic with exponential backoff for production workflows.
Marketo uses 2-legged OAuth 2.0 authentication. When you provide your Client ID, Client Secret, and REST API Endpoint to the Marketo API Call tool step, it automatically:
1. Requests an access token from Marketo's identity service
2. Includes the Bearer token in the Authorization header of API requests
3. Handles token refresh when tokens expire (typically after 3600 seconds)
You don't need to manage tokens manually - the tool step handles this automatically.
Common authentication issues include:
* **Invalid credentials**: Double-check your Client ID, Client Secret, and REST API Endpoint
* **API user permissions**: Ensure the API user assigned to your LaunchPoint service has appropriate permissions
* **Expired tokens**: The tool step should handle token refresh automatically, but network issues can sometimes cause problems
* **Incorrect endpoint URL**: Make sure you're using the correct REST API endpoint for your Marketo instance
If problems persist, try creating a new LaunchPoint service with a fresh set of credentials.
Yes! You can retrieve historical campaign data using various Marketo API endpoints:
* Use the Activities API to get historical lead activities
* Retrieve email program statistics for past campaigns
* Access landing page performance data
* Query lead changes and updates over time
Note that data retention policies may vary based on your Marketo subscription level.
* **Smart Campaigns**: Automated workflows that can include multiple steps, triggers, and actions. Use the Campaigns API endpoints to trigger or schedule these.
* **Email Programs**: Specifically designed for email marketing with built-in A/B testing and reporting. Use the Email Programs API endpoints to retrieve content and statistics.
Both can be accessed through the Marketo API Call tool step using their respective endpoints.
Many Marketo API endpoints return paginated results. To handle pagination:
1. Check the response for `nextPageToken` in the result
2. Use the token in subsequent requests with the `nextPageToken` parameter
3. Continue until no `nextPageToken` is returned
Consider using looping in your tools to automatically retrieve all pages of results.
Yes, you can create and manage custom fields using the Lead Database API. However, custom field creation requires specific API permissions. Ensure your API user has the necessary permissions in Marketo's role settings under **Admin** > **Users & Roles**.
## Additional resources
Access the complete Marketo API documentation and developer resources
Detailed REST API reference and guides
Learn about Marketo's OAuth 2.0 authentication
Complete list of available API endpoints
# Microsoft Teams
Source: https://relevanceai.com/docs/integrations/popular-integrations/microsoft-teams
Microsoft Teams is a collaboration platform that combines workplace chat, video meetings, file storage, and application integration.
With Relevance AI's Microsoft Teams integration, you can connect your Teams workspace to your AI agents, enabling them to monitor channels, respond to messages, and automate communication workflows directly within Teams.
Relevance AI uses a unified Microsoft authentication that works across **Teams**, **Outlook**, **SharePoint**, and **OneDrive** — connecting one account gives you access to all services. See the [Outlook integration](/docs/integrations/popular-integrations/outlook) and [SharePoint knowledge source](/docs/build/knowledge/integrated-knowledge-sources/sharepoint) pages for details on those services.
## Prerequisites
Before setting up the Microsoft Teams integration, ensure you have:
An active project in Relevance AI
Desktop or web app within your organization
Enterprise organizations may require admin consent from a Global Administrator or Teams Administrator (see [Admin consent & permissions](#admin-consent-permissions))
At least one channel or chat where you want your agent to operate
## Setup overview
Setting up Microsoft Teams requires two separate steps. Both are required — completing only one is not enough.
Authenticate via OAuth in Relevance AI to grant access to Microsoft services.
Add the app from the Teams app store to the channels and chats where your agent should operate.
## Step 1 - Connect the integration
In the Relevance AI dashboard, click **Integrations & API Keys** in the sidebar.
Locate **Microsoft (Teams, Outlook, SharePoint, OneDrive)** in the list of available integrations.
Click **Add Integration**. A pop-up window will open for Microsoft sign-in.
If a pop-up window doesn't appear, check your browser's pop-up blocker settings and allow pop-ups from Relevance AI.
Enter your Microsoft credentials in the pop-up window and sign in.
The Microsoft account you sign in with determines which Teams, channels, and chats are visible to the integration. Use the account that has access to the channels your agent needs to operate in.
Review the requested permissions and click **Accept**. These permissions allow Relevance AI to read and send messages, access channel and team information, and maintain a persistent connection.
If you see a "Need admin approval" message, your organization's Azure AD / Entra ID tenant restricts third-party app consent. See [Admin consent & permissions](#admin-consent-permissions) for next steps.
For a full list of requested scopes, see the [Permissions reference](#permissions-reference).
Once complete, you'll see a green **Connected** status indicator next to the Microsoft integration in Relevance AI.
### Linking your account via magic link
Both the magic link flow and the standard OAuth flow achieve the same outcome — your Microsoft Teams account is linked to your Relevance AI account.
You may receive a magic link from Microsoft Teams or via email inviting you to connect your accounts. This is an alternative to the standard OAuth flow above and achieves the same result.
1. Click the magic link in Microsoft Teams or your email.
2. If you're not logged in to Relevance AI, you'll be redirected to sign in first. After signing in, you'll be returned to the consent page automatically.
3. On the consent page, review your Relevance AI account email and your Microsoft Teams account details shown.
4. Click **Confirm** to link the accounts, or **Cancel** to abort the connection.
## Step 2 - Install the Relevance AI app in Microsoft Teams
After connecting your Microsoft account, you need to install the Relevance AI app in Teams so your agents can interact with channels and chats.
The Relevance AI app must be added to every channel and group chat where you want your agent to respond. Triggers and tool steps will not work in channels or chats where the app has not been added.
In Microsoft Teams, click on **Apps** in the left sidebar.
Type **Relevance AI** in the search bar and locate the app in the results.
If you don't see the Relevance AI app, your organization may restrict third-party app installations. See [Admin consent & permissions](#admin-consent-permissions) for how to request approval.
Click **Add** or **Install** to add the Relevance AI app to your Teams workspace.
After installing, add the app to each channel or group chat where you want your agent to operate.
1. Navigate to the channel where you want your agent to work
2. Click the **+** icon at the top of the channel to add a tab or app
3. Search for **Relevance AI** in the app picker
4. Select the app and click **Save**
1. Open the group chat where you want your agent to work
2. Click the **+** icon or **Add apps** button
3. Search for and select **Relevance AI**
4. Add the app to the chat
Confirm the Relevance AI app appears in the channel's app list and that the channel shows up in the trigger setup dropdown in Relevance AI.
## Triggers
Triggers let your agents respond to Teams messages automatically, so your team can get answers, run workflows, and escalate issues without leaving their existing conversations. Instead of switching to a separate tool, users interact with agents right where they already communicate.
The Relevance AI app is available on the Microsoft Teams marketplace. Users can @mention or message the app in channels, group chats, or direct messages to trigger agents and have two-way conversations directly in Teams. The same trigger setup also works for [workforces](/docs/build/workforces/create-a-workforce).
Teams triggers activate only on new messages. They do not trigger on new chat creation, group creation, or webhooks.
### Setting up a trigger
Before setting up a trigger, confirm that you have completed both Step 1: Connect the integration and Step 2: Install the Relevance AI app.
Navigate to your agent in Relevance AI and go to the **Triggers** section.
Click **Add Trigger** and select **Microsoft Teams** from the list.
Choose the Microsoft account you connected, then select the **Team** and specific **channel** or **chat** you want to monitor.
Only channels where the authenticated user is a member and the Relevance AI app has been added will appear in the dropdown.
Set up **keyword matching** to filter which messages activate your agent. Leave the keyword field empty to trigger on all messages, or enter specific keywords separated by commas. The trigger checks whether any of the keywords appear anywhere in the message text (case-insensitive).
In the **Core Instructions** section, write a prompt that guides how your agent should respond — including its role, tone, and when to respond.
Set tool permissions to "approval mode" initially so your agent asks before sending messages. Switch to autopilot once you're confident.
### Advanced trigger settings
#### Thread reply method
The Thread Reply Method controls whether your agent posts a response back to the Teams thread after processing a message. The setting is per-trigger and opt-in, so the default keeps existing triggers behaving exactly as before.
Default. The agent processes the message and posts its response back into the Teams thread.
The agent processes the message silently. Use this when the output goes somewhere other than Teams — a database write, an email, or a downstream workflow.
Go to your agent's **Microsoft Teams** trigger in Relevance AI.
Click **Advanced Settings** to reveal the additional trigger options.
Select **Agent auto-reply** or **No reply** under **Thread Reply Method**.
When "No reply" is selected, you won't see confirmation in Teams that your agent processed the message. Monitor the agent's task history in Relevance AI to verify it's working correctly.
#### Outreach replies only
Enable this toggle to restrict the agent to responding only to replies to messages it previously sent in the channel, rather than all new messages.
This is useful for outreach workflows where the agent sends messages to users and needs to follow up only with those who respond. Rather than monitoring all channel activity, the agent stays focused on conversations it initiated.
Go to your agent's **Microsoft Teams** trigger in Relevance AI.
Locate the **Outreach replies only** toggle, turn it on, and save your configuration.
When enabled, the trigger subtitle changes to **"On replies to outreach messages"**. The agent triggers only when a user replies to a message the agent itself sent — new messages posted by other users will not activate it.
### How triggered conversations work
Once a trigger fires, the agent responds directly inside Teams with the following capabilities:
Agent replies are threaded in the channel. Conversation threads stay active for 30 minutes.
Responses are delivered as Microsoft Adaptive Cards — rich, interactive messages inside Teams.
Teams displays a typing indicator while the agent is processing a response.
Agents can receive and process inline images, pasted screenshots, and uploaded files (PDFs, documents, images) from Teams conversations.
Agents can proactively initiate conversations in Teams DMs without waiting for user input first. Context is maintained across the full conversation, enabling back-and-forth exchanges after the initial outreach.
Teams messages can trigger an entire workforce, not just an individual agent.
Messages that contain only attachments with no text will show a "\[N attachments]" indicator to the agent.
## Tool steps for Microsoft Teams
The Microsoft Teams integration provides actions your agents can use as tool steps in their workflows.
Post a message to a specific Teams channel
Send a direct message in Teams
Create a new channel in a Team
Get all teams the authenticated user belongs to
Get all channels in a Team
Fetch messages from a specific chat conversation
Search for messages across Teams channels and chats
Retrieve shift information from Teams
Make custom calls to Microsoft Graph API
Most Microsoft Teams tool steps are currently in beta. Please report any issues to our support team.
## Agent alerts
You can receive notifications in Microsoft Teams when your agents enter specific statuses or encounter tool errors. This helps you monitor agent activity and respond quickly when issues occur.
Agent notifications are currently in beta and may not be available for all accounts.
### Setting up Teams notifications
Navigate to your agent and click the **Build** tab, then click **Escalations** in the left sidebar.
Under "Agent Notifications", click **Add agent notification**.
Select **Microsoft Teams** as the platform, then choose the notification trigger: **Agent enters status** (select specific task statuses such as "Running", "Completed", or "Failed") or **Tool errors (any tool)** to get notified when any tool encounters an error. Select a Microsoft Teams account and the channel where you want to receive notifications. If no accounts appear, complete the [connection steps](#step-1-connect-the-integration) first.
Click **Publish changes** to save your notification configuration.
Test the notification by running your agent — you should receive a notification in your selected Teams channel based on your configured triggers.
### What you'll receive
When a notification is triggered, you'll receive a message in your Teams channel containing:
Agent name, status, and task details
Link to view the full task in Relevance AI
For tool errors: which tool failed and why
## Admin consent & permissions
Enterprise organizations often require administrator approval before users can connect third-party applications or install apps in Microsoft Teams.
### Understanding admin consent
Microsoft Azure AD (Entra ID) allows tenant administrators to restrict whether users can grant consent to third-party apps on their own. When this restriction is active, individual users will see a "Need admin approval" screen during the OAuth flow instead of the standard consent prompt. This is a tenant-level policy — it is not specific to Relevance AI.
If you see "Need admin approval" or "This app requires admin approval", follow the steps below.
If you see an admin approval message when connecting your Microsoft account:
Copy the **consent URL** that appears in the Microsoft login window. This URL contains the specific permissions Relevance AI is requesting.
Send the URL to your **Microsoft 365 Global Administrator or Application Administrator** with a request to grant consent. Include a brief explanation of what Relevance AI is and how it will be used.
Your administrator will open the URL, review the requested permissions, and click **Accept** to grant consent on behalf of the organization.
Return to Relevance AI and **retry the Microsoft integration connection**. The consent prompt should no longer appear.
If your organization requires admin approval for app installations:
Request approval to install the Relevance AI app in Microsoft Teams.
Your administrator will go to the [Microsoft Teams Admin Center](https://admin.teams.microsoft.com), navigate to **Teams apps** > **Manage apps**, search for **Relevance AI**, and change the app status to **Allowed**.
Once approved, follow the steps in [Step 2: Install the Relevance AI app](#step-2-install-the-relevance-ai-app-in-microsoft-teams).
## Permissions reference
The following OAuth scopes are requested when you connect your Microsoft account. These permissions allow Relevance AI to read and send messages, access team and channel metadata, and maintain persistent access.
| Scope | Description |
| ------------------------- | -------------------------------------------------------------- |
| `offline_access` | Maintains access without requiring frequent re-authentication |
| `Chat.Create` | Create new chats |
| `Chat.ReadWrite` | Read and write to chats the user has access to |
| `ChatMessage.Read` | Read chat messages |
| `ChatMessage.Send` | Send chat messages |
| `ChannelMessage.Read.All` | Read messages in channels the user has access to |
| `ChannelMessage.Send` | Send messages to channels |
| `Channel.ReadBasic.All` | Read basic channel information (name, description, ID) |
| `Team.ReadBasic.All` | Read basic team information (name, description, ID) |
| `User.Read` | Read the signed-in user's profile |
| `User.Read.All` | List users in the organization (used for trigger user filters) |
These permissions may evolve as new features are added to the integration. Any changes will be reflected in the OAuth consent prompt.
## Troubleshooting
This error means your Azure AD / Entra ID tenant has not granted consent for Relevance AI. Ask your Microsoft 365 Global Administrator to grant admin consent using the steps in [Admin consent & permissions](#admin-consent-permissions). Once consent is granted, retry the connection from the Integrations page.
This occurs when you or your administrator explicitly declined the permissions request during the OAuth flow. To resolve this, retry the integration connection from the Integrations page and click **Accept** when prompted. If the consent was denied by an admin policy, your administrator will need to grant consent on your behalf.
If the Relevance AI app does not appear in the Teams app store, your organization likely restricts third-party app installations. Ask your IT administrator to allow the app in the [Microsoft Teams Admin Center](https://admin.teams.microsoft.com) under **Teams apps** > **Manage apps**. See [Admin consent & permissions](#admin-consent-permissions) for detailed steps.
Some Teams features are controlled by feature flags and may not be enabled for all accounts. If you don't see Microsoft Teams as a trigger option in your agent or workforce settings, [contact our support team](/docs/get-started/support) to check whether the feature needs to be enabled for your account.
Verify that the Relevance AI app has been added to the specific channel or chat being monitored (not just installed in Teams), and that the Microsoft account used for the trigger is a member of the channel. Confirm the trigger is enabled and published in your agent's settings. If keyword matching is configured, check that messages contain the expected keywords. Review the agent's task logs in Relevance AI for errors — a `401 Unauthorized` error indicates the OAuth token has expired or been revoked, and you should reconnect the Microsoft integration.
Magic links are time-limited and may expire before you click them. If your magic link no longer works, connect your Microsoft Teams account directly through the standard OAuth flow: go to **Integrations & API Keys** in the sidebar, find the Microsoft integration, and click **Add Integration**.
The consent page shows two email addresses: your Relevance AI account email and your Microsoft Teams account email. If either address looks incorrect, click **Cancel** and verify that you're logged in to the correct Relevance AI account before trying again. To switch accounts, sign out of Relevance AI and sign in with the correct account, then click the magic link again.
## Frequently asked questions (FAQs)
The Microsoft Teams integration is built and maintained by Relevance AI. For integration-specific questions, [contact our support team](/docs/get-started/support). For Microsoft Teams platform issues, contact [Microsoft support](https://support.microsoft.com/).
The most common cause is that the Relevance AI app has not been installed in Teams or added to the specific channel. The Microsoft account you connected must also be a member of that channel. If your organization requires admin consent, the app may not be visible until an administrator approves it. Verify that you've completed both setup steps and added the app to the channel.
Yes, you can connect multiple Microsoft accounts through the Integrations & API Keys page. Each account can be used for different triggers and tool steps.
Yes, Teams triggers can monitor both channel messages and private chats. To monitor direct messages, select the "Direct chats with Relevance AI" option when configuring your trigger instead of a specific channel.
Yes. Set the Thread Reply Method to "No reply" in your MS Teams trigger's Advanced Settings. This allows your agent to process messages without posting a response back to Teams — useful when the agent's output goes somewhere else, such as a database, email, or another workflow. The default is "Agent auto-reply", which maintains existing behavior. To verify the agent is running correctly, check the task history in Relevance AI.
Yes, files shared in Teams channels are stored in SharePoint. You can access them through the Microsoft API Call tool step via the Microsoft Graph API.
Pre-built tool steps (like "Send Channel Message") are designed for common tasks with simplified interfaces. The Microsoft API Call tool step gives you full access to Microsoft Graph API for advanced operations not covered by pre-built steps.
Yes, Microsoft Graph API enforces rate limits depending on your Microsoft 365 subscription. Microsoft returns a `429 Too Many Requests` status code when limits are exceeded.
Go to the **Integrations & API Keys** page from the sidebar, find **Microsoft (Teams, Outlook, SharePoint, OneDrive)**, click "..." on the account you want to remove, and click "Remove" and confirm. This will disable all triggers and tool steps using this account across Teams, Outlook, SharePoint, and OneDrive. To also remove the app from Microsoft Teams, go to **Apps** in Teams, find Relevance AI, and click **Uninstall**.
A magic link is an alternative way to connect your Microsoft Teams account to Relevance AI. When you click the link, you're taken to a consent page in Relevance AI that shows your Relevance AI account email and your Microsoft Teams account details. Click **Confirm** to complete the connection or **Cancel** to abort it. The magic link method achieves the same result as connecting via the standard OAuth flow on the Integrations page.
Both methods work and achieve the same result. You can connect your Microsoft Teams account through the standard OAuth flow on the **Integrations & API Keys** page, or by clicking a magic link you received from Microsoft Teams or via email. Use whichever is more convenient.
If you're not logged in to Relevance AI when you click the magic link, you'll be redirected to the sign-in page. After signing in, you'll be automatically returned to the consent page to complete the account linking.
# Notion
Source: https://relevanceai.com/docs/integrations/popular-integrations/notion
Seamlessly connect your AI agents with Notion workspaces to automate document creation, information retrieval, and workspace management.
## Connecting the Integration
To connect the Notion integration with Relevance AI:
1. Navigate to the Integrations section in your Relevance AI dashboard
2. Select "Notion" from the available integrations
3. Click "Connect"
4. You'll be redirected to Notion to authorize the connection
5. Select the Notion workspace you want to connect
6. Review the permissions requested and click "Allow access"
7. You'll be redirected back to Relevance AI with the integration now connected
Once connected, your Notion workspace will be available for your agents to access through various tools and actions.
## Notion API Authentication
To use Notion tools with your agent, you'll need to:
1. Create a Notion integration at [https://www.notion.so/my-integrations](https://www.notion.so/my-integrations)
2. Generate an API key for your integration
3. Share specific pages or databases with your integration
4. Provide the API key when configuring Notion tools in Relevance AI
### Creating a Notion Integration
1. Go to [https://www.notion.so/my-integrations](https://www.notion.so/my-integrations)
2. Click "New integration"
3. Enter a name for your integration (e.g., "Relevance AI Assistant")
4. Select the workspace where you want to use the integration
5. Upload an icon (optional)
6. Configure the capabilities your integration needs:
* Read content: Required for retrieving information from Notion
* Update content: Required for modifying existing pages
* Insert content: Required for creating new pages or database entries
7. Click "Submit" to create your integration
### Generating and Managing API Keys
After creating your integration:
1. Navigate to the "Secrets" tab in your integration settings
2. You'll see your "Internal Integration Token" (API key)
3. Copy this token to use with Relevance AI tools
4. For security, you can regenerate this token at any time if needed
### Sharing Pages with Your Integration
For your integration to access specific Notion content:
1. Open the Notion page or database you want to share
2. Click the "..." menu in the top-right corner
3. Select "Add connections"
4. Find and select your integration from the list
5. Click "Confirm" to grant access
Remember that you must explicitly share each page or database you want your integration to access. Parent pages do not automatically grant access to child pages.
## Setting Up Triggers
The Notion integration can be configured to trigger your AI agents when specific events occur in your Notion workspace. This allows your agents to respond automatically to changes in your documentation.
To set up a Notion trigger *(coming soon)*:
1. Navigate to your "agent's profile" page
2. Under "Triggers", select "Notion"
3. Choose the trigger type:
* New Page Created
* Page Updated
* Database Entry Added
* Comment Added
* Mention in Page
4. Configure the specific conditions for the trigger (e.g., which database to monitor)
5. Save your trigger configuration
With triggers configured, your agent will automatically activate when the specified events occur in your Notion workspace, allowing for real-time responses to documentation changes.
## Tools & Tool Steps
The Notion integration provides a rich set of tools and actions that your agents can use to interact with your Notion workspace. These actions can be incorporated into your agent's workflows to automate various documentation tasks.
### Available Notion Actions
Your agents can leverage these powerful Notion actions:
* **Create Notion Page**: Generate new pages with formatted content, including headings, lists, tables, and more
* **Update Notion Page**: Modify existing page content while preserving structure
* **Get Notion Page Content**: Retrieve and analyze the content of specific pages
* **Create Database Entry**: Add new items to Notion databases with structured properties
* **Query Database**: Search and filter database entries based on specific criteria
* **Get Database Structure**: Retrieve the schema of a database to understand its properties
* **Add Comments**: Post comments on pages for collaborative feedback
* **Create To-Do Items**: Generate actionable tasks within Notion pages
* **Get User Details**: Retrieve information about Notion workspace members
* **Search Notion**: Find relevant content across your entire workspace
And many more! These actions can be combined in powerful ways to create sophisticated documentation workflows.
### Example Use Cases
Here are some examples of how your agents can use Notion actions:
* **Meeting Documentation**: Automatically create meeting notes in Notion after calendar events
* **Knowledge Base Management**: Update documentation when new information becomes available
* **Project Tracking**: Create and update project status pages based on progress
* **Content Creation**: Generate draft documents for review based on specific requirements
* **Research Compilation**: Gather information from various sources and organize it in Notion pages
## Using the Notion API Tool Step (Advanced)
For advanced users who need more customized functionality, the Notion API tool step provides direct access to the Notion API. This allows you to build custom tools that perform specialized Notion operations beyond the standard actions.
To use the Notion API tool step:
1. Create a new tool in Relevance AI
2. Scroll down to Tool-steps
3. Add "Notion API" tool-step
4. Select your connected Notion account in the dropdown
5. Configure the API endpoint, method, and parameters
6. Test your custom API call
7. Save your tool configuration
The Notion API tool step gives you the flexibility to create highly customized Notion interactions tailored to your specific needs.
## Best Practices
To get the most out of the Notion integration:
* **Structure Your Workspace**: Organize your Notion workspace with clear hierarchies to make it easier for agents to navigate
* **Use Templates**: Create templates for common document types to ensure consistency
* **Set Clear Permissions**: Configure appropriate access levels for your agents in Notion
* **Monitor Activity**: Regularly review the actions your agents are taking in your Notion workspace
* **Start Simple**: Begin with basic documentation tasks before implementing more complex workflows
* **Secure Your API Keys**: Store your Notion API keys securely and rotate them periodically
* **Test Thoroughly**: Always test your integration in a controlled environment before deploying to production
## Troubleshooting
**Connection Issues**
* Ensure your Notion authorization hasn't expired
* Verify you've granted all necessary permissions
* Check that your Notion workspace is accessible
* Confirm your API key is valid and has not been revoked
**Content Creation Problems**
* Review the formatting in your agent's instructions
* Ensure the agent has access to the parent pages where content is being created
* Check for any API rate limits that might be affecting performance
**Trigger Reliability**
* Verify that your trigger conditions are correctly configured
* Ensure the monitored pages or databases are accessible to the integration
* Check that webhook notifications are enabled in your Notion workspace settings
**API Authentication Errors**
* Verify that your API key is correctly entered in the tool configuration
* Ensure the pages you're trying to access have been shared with your integration
* Check that your integration has the necessary capabilities enabled
For additional assistance, contact Relevance AI support or consult the detailed API documentation.
## Related Features
[Knowledge Integration](https://relevanceai.com/docs/build/knowledge/create-knowledge) - Connect your Notion workspace as a knowledge source for your agents, allowing them to reference your documentation when responding to queries.
[Document Processing Tools](https://relevanceai.com/docs/build/tools/templates) - Combine Notion integration with document processing capabilities to extract, analyze, and organize information from various sources.
[Workflow Automation](https://relevanceai.com/docs/build/agents/customise-agent/flowbuilder) - Create sophisticated workflows that incorporate Notion actions alongside other integrations for end-to-end process automation.
## Notion Assistant
The Notion Assistant is a pre-built agent available from the [Marketplace](https://app.relevanceai.com/marketplace) that builds databases, creates pages, and organizes your workspace through plain English. It validates requests before making changes and handles complex multi-step workflows automatically.
Search "Notion Assistant" in the Marketplace to clone it and start managing your workspace through conversation
# Outlook
Source: https://relevanceai.com/docs/integrations/popular-integrations/outlook
Microsoft Outlook is a comprehensive email and calendar management platform used by millions of professionals worldwide.
Microsoft Outlook is a comprehensive email and calendar management platform used by millions of professionals worldwide. With Relevance AI's Outlook integration, you can seamlessly connect your Outlook account to your AI agents, enabling them to manage emails, calendar events, contacts, and more, making your communication workflows more efficient and intelligent.
The Outlook integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not Microsoft. If you have a question or issue with using Outlook in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about Outlook, you can [reach out to Microsoft support](https://support.microsoft.com/).
## Connect the integration
Connecting your Outlook account to Relevance AI is a straightforward process:
1. Go to the "Integrations & API Keys" page in the sidebar of your Relevance AI dashboard.
2. Click on "Outlook" from the available integrations.
3. Click on the "Add Integration" button.
4. In the pop-up window, sign into your Microsoft account.
5. Grant the necessary permissions for Relevance AI to access your Outlook data.
6. Once authenticated, your Outlook account will appear as a connected integration.
After connecting, you can use Outlook as a trigger for your agents to automatically respond to incoming emails, or use Outlook tool steps in your custom tools to manage emails, calendar events, and contacts.
## Tool steps for Outlook
The Outlook integration provides a comprehensive set of actions that your agents can use to interact with your emails, calendar, and contacts. These actions can be incorporated into your agent's workflows as tool steps, enabling sophisticated communication automation capabilities.
### Email Management
Search for specific emails in your mailbox
Retrieve all email folders in your account
Get all email labels/categories
Add a label or category to an email
Remove a label or category from an email
Move an email to a different folder
Send an email from your Outlook account
### Calendar Management
Check if a time slot is available
Create a new calendar event
Delete an existing calendar event
List calendar events within a date range
Update an existing calendar event
Retrieve free/busy schedule information
### Contact Management
Create a new contact in your address book
Search for a specific contact
List all contacts in your address book
Update an existing contact's information
### Advanced Operations
Make custom API calls to Microsoft Graph API
Type "Outlook" in the tool step search bar to see all available Outlook actions when building your tools.
## Use the integration's API tool step (Advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform Outlook-specific activities using the Microsoft Outlook API Call tool step. This gives you access to the full Microsoft Graph API for advanced email, calendar, and contact operations.
### How to use the Microsoft Outlook API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add Outlook functionality to.
1. Scroll down to Tool-steps
2. Search for "Microsoft Outlook API Call" in the tool step search bar
3. Add the Microsoft Outlook API Call tool step to your workflow
Select your connected Outlook account from the dropdown menu.
Configure the API endpoint, method, and parameters according to your needs:
* **Method**: Select the HTTP method (GET, POST, PUT, DELETE, PATCH)
* **Endpoint**: Enter the API endpoint path (e.g., `/me/messages`, `/me/calendar/events`)
* **Body**: Add any required request body data
* **Headers**: Add any custom headers if needed
Test your configuration to ensure it works correctly before deploying.
### Example: Creating a Calendar Event with Custom Properties
Here's a practical example of using the Microsoft Outlook API Call tool step to create a calendar event with custom properties:
**API Endpoint**: `POST /me/calendar/events`
**Configuration**:
```json theme={null}
{
"method": "POST",
"endpoint": "/me/calendar/events",
"body": {
"subject": "Team Sync Meeting",
"body": {
"contentType": "HTML",
"content": "Discuss Q4 objectives and team priorities"
},
"start": {
"dateTime": "2024-12-01T14:00:00",
"timeZone": "Pacific Standard Time"
},
"end": {
"dateTime": "2024-12-01T15:00:00",
"timeZone": "Pacific Standard Time"
},
"location": {
"displayName": "Conference Room A"
},
"attendees": [
{
"emailAddress": {
"address": "colleague@example.com",
"name": "Colleague Name"
},
"type": "required"
}
]
}
}
```
This configuration:
* Uses the POST method to create a new event
* Specifies the event details including subject, body, and location
* Sets the start and end times with timezone information
* Adds attendees to the meeting
You can find Microsoft Graph API's complete documentation at [https://learn.microsoft.com/en-us/graph/api/overview](https://learn.microsoft.com/en-us/graph/api/overview).
### Common Microsoft Graph API Endpoints for Outlook
Here are some commonly used Microsoft Graph API endpoints you can use with the API Call tool step:
* **List messages**: `GET /me/messages`
* **Get message**: `GET /me/messages/{id}`
* **Send email**: `POST /me/sendMail`
* **Reply to email**: `POST /me/messages/{id}/reply`
* **Forward email**: `POST /me/messages/{id}/forward`
* **Delete email**: `DELETE /me/messages/{id}`
* **Mark as read**: `PATCH /me/messages/{id}` with `{"isRead": true}`
[View API Documentation](https://learn.microsoft.com/en-us/graph/api/resources/message)
* **List events**: `GET /me/calendar/events`
* **Get event**: `GET /me/events/{id}`
* **Create event**: `POST /me/calendar/events`
* **Update event**: `PATCH /me/events/{id}`
* **Delete event**: `DELETE /me/events/{id}`
* **Get schedule**: `POST /me/calendar/getSchedule`
[View API Documentation](https://learn.microsoft.com/en-us/graph/api/resources/event)
* **List contacts**: `GET /me/contacts`
* **Get contact**: `GET /me/contacts/{id}`
* **Create contact**: `POST /me/contacts`
* **Update contact**: `PATCH /me/contacts/{id}`
* **Delete contact**: `DELETE /me/contacts/{id}`
[View API Documentation](https://learn.microsoft.com/en-us/graph/api/resources/contact)
* **List folders**: `GET /me/mailFolders`
* **Get folder**: `GET /me/mailFolders/{id}`
* **Create folder**: `POST /me/mailFolders`
* **Move message**: `POST /me/messages/{id}/move`
* **Copy message**: `POST /me/messages/{id}/copy`
[View API Documentation](https://learn.microsoft.com/en-us/graph/api/resources/mailfolder)
* **Search messages**: `GET /me/messages?$search="subject:meeting"`
* **Filter messages**: `GET /me/messages?$filter=from/emailAddress/address eq 'user@example.com'`
* **Order results**: `GET /me/messages?$orderby=receivedDateTime desc`
* **Select fields**: `GET /me/messages?$select=subject,from,receivedDateTime`
[View API Documentation](https://learn.microsoft.com/en-us/graph/query-parameters)
Use the `$filter`, `$search`, `$orderby`, and `$select` query parameters to refine your API calls and retrieve exactly the data you need.
## Set up Outlook as a trigger
You can configure your agents to automatically respond to incoming Outlook emails by setting up Outlook as a trigger.
The Outlook trigger has a 25MB per-attachment limit due to Microsoft Graph API constraints, so emails with attachments larger than 25MB will not be processed by the trigger. To work around this, compress large files before sending, convert large DOCX files to PDF format to reduce file size, or use cloud storage links (OneDrive, SharePoint) instead of large attachments.
### How to set up the Outlook trigger
Navigate to your agent's settings page.
1. Click on "Integrations & API Keys" in the sidebar
2. Under "Triggers", click on the Outlook button
3. Select your connected Outlook account
Choose whether to filter emails that trigger your agent. Without a search filter, your agent will receive every email sent to your connected account.
You can use Microsoft Graph search query syntax to filter emails:
* `subject:ask us anything` - Subject contains "ask us anything"
* `body:book a demo` - Body contains "book a demo"
* `from:*apple.com` - Only emails from apple.com domain
* `hasAttachments:true` - Only emails with attachments
* `received:07/23/2018` - Only emails received on this date
[View full search syntax documentation](https://learn.microsoft.com/en-us/graph/search-query-parameter)
Build a tool that uses the "Send Email (Outlook)" tool step to respond to emails. Equip your agent with this tool in the agent settings.
Set the tool permissions to "approval mode" initially so your agent asks for permission before sending emails. Switch to autopilot once you're confident in the responses.
In the "Core Instructions" section of your agent settings, write a prompt that guides your agent on how to respond to emails.
It can take up to 30 minutes for the first email to come through after setting up the trigger.
## Example use cases
Here are some ways you can leverage the Outlook integration with your agents:
Create an agent that automatically responds to customer support emails, categorizes inquiries, searches your knowledge base for relevant information, and provides helpful responses. The agent can escalate complex issues to human team members and track response times.
Build an agent that manages your calendar by finding available time slots, scheduling meetings with attendees, sending calendar invites, and handling rescheduling requests. The agent can check multiple calendars for conflicts and suggest optimal meeting times.
Deploy an agent that automatically organizes incoming emails by moving them to appropriate folders, adding labels based on content, flagging urgent messages, and archiving newsletters or promotional emails according to your preferences.
Create an agent that qualifies leads from incoming emails, extracts key information (company size, budget, timeline), updates your CRM, and schedules follow-up calls with qualified prospects while sending polite responses to unqualified leads.
Build an agent that sends meeting summaries and action items to attendees after calendar events, tracks follow-up tasks, and sends reminders for pending action items. The agent can integrate with your project management tools.
Deploy an agent that manages your email newsletter by collecting subscriber information, organizing contact lists, scheduling newsletter sends, and tracking engagement metrics like open rates and click-throughs.
Create an agent that handles emails while you're away by sending personalized auto-responses, forwarding urgent messages to colleagues, categorizing emails for later review, and scheduling follow-ups for when you return.
Build an agent that automatically processes invoices and receipts received via email, extracts key information (amount, date, vendor), saves attachments to cloud storage, and updates your accounting system or expense tracking tools.
Deploy an agent that handles event registrations via email, confirms attendance, sends calendar invites with event details, manages waitlists, and sends reminder emails before the event.
Create an agent that keeps your contacts synchronized across platforms, enriches contact information from email signatures, updates contact details when changes are detected, and removes duplicate entries.
## Frequently asked questions (FAQs)
This issue occurs because new Microsoft Teams scopes have been added to the Outlook integration (`OnlineMeetingTranscript.Read.All` and `MailBoxSettings.Read`).
**Solution**: Update the permission type filter to select the **Microsoft Teams** option. This will allow you to see and select your Outlook account that now includes the expanded Microsoft Teams permissions.
If you continue to experience issues, try reconnecting your Outlook account through the Integrations & API Keys page to ensure all the latest permissions are granted.
The integration requires permissions to read and write emails, manage calendar events, access contacts, and read mailbox settings. This includes Microsoft Teams scopes for meeting transcripts and mailbox settings. You can review the specific permissions during the authentication process.
After setting up the Outlook trigger, it can take up to 30 minutes for the first email to come through to your agent. Subsequent emails should be processed more quickly, typically within a few minutes.
The Outlook trigger has a 25MB per-attachment limit due to Microsoft Graph API constraints, so emails with attachments larger than 25MB will not be processed by the trigger. To work around this, ask senders to compress large files before sending, convert large DOCX files to PDF format to reduce file size, or use cloud storage links (OneDrive, SharePoint, Dropbox) instead of attaching large files directly. You can also set up a separate workflow to handle large file transfers outside of email. This is a Microsoft Graph API limitation, not a Relevance AI limitation.
Yes! You can use Microsoft Graph search query syntax to filter emails. For example:
* Filter by subject: `subject:customer inquiry`
* Filter by sender: `from:*company.com`
* Filter by attachments: `hasAttachments:true`
* Combine filters: `subject:urgent AND from:*vip.com`
[View full search syntax documentation](https://learn.microsoft.com/en-us/graph/search-query-parameter)
Yes, you can connect multiple Outlook accounts through the Integrations & API Keys page. When building tools or setting up triggers, you can select which account to use from the dropdown menu. This is useful for managing different email addresses or separating personal and business communications.
Set your email-sending tools to "approval mode" in the agent settings. This ensures your agent will always ask for permission before sending an email. You can review the draft, make edits if needed, and then approve or reject the send action.
Yes, if you have the appropriate permissions, your agent can access shared mailboxes. You'll need to use the Microsoft Graph API Call tool step with endpoints like `/users/{userId}/messages` instead of `/me/messages`. Make sure your connected account has delegated access to the shared mailbox.
Pre-built tool steps (like "Send Email" or "Create Event") are designed for specific, common tasks and have simplified interfaces with guided inputs. The Microsoft Outlook API Call tool step gives you full access to Microsoft Graph API, allowing you to implement any functionality available in the API, including advanced operations not covered by pre-built steps.
Yes, Microsoft Graph API enforces rate limits. The specific limits depend on your Microsoft 365 subscription and the type of requests being made. Your agents should be designed to handle rate limiting gracefully. Microsoft typically returns a `429 Too Many Requests` status code when limits are exceeded.
Yes, you can access email attachments using the Microsoft Graph API. Use the endpoint `GET /me/messages/{id}/attachments` to list attachments, and `GET /me/messages/{id}/attachments/{attachmentId}` to download specific attachments. The attachment content is returned as base64-encoded data.
**Note**: When using the Outlook trigger, emails with attachments larger than 25MB will not be processed due to Microsoft Graph API limitations.
To remove the Outlook integration:
1. Open your agent settings
2. Navigate to "Integrations & API Keys"
3. Click the three dots menu next to your connected Outlook trigger
4. Click "Remove"
Once removed, your agent will no longer receive emails or have access to your Outlook data. You can also disconnect the integration entirely from the main Integrations & API Keys page.
Yes! The Outlook integration works with Outlook.com, Office 365, and Microsoft 365 accounts. All these services use the same Microsoft Graph API, so the integration functions identically across all Microsoft email platforms.
# Salesforce
Source: https://relevanceai.com/docs/integrations/popular-integrations/salesforce
Interact with your Salesforce CRM with Relevance.
Salesforce is designed to help businesses manage their sales pipeline, primarily through customer relationship tracking activities. With Relevance AI, your agents can interact with Salesforce much like your human sales team would.
Below, we'll show you how to get started with the Salesforce integration, including how to connect your Salesforce account, how to trigger agentic workflows based on Salesforce events, and how to complete common CRM activities with your agents.
## How to connect your Salesforce account
To add Salesforce as an integration, all you need to do is sign-into your Salesforce account via the integrations page:
1. Go to the "Integrations" page in the sidebar.
2. Click on "Salesforce".
3. Click on the Add Integration button.
4. Sign-in to your Salesforce account.
5. Click "Allow access" to Relevance AI.
## Setup Salesforce as an Agent Trigger
A trigger is an event that triggers your agent to start working. In the case of Salesforce, a trigger might be new leads added to your CRM, demos have been booked, a lead has moved down the sales funnel (e.g. Prospect -> Qualified lead) or other events unique to your sales workflows.
### Add a Salesforce trigger to your agent.
After you have created a new agent, you can add Salesforce as a trigger:
1. Open your agent settings (Agent profile tab).
2. Scroll down to Integrations > Triggers.
3. Click on Salesforce.
4. Select your connected Salesforce account, or sign-in if not already added via the integrations page (previous section).
5. Click "Allow access" to Relevance AI.
6. Write an SOQL query to retrieve the data you want to pull in from your Salesforce account.
Here is an example on an SOQL query that pulls in new leads:
The following SOQL query pulls in Lead objects with the selected properties, where the "Relevance\_Outreached\_\_c" custom object has been set to "true".
```SOQL theme={null}
SELECT Id, Name, Email, Phone, AccountId, Account.Name, Title
FROM Lead
WHERE Relevance_Outreached__c = true
```
Now, any new Leads that are added to the CRM since the last time we checked that meet the query conditions, will be sent to the agent.
Make sure that you are writing [Salesforce Object Query Language (SOQL) queries](https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql.htm), and not SQL queries here. SQL queries that use order-by statements for example, will fail.
7. Advanced option (Optional): Specify a frequency, which is how often you want to fetch data from Salesforce. If you don't specify a frequency, it'll check every 1 minute.
8. Set a Cadence (Optional): Specificy a cadence, which is how often one of the items fetched from Salesforce triggers the agent (if 100 new leads are added, you might not want your agent to outreach to them all the same day, especially if you're in the middle of warming up your inboxes). The rest will wait in a queue.
## Get your agent to complete common Salesforce activities
Once your account is connected, you can use the Salesforce API call step in the Tool builder. This tool step allows you to complete Salesforce-specific activities, like managing Leads, Contacts, Notes, Tasks and more.
### Use Salesforce API tool-step
You can build custom tools that perform Salesforce activities, by using the Salesforce API Call tool-step:
1. Create a new tool.
2. Scroll down to Tool-steps.
3. Add Salesforce API tool-step.
4. Select your connected Salesforce account in the dropdown.
Below are examples of common Salesforce activities your agents can perform.
### Get an existing Contact's details.
### Create a new Lead.
### Create a note (e.g. lead qual research).
### Create a task
### Mark a task as complete
## Troubleshooting
If you encounter an `OAUTH_APPROVAL_ERROR_GENERIC` error when authenticating with Salesforce, this is typically due to Salesforce security updates implemented in September 2024 that require explicit installation of connected apps.
This issue commonly occurs with:
* Sandbox environments created before September 8th, 2024
* New Salesforce instances
* Users without System Administrator permissions
To resolve this issue:
1. **Verify System Administrator access**
* The first user to authenticate must have System Administrator permissions or the "Approve Uninstalled Connected Apps" permission
* Have a System Administrator complete the initial authentication with Relevance AI
2. **For Sandbox environments created before September 8th:**
* Go to **Setup** → **Company Information**
* Click **"Match Production Licenses"** to update the sandbox with the necessary infrastructure
3. **Install the Relevance AI connected app:**
* After a System Administrator successfully authenticates once, go to **Setup**
* In Quick Find, type **"OAuth"**
* Navigate to **Connected Apps OAuth Usage**
* Locate the Relevance AI app in the list
* Click **"Install"** to approve the connected app for your organization
4. **Grant permissions to other users (optional):**
* System Administrators can grant the **"Approve Uninstalled Connected Apps"** permission to other users who need to authenticate
Scratch orgs created before September 8th, 2024 cannot have connected apps added and must be recreated. If issues persist after following these steps, contact Salesforce support for assistance with connected app authentication in your organization.
For more information, see the [Salesforce documentation](https://help.salesforce.com/s/articleView?id=005132365\&type=1).
## Remove Salesforce integration
You can remove Salesforce as a Trigger in your agent settings, by clicking the three dots next to your connected account, and then "Remove".
If you want to remove the Salesforce integration completely, you can:
1. Go to the "Integrations" page from the sidebar
2. Select Salesforce from the list
3. Click "..." on the account you want to remove
4. Click remove
# Slack
Source: https://relevanceai.com/docs/integrations/popular-integrations/slack
Relevance AI's integration for Slack allows you to connect your Relevance AI Agents with Slack, enabling seamless communication between your AI Workforce and your team's Slack workspace.
The Relevance AI team are constantly making improvements to the Slack integrations. If a new Slack feature isn't showing on your account, try to reconnect your Slack integration. To see our changes, sometimes integrations need a reconnect or marketplace re-approval.
To add Slack as an integration, follow these simple steps:
1. Log into Relevance AI: [https://app.relevanceai.com](https://app.relevanceai.com)
2. Go to the **Integrations & API Keys** page in the sidebar of your Relevance AI dashboard.
3. Click on "Slack" from the available integrations.
4. Click on the "Add Integration" button.
5. In the pop-up window, sign into your Slack workspace and authorize Relevance AI to access your Slack account.
6. Select the channels you want to grant access to.
7. Click "Allow" to complete the connection.
This integration for Slack was developed by our team and is not affiliated with Slack. Please contact our Support for any questions/queries you may have.
## Linking your account via magic link
Both the magic link flow and the standard OAuth flow achieve the same outcome — your Slack account is linked to your Relevance AI account.
You may receive a magic link from Slack or via email inviting you to connect your accounts. This is an alternative to the standard OAuth flow above and achieves the same result.
1. Click the magic link in Slack or your email.
2. If you're not logged in to Relevance AI, you'll be redirected to sign in first. After signing in, you'll be returned to the consent page automatically.
3. On the consent page, review your Relevance AI account email and your Slack account details shown.
4. Click **Confirm** to link the accounts, or **Cancel** to abort the connection.
## Understanding Slack connections in Relevance AI
Relevance AI uses two distinct Slack authentication methods depending on which part of the platform you're using. They are independent of each other, and your Slack workspace admin can allow or block each type separately.
Uses a workspace-level bot token through the Relevance AI Slack app. Installed once for the whole workspace, it lets agents post messages, respond to triggers, and send notifications. Requires a Slack workspace admin to approve the Relevance AI app.
Each user connects their own Slack account individually through OAuth, granting Relevance AI access to act on that user's behalf in Slack.
If Slack works in one part of Relevance AI but not another, your workspace admin has likely approved one connection type but not the other. Ask your admin to check permissions for both the Relevance AI Slack app and per-user OAuth app installations.
Both connection types can coexist in the same workspace.
## Triggering Agents or Workforces from Slack
You can trigger your **Agents** or **Workforces** directly from Slack channels or your own DM. This will start your Agent or Workforce in Relevance AI based on a keyword of your choice, and then will reply to your message in Slack.
You can now trigger entire Workforces from Slack, not just individual Agents. This allows you to kick off complex multi-agent workflows directly from your Slack conversations. Learn more about [Workforce Triggers](/docs/build/workforces/build-an-ai-workforce/add-triggers).
### Setting up triggers for channels
To trigger from a **channel**, first **invite Relevance AI to the Slack channel** by typing `/invite @Relevance AI` into the channel.
### Setting up triggers for DMs
To trigger from your **own DM**, open a DM with the Relevance AI bot in Slack and **send it any message**. This establishes the DM connection and makes your DM appear in the channel selection dropdown.
**Channel vs DM setup:**
1. **For channels:** Use `/invite @Relevance AI` in the channel
2. **For your DM:** Send a message to the Relevance AI bot (any message works)
Then, set up your Trigger from Relevance AI by following the steps below:
1. **To trigger your Agent:** enter your Triggers page in your Agent, and create a new Trigger. **To trigger your Workforce:** enter your Workforce page, select a Trigger.
2. Select Slack.
3. Connect or select your Slack account, then click 'Continue'.
4. Select the channel or DM you want your Agent to be triggered on.
5. Enter the keyword you want the Agent to be triggered on - if you want the Agent to be triggered on all messages that tag `@Relevance AI`, leave this blank.
6. Click 'Continue'.
7. Queue work hours if needed.
8. Click 'Setup trigger'.
Once setup, you can trigger your Agent from Slack by tagging `@Relevance AI` and mentioning the keyword you've set (if you set a keyword)! You can also keep the conversation rolling in threads - simply `@Relevance AI` in thread for your agent to respond, with full context of the conversation.
### Advanced Trigger Settings
#### Live Status Updates
When your Agent or Workforce is triggered from Slack, you'll receive live status updates as it progresses through tasks. These updates are automatically enabled and appear directly in the Slack thread, showing you what your Agent is doing in real-time.
#### Exclude Keywords
You can specify keywords that will prevent your Agent from triggering, even when messages mention your trigger keyword or tag `@Relevance AI`.
**To configure:**
1. In your Slack trigger settings, expand **Advanced Settings**
2. Find the **Exclude Keywords** field
3. Enter keywords or phrases (comma-separated)
4. Save your configuration
If a message contains any of your exclude keywords, the Agent will not trigger. Keywords are case-insensitive.
#### No Agent Reply
Enable this setting to have your Agent process Slack messages without posting a response back to the channel. This is useful for background processing, data collection, or triggering workflows that complete elsewhere.
**To enable:**
1. In your Slack trigger settings, expand **Advanced Settings**
2. Toggle on **"No Agent Reply"** or **"Disable Agent responses"**
3. Save your configuration
When "No Agent Reply" is enabled, you won't receive confirmation in Slack that your Agent processed the message. Monitor your Agent's task history in Relevance AI to verify it's working correctly.
### Customize Message Formatting
When using the Send Message (advanced) tool step, you can send messages through Slack with enhanced formatting. This includes:
1. **Emojis:** Add emojis to make your messages more engaging and expressive.
2. **Bolded text:** Use bold formatting to highlight important information.
3. **Images:** Include images to provide visual context or instructions.
## Escalate your Agent to Slack
This feature may be deprecated in the future and an Agent Notification feature will be added instead.
To escalate your agent to Slack, follow these steps:
1. Go to the "Agents" page in the sidebar of your Relevance AI dashboard.
2. Select the agent you want to escalate.
3. Navigate to the Build tab of your agent (top center)
4. Click on "Escalations" in the left sidebar.
## Agent Notifications
This feature is currently in beta for some users
1. Under "Agent Notifications", click "Add agent notification"
2. Configure your notification settings:
* Select "Slack" as the platform
* Choose the specific task statuses you want to trigger the notifications with (e.g., "Running" to trigger whenever the agent runs)
* Select a Slack account that you have previously authed or add a new Slack account
* Select a Slack channel you want to notify with new agent messages
3. Invite the Relevance AI agent to the Slack channel you want to notify by typing "/invite @RelevanceAI" in the channel.
4. Publish changes to your agent by clicking "Publish changes"
5. Run your agent by selecting "Run" at the top of the page.
6. Prompt the agent with some text, e.g. "Give me a summary of what Slack does".
7. You can reply to the agent's notification directly in Slack, or if you'd prefer you can click on "View task" to navigate back to the task in Relevance AI and perform further actions.
Once connected, your integration for Slack will be available for use with your Agents and Tools.
## Making API calls with Slack using Tool steps
You can configure your Slack agent to make API calls to Slack via Relevance AI's tool builder. This allows you to perform actions such as posting Slack messages to channels, or reading messages from channels. These are just a few examples of the many Slack actions available. Your agents can combine these actions with their reasoning capabilities to create sophisticated workflows that enhance team communication and productivity.
Type in "Slack" in the search bar to see all the available Slack actions.
### All Slack Tool steps
You can learn more about each of the Slack Tool steps on the following pages.
## Remove integration for Slack
If you need to remove the integration for Slack:
1. Go to the **Integrations & API Keys** page from the sidebar.
2. Search for Slack from the list.
3. Click "..." on the account you want to remove.
4. Click "Remove" and confirm your choice.
This will disconnect your Slack workspace from Relevance AI, and your agents will no longer be able to interact with Slack until you reconnect the integration for Slack.
## Troubleshooting
Magic links are time-limited and may expire before you click them. If your magic link no longer works, connect your Slack account directly through the standard OAuth flow: go to **Integrations & API Keys** in the sidebar, find Slack, and click **Add Integration**.
The consent page shows two email addresses: your Relevance AI account email and your Slack account email. If either address looks incorrect, click **Cancel** and verify that you're logged in to the correct Relevance AI account before trying again. To switch accounts, sign out of Relevance AI and sign in with the correct account, then click the magic link again.
## Frequently asked questions (FAQs)
Yes! You can use your own Slack DM as a trigger source. Here's how to set it up:
1. Open a DM with the Relevance AI bot in Slack
2. Send the bot any message (this establishes the DM connection)
3. Your DM will then appear in the channel selection dropdown when setting up triggers in Relevance AI
**Note:** For DMs, you don't use the `/invite` command. Simply sending a message to the bot is enough to establish the connection. If your DM doesn't appear in the channel list, make sure you've sent at least one message to the Relevance AI bot first.
To trigger an agent via direct message (DM) in Slack, you must have Editor permissions or higher on that specific agent.
If you want to be able to send a message to a specific person in Slack, that person will first need to send a message to the Relevance AI bot in Slack. Once they do this, their name will appear as a destination option when sending Slack messages.
The most common reason Slack isn't working as expected is that your integration needs to be updated. We occasionally release improvements to our Slack app, and older installations don't pick these up automatically. Updating only takes a moment - go to your project's integrations page, find your Slack connection and click 'Reconnect'.
This usually happens for one of two reasons. First, the email address you use in Slack may not match the email you used when signing up to Relevance - we require these to be the same. Second, the Relevance AI app might not have been invited to the channel yet. To fix this, open the channel and run `/invite @RelevanceAI`, and it should appear.
The easiest and most reliable method is to install Slack directly through Relevance. Start the Slack integration connection flow in Relevance and a request will automatically be sent to your Slack admin for approval. In some cases, admins install the Relevance AI app in Slack before the integration is set up in Relevance, which can create sync issues. Installing via Relevance avoids this.
Yes! Live status updates are automatically enabled for all Slack triggers. You'll see real-time progress updates posted in the Slack thread as your Agent works through its tasks.
Use the **Exclude Keywords** feature in your Slack trigger's advanced settings. Add keywords or phrases that should prevent your Agent from triggering, even if the message mentions your trigger keyword or tags `@Relevance AI`.
Yes! Enable the **"No Agent Reply"** setting in your trigger's advanced settings. This allows your Agent to process messages without posting a response back to Slack.
Agent triggers start a single AI Agent, while Workforce triggers kick off an entire multi-agent workflow with multiple Agents working together. Use Workforce triggers for complex, multi-step processes that require different specialized Agents to collaborate.
A magic link is an alternative way to connect your Slack account to Relevance AI. When you click the link, you're taken to a consent page in Relevance AI that shows your Relevance AI account email and your Slack account details. Click **Confirm** to complete the connection or **Cancel** to abort it. The magic link method achieves the same result as connecting via the standard OAuth flow on the Integrations page.
Both methods work and achieve the same result. You can connect your Slack account through the standard OAuth flow on the **Integrations & API Keys** page, or by clicking a magic link you received from Slack or via email. Use whichever is more convenient.
If you're not logged in to Relevance AI when you click the magic link, you'll be redirected to the sign-in page. After signing in, you'll be automatically returned to the consent page to complete the account linking.
Relevance AI uses two different Slack authentication methods. Builder features (Agents, Tools, Triggers, Workforces) use a workspace-level bot token through the Relevance AI Slack app, which requires a workspace admin to approve the app installation. The other method uses per-user OAuth, where each user connects their own Slack account individually.
If Slack works in one area but not the other, your workspace admin has likely approved one connection type without the other. Ask your admin to check the app permission settings for both the Relevance AI Slack app and per-user OAuth app installations. Both connection types can coexist once both are approved.
## Disclaimer
Relevance AI enables users to access verified and genuine generative models from secure and trusted vendors. However, generative AI technologies still leave the potential for hallucinations leading to potentially inaccurate responses. Please review and verify the agent's output and use a combination of deterministic and agentic behaviour to achieve the most reliable results.
## Privacy Policy
To find out more about how Relevance AI handles your data, please see our [Privacy Policy](https://relevanceai.com/privacy-policy).
## Follow along on YouTube
# Telegram
Source: https://relevanceai.com/docs/integrations/popular-integrations/telegram
Interact with your Telegram account with Relevance.
# Telegram Integration
Connect your AI agents with Telegram to automate conversations and workflows directly through the popular messaging platform. The Telegram integration allows your agents to receive messages, respond intelligently, and execute actions based on user interactions.
## How the Telegram Integration Works
The Relevance AI Telegram integration connects your **personal Telegram account** (or a dedicated Telegram account you create). When you set up this integration:
* Your AI agent sends and receives messages **as that Telegram account**
* You authenticate using Telegram's standard login process
* The agent can interact with your contacts, groups, and channels
## Connect the integration
Setting up the Telegram integration with Relevance AI is straightforward:
1. Go to the "Integrations & API Keys" page in the sidebar of your Relevance AI dashboard
2. Click on "Telegram" from the available integrations
3. Click the "Add Integration" button
4. You'll be prompted to authenticate with your Telegram account
5. Follow the on-screen instructions to authorize the connection
6. Once connected, you'll see your Telegram account listed under connected accounts
## Setting up triggers
The Telegram integration can be configured as a trigger for your AI agents, allowing them to automatically respond when messages are received.
The Telegram Trigger is a Premium trigger, available on the Pro plan and above.
### Create a Telegram trigger
1. Navigate to your agent's profile page and "Triggers"
2. Choose "Telegram" from the list of available triggers
3. Select your connected Telegram account
4. Configure the trigger settings:
* **Chat Type**: Choose between private chats, group chats, or both
* **Message Filter**: Optionally set up filters to only trigger on specific message types or content
* **Response Mode**: Select whether your agent should respond automatically or require approval
### Common trigger use cases
* **Customer Support**: Automatically respond to customer inquiries received via Telegram
* **Lead Qualification**: Trigger an agent to qualify leads that reach out through Telegram
* **Information Requests**: Set up an agent to provide information when users ask specific questions
* **Appointment Scheduling**: Allow users to schedule appointments through Telegram conversations
* **Order Processing**: Process orders and transactions initiated through Telegram messages
## Tools & Tool Steps
The Telegram integration provides several powerful actions that your agents can use as part of their workflows. These actions enable your agents to interact with Telegram in various ways.
### Available Telegram actions
* **Send Message**: Send a text message to a specific chat or user
* **Send Photo**: Share images with optional captions
* **Send Document**: Share files and documents of various formats
* **Send Location**: Share geographical locations
* **Create Poll**: Create and send polls to gather feedback
* **Get Chat Information**: Retrieve details about a specific chat
* **Get User Profile**: Retrieve information about a Telegram user
* **Pin Message**: Pin important messages in a chat
* **Delete Message**: Remove messages from a conversation
* **Forward Message**: Forward messages between chats
* **Create Chat Invite Link**: Generate invitation links for groups or channels
These are just some of the many actions available. The Telegram integration offers a comprehensive set of tools that allow your agents to leverage the full functionality of the Telegram platform.
### Example workflow
Here's an example of how you might use Telegram actions in a customer support workflow:
1. **Trigger**: Agent is triggered by an incoming Telegram message
2. **Analysis**: Agent analyzes the message content to determine the customer's intent
3. **Response**: Agent uses the "Send Message" action to respond with an appropriate greeting
4. **Information Gathering**: If additional information is needed, agent asks follow-up questions
5. **Resolution**: Once the issue is understood, agent provides a solution
6. **Documentation**: Agent uses "Send Document" action to share relevant documentation if needed
7. **Follow-up**: Agent schedules a follow-up message for later if the issue requires monitoring
## Use the integration's API tool step (advanced)
In addition to the pre-built actions, advanced users can access additional Telegram functionality through the Telegram API tool step:
1. Create a new tool
2. Scroll down to Tool-steps
3. Add Telegram API tool-step
4. Select your connected Telegram account in the dropdown
5. Configure the API endpoint and parameters according to your needs
**Note**: This tool step uses your connected personal Telegram account's authentication. While it provides access to Telegram's API methods, it operates within the context of your authenticated account, not as a BotFather bot. The available methods depend on what Telegram allows for user accounts versus bots.
For full Telegram Bot API functionality with a BotFather bot, use the [API tool step](https://relevanceai.com/docs/tool/tool-steps/api) with your bot token instead.
### Example API usage
```json theme={null}
{
"method": "sendMessage",
"chat_id": "{{chatId}}",
"text": "This is a custom formatted message with *bold* and _italic_ text",
"parse_mode": "Markdown"
}
```
## Frequently asked questions (FAQs)
Yes, you can connect multiple Telegram accounts to Relevance AI.
Yes, the integration works with both personal accounts and business accounts on Telegram.
Yes, your agent can be configured to respond to messages in private chats, groups, or both, depending on your trigger settings.
Message processing is counted against your overall credit usage. The specific limits depend on your subscription plan.
Yes, you can customize the name and profile picture of your Telegram bot that represents your agent in conversations.
No, the native Telegram integration does not support BotFather bot tokens. This integration connects your personal Telegram account (or a dedicated account), and your agent operates as that account. If you want to use BotFather, you should build a custom Agent with a webhook trigger and custom API calls.
# Trello
Source: https://relevanceai.com/docs/integrations/popular-integrations/trello
Enhance your day-to-day team and personal coordination with the Trello integration for Relevance AI.
Trello is a flexible personal productivity and work management tool that helps individuals and teams visually organize tasks, ideas, and workflows using boards, lists, and cards. It's designed to adapt to a wide range of use cases — from planning daily to-dos and tracking habits to managing team coordination or creative pipelines. With its drag-and-drop interface, customizable labels, and integrations with tools like Slack, Google Drive, and now Relevance AI, Trello makes it easy to stay on top of work, whether you're managing solo projects or collaborating asynchronously.
The Trello integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not Atlassian (Trello's parent company). If you have a question / issue with using Trello in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question / issue that is only about Trello, you can [reach out to Atlassian support](https://support.atlassian.com/contact/).
## Connect the integration
Setting up the Trello integration with Relevance AI is straightforward:
1. Navigate to the Integrations & App Keys section in your Relevance AI dashboard
2. Find and select "Trello" from the available integrations
3. Click "Connect"
4. You'll be redirected to Trello to authorize the connection
5. Log in to your Trello account (or create one if needed)
6. Review and approve the permissions requested
7. Once authorized, you'll be redirected back to Relevance AI with the integration active
After connecting, your Relevance AI agents will be able to interact with your Trello account, accessing boards, creating cards, and managing your Trello workflows.
## Trello API authentication
In addition to OAuth authentication, you can use Trello's native API key and token authentication method. This approach is useful for server-to-server integrations, automation scripts, or when you need more granular control over API access.
### When to use API key + token authentication
* **OAuth (recommended for most users)**: Best for user-facing integrations where you want users to authorize access through Trello's interface
* **API key + token**: Ideal for backend automation, service accounts, or when you need persistent access without user interaction
### Getting your API key
Navigate to [https://trello.com/power-ups/admin](https://trello.com/power-ups/admin) while logged into your Trello account.
If you haven't created a Power-Up before, click "New" to create one. You'll need to provide a name for your integration (e.g., "Relevance AI Integration").
Once created, you'll see your API key displayed. Copy this key and store it securely.
### Generating a token
After obtaining your API key, you need to generate a token:
Visit the following URL in your browser, replacing `YOUR_API_KEY` with your actual API key:
```
https://trello.com/1/authorize?expiration=never&name=RelevanceAI&scope=read,write&response_type=token&key=YOUR_API_KEY
```
You'll be prompted to authorize the token. Review the permissions and click "Allow" to generate your token.
After authorization, Trello will display your token. Copy and store it securely alongside your API key.
### Using API credentials in Relevance AI
When configuring Trello tool steps in Relevance AI, you can provide your API key and token directly in the tool configuration. This allows your agents to authenticate with Trello without requiring OAuth authorization.
Store your API key and token securely. Never commit them to version control or share them publicly. Treat them like passwords.
For more details on Trello's API authentication, see the [official Trello API documentation](https://developer.atlassian.com/cloud/trello/guides/rest-api/api-introduction/).
## Available triggers
The Trello integration allows you to set up triggers that automatically activate your AI agents when specific events occur in your Trello boards. Most Trello triggers are **instant** (webhook-based), meaning your agents respond in real-time as soon as changes happen — whether it's a new card being created, a comment being added, or a card moving between lists. This enables powerful automation workflows that keep your team productive without manual intervention.
The following trigger options are available, organized by category:
Monitor card lifecycle events to automate workflows around task management.
* **New Card (Instant)** — Triggers immediately when a new card is created on a board. Perfect for automatically assigning tasks, sending notifications, or initiating approval workflows.
* **Card Updated (Instant)** — Triggers whenever any changes are made to a card (title, description, due date, etc.). Useful for tracking modifications and keeping external systems synchronized.
* **Card Moved (Instant)** — Triggers when a card is moved to a different list. Ideal for stage-based workflows like moving from "In Progress" to "Review" or "Done."
* **Card Archived (Instant)** — Triggers when a card is archived. Use this to log completed work, update external databases, or trigger cleanup processes.
* **Card Due Date Reminder** — Triggers at a specified time before a card's due date. Configure how far in advance you want to be notified (e.g., 1 day, 1 hour before due).
Stay informed about team discussions and collaboration activities.
* **New Comment Added to Card (Instant)** — Triggers immediately when someone adds a comment to any card. Great for monitoring discussions, extracting action items, or routing questions to the right team members.
* **New Member on Card (Instant)** — Triggers when a team member is added to a card. Use this to send welcome messages, provide context, or update assignment tracking systems.
Automate workflows based on card categorization and organization.
* **New Label Created (Instant)** — Triggers when a new label is created on a board. Useful for maintaining label consistency across multiple boards or updating documentation.
* **New Label Added To Card (Instant)** — Triggers when a label is applied to a card. Perfect for routing cards to specific workflows based on priority, category, or department labels.
Monitor task breakdown and subtask management.
* **New Checklist (Instant)** — Triggers when a new checklist is added to any card on a board. Use this to track task decomposition or ensure proper subtask templates are being used.
Track high-level board changes and comprehensive activity monitoring.
* **New Board (Instant)** — Triggers when a new board is created in your Trello workspace. Ideal for setting up board templates, applying default settings, or notifying administrators.
* **New Board Activity (Instant)** — Triggers for any activity on a board with extensive filtering options. This is the most flexible trigger, allowing you to monitor multiple activity types simultaneously (card creation, updates, comments, member changes, etc.).
* **New Notification** — Triggers when you receive a new Trello notification. Use this to centralize all your Trello alerts or create custom notification routing.
Monitor file and document additions to cards.
* **New Attachment (Instant)** — Triggers when a file or link is attached to any card on a board. Perfect for processing uploaded documents, backing up files, or extracting information from attachments.
Highly customizable triggers for complex automation scenarios.
* **Custom Webhook Events (Instant)** — The most powerful trigger option, allowing you to create highly specific conditions by combining multiple filters:
* Filter by specific boards
* Filter by event types (create, update, delete, etc.)
* Filter by specific lists
* Filter by specific cards
* Combine multiple conditions for precise control
This trigger is ideal when you need granular control over exactly which events should activate your agent.
## Practical use cases
Here are some powerful ways to use Trello triggers with Relevance AI:
When a new card is created in your "Incoming Requests" list, automatically analyze the card content and assign it to the appropriate team member based on keywords or workload.
When a card moves to your "Completed" list, automatically send a summary email to stakeholders and update your project management dashboard.
When a new comment is added, use AI to detect questions, action items, or escalations, then route them appropriately or create follow-up tasks.
Set up reminders that trigger 24 hours before a card is due, sending personalized notifications and checking if all checklist items are complete.
When a "Priority" or "Urgent" label is added to a card, automatically notify relevant team members and escalate to management if needed.
When an attachment is added to a card, automatically extract key information, generate summaries, or validate document completeness.
**Pro tip:** Combine multiple Trello triggers with different agents to create sophisticated workflows. For example, use one agent to process new cards and another to handle comments, creating a complete automation ecosystem for your Trello boards.
## Tool steps for Trello
The Trello integration provides a comprehensive set of actions that your agents can use to interact with your boards and workflows. These actions can be incorporated into your agent's workflows as tool steps, enabling automation capabilities.
### Card Management
Create a new card on a Trello board
Update an existing card's properties
Retrieve details about a specific card
Archive a card from a board
### Board & List Operations
List all boards accessible to your account
Retrieve all cards from a specific list
Create a new list on a board
### Comments & Collaboration
Post a comment on a card
Add a comment to a card (legacy action)
### Checklist Management
Add a checklist to a card
Add an item to an existing checklist
### Advanced Operations
Make custom API calls to any Trello endpoint
Type "Trello" in the tool step search bar to see all available Trello actions when building your tools.
## Use the integration's API tool step (advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform Trello-specific activities using the Trello API Call tool step.
### How to use the Trello API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add Trello functionality to.
1. Scroll down to Tool steps
2. Search for "Trello API Call" in the tool step search bar
3. Add the Trello API Call tool step to your workflow
Choose between OAuth (connected account) or API key + token authentication.
Configure the API endpoint, method, and parameters:
* **Method**: Select the HTTP method (GET, POST, PUT, DELETE)
* **Endpoint**: Enter the API endpoint path (e.g., `/1/boards/{id}/cards`)
* **Body**: Add any required request body data
* **Query Parameters**: Add URL parameters as needed
Test your configuration to ensure it works correctly before deploying.
### Example: Creating a card with custom fields
Here's a practical example of using the Trello API Call tool step to create a card with specific properties:
**API Endpoint**: `POST /1/cards`
**Configuration**:
```json theme={null}
{
"method": "POST",
"endpoint": "/1/cards",
"body": {
"idList": "5f8a1b2c3d4e5f6g7h8i9j0k",
"name": "New Task from Agent",
"desc": "This card was created automatically by Relevance AI",
"pos": "top",
"due": "2024-12-31",
"idLabels": ["5f8a1b2c3d4e5f6g7h8i9j0k"]
}
}
```
This configuration:
* Uses the POST method to create a new card
* Specifies the list ID where the card should be created
* Sets the card name and description
* Positions the card at the top of the list
* Adds a due date
* Applies labels to the card
### Common Trello API endpoints
Here are some commonly used Trello API endpoints you can use with the API Call tool step:
* **Get card**: `GET /1/cards/{id}`
* **Create card**: `POST /1/cards`
* **Update card**: `PUT /1/cards/{id}`
* **Delete card**: `DELETE /1/cards/{id}`
* **Add comment**: `POST /1/cards/{id}/actions/comments`
[View API Documentation](https://developer.atlassian.com/cloud/trello/rest/api-group-cards/)
* **Get board**: `GET /1/boards/{id}`
* **Get board lists**: `GET /1/boards/{id}/lists`
* **Get board cards**: `GET /1/boards/{id}/cards`
* **Create board**: `POST /1/boards`
[View API Documentation](https://developer.atlassian.com/cloud/trello/rest/api-group-boards/)
* **Get list**: `GET /1/lists/{id}`
* **Create list**: `POST /1/lists`
* **Update list**: `PUT /1/lists/{id}`
* **Get list cards**: `GET /1/lists/{id}/cards`
[View API Documentation](https://developer.atlassian.com/cloud/trello/rest/api-group-lists/)
* **Get checklist**: `GET /1/checklists/{id}`
* **Create checklist**: `POST /1/checklists`
* **Add checklist item**: `POST /1/checklists/{id}/checkItems`
* **Update checklist item**: `PUT /1/cards/{id}/checkItem/{idCheckItem}`
[View API Documentation](https://developer.atlassian.com/cloud/trello/rest/api-group-checklists/)
* **Get label**: `GET /1/labels/{id}`
* **Create label**: `POST /1/labels`
* **Add label to card**: `POST /1/cards/{id}/idLabels`
* **Remove label from card**: `DELETE /1/cards/{id}/idLabels/{idLabel}`
[View API Documentation](https://developer.atlassian.com/cloud/trello/rest/api-group-labels/)
You can find Trello's complete API documentation at [https://developer.atlassian.com/cloud/trello/rest/](https://developer.atlassian.com/cloud/trello/rest/).
## Frequently asked questions (FAQs)
The integration requires read and write access to your Trello boards, lists, and cards. When you connect your Trello account, you'll be asked to authorize Relevance AI to access your Trello data. You can review the specific permissions during the OAuth authorization process.
**OAuth** is recommended for most users as it's simpler to set up and provides user-level permissions. Use **API key + token** when you need:
* Server-to-server integrations
* Persistent access without user interaction
* Service account functionality
* More granular control over API access
Yes, when configuring triggers, you can specify which boards to monitor. For tool steps, you control which boards your agent interacts with through the board ID parameters in your workflows. Your agent will only access the boards you explicitly configure.
If your trigger isn't activating, check the following:
1. Verify your Trello integration is still connected (re-authenticate if needed)
2. Confirm the trigger is configured for the correct board
3. Check that the specific event type matches your trigger (e.g., "Card Moved" vs "Card Updated")
4. For non-instant triggers, ensure the polling frequency has elapsed
If issues persist, try disconnecting and reconnecting your Trello integration.
**Card Updated** triggers whenever any property of a card changes (title, description, due date, attachments, etc.), including when a card moves. **Card Moved** is more specific and only triggers when a card moves from one list to another. Use Card Moved for stage-based workflows; use Card Updated for comprehensive change monitoring.
Yes, you can connect multiple Trello accounts by adding separate integrations for each account. Each integration will appear with its account name in your integrations list, and you can select the appropriate account when configuring triggers or tool steps.
Yes, Trello enforces API rate limits (typically 100 requests per 10 seconds per token). Relevance AI manages these limits automatically for pre-built tool steps. If you're using the API Call tool step for high-volume operations, be mindful of rate limiting and implement appropriate delays in your workflows.
The easiest way to find IDs is to open the board, list, or card in Trello and add `.json` to the end of the URL. For example, `https://trello.com/b/abc123/board-name.json` will show the board's data including its ID. Alternatively, use the Trello API to list your boards and retrieve IDs programmatically.
Absolutely! You can configure triggers to monitor one board and use tool steps to create or update cards on different boards. This enables powerful cross-board automation, such as syncing tasks between team boards or escalating items to management boards.
# Twilio
Source: https://relevanceai.com/docs/integrations/popular-integrations/twilio
Connect Twilio to send SMS, make voice calls, and automate communications with AI agents
Twilio is a cloud communications platform that provides APIs for SMS, voice calls, video, and other messaging channels. With the Twilio integration in Relevance AI, your agents can send text messages, make and manage phone calls, look up phone numbers, handle media, and run SMS verification flows.
This integration is built by Relevance AI. For integration-specific support, contact [Relevance AI support](https://relevanceai.com/docs/get-started/support). For Twilio platform issues, visit [Twilio Support](https://help.twilio.com/).
## Connect the integration
You authenticate with your Twilio Account SID and Auth Token. Both are available in the **Account Info** panel on your [Twilio Console](https://console.twilio.com/) dashboard.
Go to the **Integrations & API Keys** page in your Relevance AI dashboard.
Find and click on **Twilio** from the list of available integrations.
Click the **Add Integration** button to begin the connection process.
Paste your Twilio **Account SID**. In the Twilio Console, this is shown under **Account Info** on the main dashboard (format: `ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`).
Paste your Twilio **Auth Token**. This is shown directly below the Account SID in the **Account Info** panel. Click the eye icon in the Twilio Console to reveal it.
Click **Connect**. Once authenticated, your Twilio account will appear as connected in your integrations list.
If you manage multiple Twilio projects, you can connect each project separately using its own Account SID and Auth Token. Each connection appears as a distinct entry in your integrations list.
## Setting up triggers
Twilio does not currently support event-based triggers in Relevance AI. To react to inbound SMS or calls, set up a [webhook trigger](/docs/build/agents/build-your-agent/triggers) on your agent and configure your Twilio phone number's webhook URL to point to it.
## Tools & tool steps
The Twilio integration provides 17 operations across seven categories. To find them in the tool step search, type "Twilio" in the search bar.
### SMS operations
Send an SMS message from a Twilio phone number to any destination number. Specify the `from` number (must be a Twilio number on your account), the `to` number, and the message body. Supports plain text up to 1,600 characters; longer messages are split automatically.
Send an MMS message with one or more media attachments. Provide the `from` and `to` numbers, an optional text body, and one or more publicly accessible media URLs. Supported formats include JPEG, PNG, GIF, and MP4.
Schedule an SMS to be sent at a future date and time. Specify the message content, the send time in ISO 8601 format, and the messaging service SID to use. Scheduling requires a Twilio Messaging Service with scheduling enabled.
Cancel a previously scheduled SMS before it is sent. Provide the message SID of the scheduled message. The message must still be in `scheduled` status — messages already sent cannot be recalled.
### Voice call operations
Initiate an outbound phone call from a Twilio number. Provide the `from` and `to` numbers and a TwiML URL or TwiML string that defines how the call behaves (e.g., playing a message, collecting input, or connecting to another number).
Make a voice call and read out a text message using Twilio's text-to-speech engine. Specify the `from` and `to` numbers, the text to speak, and optionally the language and voice. No TwiML knowledge required — the integration handles the TwiML generation.
End an in-progress call by updating its status to `completed`. Provide the call SID. Useful for programmatically terminating calls from within an agent workflow.
### Call & message management
Retrieve a list of calls from your Twilio account. Filter by `from` number, `to` number, status, or date range. Returns call metadata including SID, direction, duration, status, and timestamps.
Fetch details about a specific call using its call SID. Returns the call's status, direction, duration, from/to numbers, price, and any associated recordings.
Retrieve a list of messages from your Twilio account. Filter by `from` number, `to` number, date sent, or message status. Returns message metadata including SID, body, direction, status, and timestamps.
Fetch details about a specific message using its message SID. Returns the full message body, status, direction, error codes (if any), and pricing information.
### Phone number lookup
Look up carrier and line-type information for any phone number. Returns whether the number is mobile, landline, or VoIP, along with the carrier name and country. Useful for validating numbers before sending SMS or making calls. This operation uses Twilio Lookup and may incur additional Twilio charges.
Search for available Twilio phone numbers to purchase in a given country or area code. Filter by capabilities (SMS, voice, MMS), area code, or locality. Returns a list of available numbers with their capabilities and monthly costs.
### Transcription services
Submit a Twilio call recording for transcription. Provide the recording SID. Twilio processes the audio and returns the transcription text once complete. Transcription is an asynchronous operation — poll the Get Transcription step or use a webhook to retrieve the result.
Retrieve the text and metadata for a completed transcription using its transcription SID. Returns the transcription body, status, duration, and the associated recording SID.
### SMS verification
Send a one-time passcode (OTP) to a phone number via SMS or voice call using Twilio Verify. Provide the destination number and the channel (`sms` or `call`). Requires a Twilio Verify Service SID configured in your Twilio account.
Verify a code entered by the user against the OTP sent by Twilio Verify. Provide the phone number, the code, and the Verify Service SID. Returns `approved` if the code matches and is still within its validity window.
### Media handling
List all media attachments associated with a specific MMS message. Provide the message SID. Returns media SIDs, content types, and URLs for each attachment.
Delete a media attachment from your Twilio account using its media SID and parent message SID. Deleted media is no longer accessible via its Twilio URL. This action is permanent.
## Use the integration's API tool step (advanced)
For operations not covered by the pre-built tool steps, use the **Twilio API Call** tool step to make raw requests to any Twilio REST API endpoint.
In your agent or tool builder, add the **Twilio API Call** tool step.
Choose the appropriate HTTP method — most Twilio write operations use `POST`, and reads use `GET`.
Provide the API path relative to `https://api.twilio.com/2010-04-01/Accounts/{AccountSid}/`, for example `/Messages.json` or `/Calls/{CallSid}.json`.
Provide the request body as form-encoded key-value pairs (Twilio's REST API uses `application/x-www-form-urlencoded`, not JSON).
Run the tool step to confirm it returns the expected response before using it in a live workflow.
### Example: sending an SMS via API tool step
```json theme={null}
{
"method": "POST",
"endpoint": "/Messages.json",
"body": {
"From": "+15551234567",
"To": "+15559876543",
"Body": "Your appointment is confirmed for tomorrow at 10am."
}
}
```
For the full endpoint reference, see the [Twilio REST API documentation](https://www.twilio.com/docs/usage/api).
## Example use cases
Send automated SMS reminders to customers before scheduled appointments. Reduce no-shows by triggering reminder messages 24 hours and 1 hour before the appointment time.
Add SMS-based two-factor authentication to your workflows using Twilio Verify. Send a one-time code and verify it before granting access or confirming high-value actions.
Automatically respond to inbound SMS inquiries using an AI agent. Route complex issues to human agents while resolving common questions instantly.
Trigger outbound voice calls for order confirmations, collections follow-ups, or survey outreach. Use text-to-speech to deliver dynamic messages without pre-recording audio.
Qualify inbound leads via SMS conversation. An agent can ask qualifying questions, score responses, and pass qualified leads to your CRM automatically.
Send real-time SMS notifications for shipment status updates, delivery confirmations, or exception alerts — triggered automatically as order status changes in your systems.
## Frequently asked questions (FAQs)
Both are displayed in the **Account Info** panel on your Twilio Console dashboard at console.twilio.com. Click the eye icon next to the Auth Token to reveal it. Keep your Auth Token secret — anyone with it can make API calls on your behalf.
For sending SMS or making outbound calls, yes — you need at least one Twilio phone number on your account. You can purchase numbers in the Twilio Console under **Phone Numbers** > **Manage** > **Buy a number**. For Twilio Verify (SMS verification), you need a Verify Service instead of a regular phone number.
Yes. Each Twilio project has its own Account SID and Auth Token. Add a separate integration for each project, and each will appear as a distinct connected account in your integrations list.
Common causes include: the destination number is a landline (not SMS-capable), the `from` number does not have SMS capability enabled, your Twilio account balance is insufficient, or the message was filtered as spam. Check the message status and error code using the Get Message tool step, then refer to the [Twilio error code reference](https://www.twilio.com/docs/api/errors) for resolution steps.
Twilio enforces rate limits per account and per phone number. The limits vary by Twilio account type and the specific API. If your workflow sends a high volume of messages, consider using a Twilio Messaging Service to distribute load across multiple numbers. Consult [Twilio's rate limit documentation](https://www.twilio.com/docs/usage/api/rate-limits) for specifics.
Inbound messages and calls are handled via webhooks. Configure your Twilio phone number's inbound webhook URL to point to a [webhook trigger](/docs/build/agents/build-your-agent/triggers) on your Relevance AI agent. Your agent will then be activated each time a message or call arrives.
First, create a Verify Service in your Twilio Console under **Verify** > **Services**. Note the Service SID. Then use the **Send verification code** tool step with your Verify Service SID to send an OTP, and the **Check verification code** tool step to validate what the user enters.
***
Contact our support team for assistance with the Twilio integration.
Discover other integrations to enhance your workflows.
# Vercel
Source: https://relevanceai.com/docs/integrations/popular-integrations/vercel
Vercel is the platform for frontend developers, providing the speed and reliability innovators need to create at the moment of inspiration.
Vercel is the platform for frontend developers, providing the speed and reliability innovators need to create at the moment of inspiration. With Relevance AI's Vercel integration, you can seamlessly connect your Vercel projects to your AI agents, enabling them to manage deployments, monitor project status, and automate your development workflows, making your deployment processes more efficient and intelligent.
The Vercel integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not Vercel. If you have a question or issue with using Vercel in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about Vercel, you can [reach out to Vercel support](https://vercel.com/support).
## Connect the integration
Connecting your Vercel account to Relevance AI is a straightforward process:
1. Go to the "Integrations" page in the sidebar of your Relevance AI dashboard.
2. Click on "Vercel" from the available integrations.
3. Click on the "Add Integration" button.
4. In the pop-up window, sign into your Vercel account.
5. Grant the necessary permissions for Relevance AI to access your Vercel projects and deployments.
6. Once authenticated, your Vercel account will appear as a connected integration.
## Tool steps for Vercel
The Vercel integration provides a comprehensive set of actions that your agents can use to interact with your deployments and development workflows. These actions can be incorporated into your agent's workflows as tool steps, enabling sophisticated deployment automation capabilities.
### Deployment Management
Create a new deployment for a Vercel project with custom configurations
Retrieve a list of deployments with filtering options
Cancel an ongoing or queued deployment
### Advanced Operations
Make authorized requests to any Vercel API endpoint
Type "Vercel" in the tool step search bar to see all available Vercel actions when building your tools.
## Use the integration's API tool step (Advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform Vercel-specific activities using the Vercel API Call tool step.
### How to use the Vercel API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add Vercel functionality to.
1. Scroll down to Tool-steps
2. Search for "Vercel API Call" in the tool step search bar
3. Add the Vercel API Call tool step to your workflow
Select your connected Vercel account from the dropdown menu.
Configure the API endpoint, method, and parameters according to your needs:
* **Method**: Select the HTTP method (GET, POST, PUT, DELETE, PATCH)
* **Path**: Enter the API endpoint path (e.g., `/v13/deployments`)
* **Body**: Add any required request body data
* **Headers**: Add any custom headers if needed
Test your configuration to ensure it works correctly before deploying.
### Example: Getting Deployment Details
Here's a practical example of using the Vercel API Call tool step to retrieve details about a specific deployment:
**API Endpoint**: `GET /v13/deployments/{id}`
**Configuration**:
```json theme={null}
{
"method": "GET",
"path": "/v13/deployments/dpl_ABC123xyz",
"headers": {}
}
```
This configuration:
* Uses the GET method to retrieve deployment information
* Specifies the deployment ID in the path
* Returns comprehensive details about the deployment including status, creator, and metadata
You can find Vercel's complete API documentation at [https://vercel.com/docs/rest-api](https://vercel.com/docs/rest-api).
### Common Vercel API Endpoints
Here are some commonly used Vercel API endpoints you can use with the API Call tool step:
* **List deployments**: `GET /v6/deployments`
* **Get deployment**: `GET /v13/deployments/{id}`
* **Create deployment**: `POST /v13/deployments`
* **Cancel deployment**: `PATCH /v12/deployments/{id}/cancel`
* **Delete deployment**: `DELETE /v13/deployments/{id}`
[View API Documentation](https://vercel.com/docs/rest-api/endpoints/deployments)
* **List projects**: `GET /v9/projects`
* **Get project**: `GET /v9/projects/{id}`
* **Create project**: `POST /v10/projects`
* **Update project**: `PATCH /v9/projects/{id}`
* **Delete project**: `DELETE /v9/projects/{id}`
[View API Documentation](https://vercel.com/docs/rest-api/endpoints/projects)
* **List domains**: `GET /v5/domains`
* **Get domain**: `GET /v5/domains/{domain}`
* **Add domain**: `POST /v10/projects/{id}/domains`
* **Remove domain**: `DELETE /v9/projects/{id}/domains/{domain}`
[View API Documentation](https://vercel.com/docs/rest-api/endpoints/domains)
* **List env variables**: `GET /v9/projects/{id}/env`
* **Create env variable**: `POST /v10/projects/{id}/env`
* **Update env variable**: `PATCH /v9/projects/{id}/env/{id}`
* **Delete env variable**: `DELETE /v9/projects/{id}/env/{id}`
[View API Documentation](https://vercel.com/docs/rest-api/endpoints/projects#environment-variables)
* **List teams**: `GET /v2/teams`
* **Get team**: `GET /v2/teams/{id}`
* **List team members**: `GET /v2/teams/{id}/members`
[View API Documentation](https://vercel.com/docs/rest-api/endpoints/teams)
## Example use cases
Here are some ways you can leverage the Vercel integration with your agents:
Create an agent that automatically triggers deployments when specific conditions are met, such as successful test runs, code reviews, or scheduled times. The agent can monitor your repository, validate changes, and deploy to the appropriate environment (production, staging, or preview) based on your workflow rules.
Build an agent that manages deployments across multiple environments simultaneously. The agent can coordinate staging deployments for testing, automatically promote successful builds to production, and maintain environment-specific configurations and variables.
Deploy an agent that continuously monitors deployment status, tracks build times, and alerts your team when deployments fail or take longer than expected. The agent can provide detailed reports on deployment health and performance metrics.
Create an agent that automatically detects deployment issues through error monitoring or performance degradation and initiates rollbacks to the last stable version. The agent can analyze logs, monitor error rates, and make intelligent decisions about when to rollback.
Build an agent that analyzes traffic patterns and schedules deployments during low-traffic periods to minimize user impact. The agent can optimize deployment timing based on historical data and current system load.
Deploy an agent that bridges your CI/CD pipeline with Vercel deployments, automatically triggering builds when tests pass, managing preview deployments for pull requests, and coordinating multi-stage deployment workflows.
Create an agent that sends customized notifications to different stakeholders (developers, QA, product managers) about deployment events. The agent can provide context-aware updates via Slack, email, or other channels based on deployment status and team preferences.
Build an agent that automatically creates and manages preview deployments for feature branches, assigns unique URLs, notifies reviewers, and cleans up old preview deployments to optimize resource usage.
## Frequently asked questions (FAQs)
The integration requires permissions to manage deployments, access project information, and read deployment logs. You can review the specific permissions during the authentication process. Vercel uses OAuth for secure authentication, ensuring your credentials are never stored directly.
Yes, you can configure your tools and triggers to only interact with specific projects by setting the appropriate project parameters. Additionally, you can use Vercel's team-based access controls to limit which projects are accessible through the integration.
When you connect your Vercel account through the Integrations page, Relevance AI handles authentication automatically using OAuth. When using the Vercel API Call tool step, simply select your connected Vercel account from the dropdown, and authentication will be handled for you.
Pre-built tool steps (like "Create Deployment" or "List Deployments") are designed for specific, common tasks and have simplified interfaces with guided inputs. The Vercel API Call tool step gives you full access to Vercel's REST API, allowing you to implement any functionality available in the API, including advanced or custom operations not covered by pre-built steps.
Yes! You can set up Vercel webhooks to trigger your agents when specific events occur in your projects (like deployment started, deployment completed, or deployment failed). Configure webhooks in your Vercel project settings to point to your agent's webhook URL in Relevance AI.
Yes, Vercel enforces rate limits on API calls. The specific limits depend on your Vercel plan. Your agents should be designed to handle rate limiting gracefully. You can check your current rate limit status in the API response headers.
Yes! You can use the Vercel API Call tool step to create, update, and delete environment variables for your projects. This allows your agents to dynamically manage configuration across different environments.
Use the "Cancel Deployment" tool step or the Vercel API Call with the `PATCH /v12/deployments/{id}/cancel` endpoint. You'll need the deployment ID, which you can obtain from the "List Deployments" tool step or from deployment creation responses.
Yes! When creating a deployment, you can specify the branch, environment (production, preview, or development), and other configuration options. This allows your agents to manage multi-environment deployment strategies effectively.
# WhatsApp
Source: https://relevanceai.com/docs/integrations/popular-integrations/whatsapp
Connect your WhatsApp account to Relevance AI and enable your agents to communicate directly with customers through one of the world's most popular messaging platforms.
Our WhatsApp integration provider is shipping a change in mid-March 2026 that requires action from existing users. If you currently use the WhatsApp integration, you will need to reconnect your account once the change takes effect. Additionally, previously threaded conversations will start on a new thread due to a change in identifier format. Affected users have been emailed with further details.
## Connect the integration
Connecting your WhatsApp account to Relevance AI is a straightforward process:
1. Go to the "Integrations & API Keys" page in the sidebar.
2. Click on "WhatsApp".
3. Click on the "Add Integration" button.
4. In the pop-up window, sign into your WhatsApp Business account.
5. Follow the authorization steps to grant Relevance AI access to your WhatsApp account.
6. Once connected, you'll see your WhatsApp account listed under active integrations.
## Setting up triggers
WhatsApp Integration can be configured as a trigger for your AI agents, allowing them to automatically respond when messages are received through WhatsApp.
The WhatsApp Trigger is a Premium trigger, available on the Pro plan and above.
To set up WhatsApp as a trigger:
1. Create a new agent or edit an existing one.
2. Navigate to the "Triggers" section in "Agent Profile".
3. Select "WhatsApp" from the available triggers.
4. Choose the WhatsApp account you want to connect to this agent.
5. Configure trigger conditions (optional):
* Respond to all incoming messages
* Respond only to specific contacts or groups
* Respond based on message content filters
6. Save your trigger configuration.
Once set up, your agent will automatically activate when new WhatsApp messages that match your trigger conditions are received, enabling real-time customer engagement.
## Tools & Tool Steps
WhatsApp integration provides powerful tools and actions that your agents can use to engage with customers. These actions can be incorporated into your agent's workflow at any point, not just as triggers.
Here are some of the key WhatsApp actions available:
### Send WhatsApp Message
Send text messages to individual contacts or groups.
Input parameters:
* Recipient phone number or group ID
* Message content
* Optional: Attachments
### Send WhatsApp Media
Share images, documents, or other media files with your contacts.
Input parameters:
* Recipient phone number or group ID
* Media type (image, document, audio, video)
* Media URL or file
* Optional: Caption
### Send WhatsApp Template Message
Use pre-approved message templates for business communications.
Input parameters:
* Recipient phone number
* Template name
* Template parameters
### Get WhatsApp Conversation History
Retrieve previous messages from a specific conversation.
Input parameters:
* Contact phone number
* Optional: Time range
### Mark WhatsApp Message as Read
Update the read status of messages.
Input parameters:
* Message ID
These are just a few examples of the many WhatsApp actions available. Your agents can leverage these tools to create sophisticated customer engagement workflows, from automated support responses to personalized marketing campaigns.
## Use the integration's API tool step (advanced)
In addition to the tools and actions available in the directory, you can build custom tools that perform WhatsApp activities by using the WhatsApp API Call tool step:
1. Create a new tool.
2. Scroll down to Tool-steps.
3. Add WhatsApp API tool-step.
4. Select your connected WhatsApp account in the dropdown.
This advanced approach gives you direct access to the WhatsApp Business API, allowing for more complex and customized interactions:
### Example API call:
```json theme={null}
{
"endpoint": "/messages",
"method": "POST",
"body": {
"to": "{{recipient_number}}",
"type": "text",
"text": {
"body": "{{message_content}}"
}
}
}
```
## Frequently asked questions (FAQs)
Relevance AI supports both WhatsApp Personal and Business accounts. To learn more about the Business accounts integration, head [here](/docs/integrations/popular-integrations/whatsapp-for-business).
Message volumes are subject to WhatsApp's own policies and rate limits. The Relevance AI platform itself doesn't impose additional limits beyond your plan's credit allocation.
Yes, but you must comply with WhatsApp's business policies regarding bulk messaging and ensure you have proper opt-ins from recipients.
All WhatsApp communications maintain end-to-end encryption. Relevance AI adheres to strict security protocols to ensure your conversation data remains protected.
Yes, you can connect multiple agents to the same WhatsApp account, but you should configure triggers carefully to avoid conflicts.
Our WhatsApp integration provider is shipping a change in mid-March 2026. If you're an existing user, you'll need to reconnect your WhatsApp account once the change takes effect. Please also note that previously threaded conversations will start on a new thread, as the underlying identifier format is changing. No action is needed until the change goes live — we'll follow up with further instructions.
# Whatsapp for Business
Source: https://relevanceai.com/docs/integrations/popular-integrations/whatsapp-for-business
Interact with your WhatsApp Business account with Relevance.
Connect your AI agents with WhatsApp Business to engage with customers directly through one of the world's most popular messaging platforms. The WhatsApp Business integration enables your agents to handle customer inquiries, provide support, and deliver personalized experiences through WhatsApp's familiar interface.
## Connect the integration
Setting up the WhatsApp Business integration with Relevance AI is straightforward:
1. Navigate to the "Integrations & API Keys" page in the sidebar of your Relevance AI dashboard
2. Locate and click on "WhatsApp Business"
3. Click the "Add Integration" button
4. Follow the authentication flow to connect your WhatsApp Business account
5. Once connected, you'll see your WhatsApp Business account listed under active integrations
## Setting up triggers
The WhatsApp Business integration allows you to create powerful triggers that automatically activate your AI agents when specific events occur. This enables seamless customer engagement without manual intervention.
The WhatsApp for Business Trigger is a Premium trigger, available on the Pro plan and above.
To set up a WhatsApp trigger:
1. Go to your agent's profile page
2. Under "Triggers", select "WhatsApp Business"
3. Configure the trigger settings:
* **Trigger on new messages**: Activate your agent when a customer sends a message to your WhatsApp Business number
* **Trigger on specific keywords**: Set your agent to respond only when certain keywords or phrases are detected
* **Trigger based on customer attributes**: Configure triggers based on customer data or conversation context
Once configured, your agent will automatically engage with customers through WhatsApp when the trigger conditions are met.
## Tools & Tool Steps
The WhatsApp Business integration provides a rich set of actions that your agents can use to interact with customers. These actions can be incorporated into your agent's workflow to create sophisticated conversation flows and deliver exceptional customer experiences.
Here are some of the key actions available:
### Send Message
Send text messages to customers through WhatsApp. This action supports rich text formatting, allowing your agent to send well-structured, easy-to-read messages.
### Send Media
Share images, documents, videos, or audio files with customers. This is perfect for sending product catalogs, instructional materials, or visual content to enhance the conversation.
### Send Template Message
Utilize pre-approved message templates for common scenarios like welcome messages, order confirmations, appointment reminders, and more. Templates ensure compliance with WhatsApp's policies while maintaining consistent communication.
### Send Interactive Messages
Create interactive experiences with buttons, list messages, and reply buttons that guide customers through specific flows or help them make selections without typing lengthy responses.
### Get Customer Profile
Retrieve customer profile information to personalize interactions based on available data, such as name, profile picture, or previous interaction history.
### Mark Messages as Read
Update message status to "read" to provide customers with confirmation that their messages have been received and processed.
### Create Groups
Create WhatsApp groups for specific purposes, such as product launches, support communities, or team discussions.
### Manage Contacts
Add, update, or retrieve contact information to maintain an accurate customer database.
These are just a few examples of the many actions available through the WhatsApp Business integration. The platform offers numerous additional capabilities to support complex business workflows and customer engagement strategies.
## Use the integration's API tool step (advanced)
For advanced users who need more customized functionality, Relevance AI provides direct access to the WhatsApp Business API through a dedicated API tool step:
1. Create a new tool in your Relevance AI dashboard
2. Scroll down to Tool-steps
3. Add the WhatsApp Business API tool-step
4. Select your connected WhatsApp Business account from the dropdown
With the API tool step, you can build custom tools that leverage the full power of the WhatsApp Business API, including:
### Custom Message Formatting
Create highly customized message formats with advanced formatting options not available through standard actions.
### Batch Operations
Send messages to multiple recipients simultaneously or perform bulk operations on conversations.
### Advanced Media Handling
Implement sophisticated media processing workflows, such as image analysis or document processing before sending responses.
### Integration with External Systems
Connect WhatsApp conversations with external databases, CRMs, or business systems to create unified customer experiences.
### Custom Analytics
Build specialized analytics tools to track conversation metrics, customer engagement patterns, or agent performance.
The API tool step gives you complete flexibility to extend the capabilities of the WhatsApp Business integration to meet your specific business requirements.
## Frequently asked questions (FAQs)
You need a WhatsApp Business account and must comply with WhatsApp's Business Policy. Your account must be verified and in good standing.
Yes, you can connect multiple WhatsApp Business numbers to Relevance AI and configure different agents to work with specific numbers.
Yes, the integration is designed to comply with WhatsApp's Business Messaging Policy. However, it's your responsibility to ensure that your messaging practices adhere to these policies and local regulations.
# WorldNewsAPI
Source: https://relevanceai.com/docs/integrations/popular-integrations/worldnewsapi
Access thousands of news sources in 86+ languages from 210+ countries with semantic search, sentiment analysis, and real-time updates
WorldNewsAPI provides access to thousands of news sources across 210+ countries in 86+ languages, with 170,000+ news articles added daily in real-time. The platform offers semantic tagging, sentiment analysis, author extraction, and structured data extraction including images, videos, titles, descriptions, and publication dates.
With the WorldNewsAPI integration in Relevance AI, you can search news with advanced filters, extract structured data from news URLs, and convert location names to coordinates for location-based news searches—all directly within your AI workflows.
The WorldNewsAPI integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not WorldNewsAPI. If you have a question or issue with using WorldNewsAPI in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about WorldNewsAPI, you can [reach out to WorldNewsAPI support](https://worldnewsapi.com/).
## About WorldNewsAPI
WorldNewsAPI is a comprehensive news data platform that provides:
* **Global Coverage**: Access to thousands of news sources from 210+ countries
* **Multi-language Support**: Content in 86+ languages
* **Real-time Updates**: 170,000+ new articles added daily
* **Advanced Features**: Semantic tagging, sentiment analysis, author extraction
* **Rich Media**: Automatic extraction of images, videos, titles, descriptions, and dates
* **Powerful Search**: Semantic search with filters for country, language, time, sentiment, entities, sources, and authors
This is a native integration that replaces the previous Pipedream version, offering improved reliability and performance.
## Connect the integration
Connecting your WorldNewsAPI account to Relevance AI requires an API key:
1. Go to the "Integrations" page in the sidebar of your Relevance AI dashboard.
2. Click on "WorldNewsAPI" from the available integrations.
3. Click on the "Add Integration" button.
4. Enter your WorldNewsAPI API key when prompted.
5. Once authenticated, your WorldNewsAPI account will appear as a connected integration.
To get your WorldNewsAPI API key:
1. Sign up at [https://worldnewsapi.com/](https://worldnewsapi.com/)
2. Confirm your email address
3. Go to your Profile page
4. Click "Show/Hide API Key" to reveal your key
## Tool steps for WorldNewsAPI
The WorldNewsAPI integration provides ready-made actions that your agents can use to search news, extract article data, and work with location-based searches. These actions can be incorporated into your agent's workflows as tool steps.
### News Search & Discovery
Search thousands of news sources with filters for 50+ languages, 150+ countries, date ranges, sentiment, entities, sources, and authors
Extract structured data from any news article URL including title, text, images, videos, publish date, authors, language, source country, and sentiment
### Location Services
Convert location names to latitude and longitude coordinates for location-based news searches
### Advanced API Access
Make custom API calls to access any WorldNewsAPI endpoint for advanced use cases
Type "WorldNewsAPI" in the tool step search bar to see all available actions when building your tools.
## Use the integration's API tool step (Advanced)
In addition to the pre-built actions available in the tool directory, you can build custom tools that perform WorldNewsAPI-specific activities using the WorldNewsAPI API Call tool step.
### How to use the API Call tool step
Create a new tool in Relevance AI or open an existing tool you want to add WorldNewsAPI functionality to.
1. Scroll down to Tool-steps
2. Search for "WorldNewsAPI API Call" in the tool step search bar
3. Add the WorldNewsAPI API Call tool step to your workflow
Select your connected WorldNewsAPI account from the dropdown menu.
Configure the API endpoint, method, and parameters according to your needs:
* **Method**: Select the HTTP method (GET, POST)
* **Endpoint**: Enter the API endpoint path (e.g., `/search-news`)
* **Parameters**: Add query parameters for filtering and search criteria
Test your configuration to ensure it works correctly before deploying.
### Example: Search News with Custom Filters
Here's a practical example of using the WorldNewsAPI API Call tool step to search for technology news with sentiment filtering:
**API Endpoint**: `GET /search-news`
**Configuration**:
```json theme={null}
{
"method": "GET",
"endpoint": "/search-news",
"params": {
"text": "artificial intelligence",
"language": "en",
"sentiment": "positive",
"earliest-publish-date": "2026-03-01",
"number": 10
}
}
```
This configuration:
* Searches for articles about "artificial intelligence"
* Filters for English language content
* Returns only positive sentiment articles
* Limits results to articles published after March 1, 2026
* Returns up to 10 results
You can find WorldNewsAPI's complete API documentation at [https://worldnewsapi.com/docs/](https://worldnewsapi.com/docs/).
### Common API endpoints
**Endpoint**: `GET /search-news`
Search news articles with advanced filtering options:
* **text**: Search query text
* **language**: Filter by language code (e.g., "en", "es", "fr")
* **source-countries**: Filter by country codes
* **sentiment**: Filter by sentiment (positive, negative, neutral)
* **entities**: Filter by named entities
* **earliest-publish-date**: Start date for results
* **latest-publish-date**: End date for results
* **number**: Number of results to return
Returns: Array of news articles with full metadata
[View API Documentation](https://worldnewsapi.com/docs/)
**Endpoint**: `GET /extract-news`
Extract structured data from a news article URL:
* **url**: The news article URL to extract from
* **analyze**: Whether to include sentiment analysis
Returns: Title, text, images, videos, publish date, authors, language, source country, sentiment
[View API Documentation](https://worldnewsapi.com/docs/)
**Endpoint**: `GET /geo-coordinates`
Convert location names to coordinates:
* **location**: Location name to geocode
Returns: Latitude and longitude coordinates
Useful for location-based news searches and mapping.
[View API Documentation](https://worldnewsapi.com/docs/)
**Endpoint**: `GET /top-news`
Get top news headlines:
* **source-country**: Country code for news sources
* **language**: Language code
* **date**: Date for top news
Returns: Top headlines for the specified criteria
[View API Documentation](https://worldnewsapi.com/docs/)
## Example use cases
Here are some ways you can leverage the WorldNewsAPI integration with your agents:
Create an agent that monitors news mentions of your brand, products, or key executives. The agent searches for relevant articles, analyzes sentiment, and sends alerts when negative coverage is detected or when your brand appears in major publications.
Build an agent that tracks competitor mentions across global news sources. The agent monitors product launches, executive changes, funding announcements, and market moves, then compiles daily intelligence briefings for your team.
Deploy an agent that analyzes news trends in your industry. The agent tracks emerging topics, sentiment shifts, and geographic patterns, providing insights into market dynamics and consumer sentiment.
Create an agent that builds curated news feeds for specific topics, industries, or regions. The agent filters by language, sentiment, and relevance, then formats articles for your website, newsletter, or internal dashboard.
Build an agent that monitors for breaking news and crisis situations relevant to your organization. The agent searches for keywords related to potential risks, analyzes sentiment and urgency, and sends real-time alerts to stakeholders.
Deploy an agent that aggregates news from multiple languages and regions. The agent searches news in different languages, translates key articles, and creates a comprehensive international news digest for global teams.
Create an agent that tracks sentiment trends for specific topics over time. The agent collects articles, analyzes sentiment patterns, and generates reports showing how public perception is evolving.
Build an agent that monitors news for specific geographic locations. The agent uses geo-coordinates to find local news, tracks regional events, and alerts relevant teams about location-specific developments.
## Best practices
**Manage your API usage effectively:**
* Rate limits depend on your WorldNewsAPI plan
* Implement retry logic with exponential backoff for rate limit errors
* Cache search results when appropriate to reduce API calls
* Use specific filters to reduce result set sizes
* Monitor your API usage through the WorldNewsAPI dashboard
* Consider upgrading your plan if you consistently hit limits
**Get better search results:**
* Use specific search terms rather than broad queries
* Combine multiple filters (language, country, date) to narrow results
* Use sentiment filters to focus on relevant coverage
* Specify date ranges to get timely results
* Use entity filters to find articles mentioning specific people or organizations
* Test different search queries to find the most effective terms
**Ensure high-quality data:**
* Validate extracted article data before using it
* Handle cases where extraction fails or returns incomplete data
* Check sentiment scores for reliability
* Verify publication dates are within expected ranges
* Filter out duplicate articles from different sources
* Implement fallback logic for missing data fields
**Optimize workflow performance:**
* Limit the number of results per search to what you actually need
* Use pagination for large result sets
* Process articles in batches rather than one at a time
* Cache frequently accessed data
* Schedule regular searches rather than real-time queries when possible
* Use webhooks or scheduled runs instead of continuous polling
## Frequently asked questions (FAQs)
WorldNewsAPI supports 86+ languages including English, Spanish, French, German, Chinese, Japanese, Arabic, Portuguese, Russian, and many more. You can filter search results by language code (e.g., "en" for English, "es" for Spanish).
WorldNewsAPI provides access to thousands of news sources across 210+ countries. The exact number varies as sources are continuously added and updated. Coverage includes major international publications, regional news outlets, and specialized industry sources.
The native WorldNewsAPI integration is built directly into Relevance AI, offering better reliability, performance, and support. The Pipedream version (now renamed "World News API (Pipedream)") is being deprecated. We recommend using the native integration for all new workflows.
To get your API key:
1. Visit [https://worldnewsapi.com/](https://worldnewsapi.com/)
2. Sign up for an account
3. Confirm your email address
4. Log in and go to your Profile page
5. Click "Show/Hide API Key" to reveal your key
Keep your API key secure and never share it publicly.
Yes, rate limits depend on your WorldNewsAPI subscription plan. Free plans have lower limits, while paid plans offer higher request volumes. Check your WorldNewsAPI account dashboard for your specific limits. If you hit rate limits, implement retry logic in your workflows.
WorldNewsAPI uses advanced natural language processing for sentiment analysis. While generally accurate, sentiment detection can vary based on article complexity, language, and context. We recommend reviewing sentiment scores and implementing confidence thresholds for critical use cases.
Yes, you can search across multiple languages by making separate API calls for each language or by not specifying a language filter (which returns results in all languages). You can then filter or process the results based on your needs.
WorldNewsAPI adds 170,000+ articles daily in real-time. New articles typically appear in search results within minutes of publication. However, the exact timing depends on when the source publishes and how quickly it's indexed.
The Extract News tool works with most news article URLs. However, some sites may block automated extraction or have paywalls. The tool extracts publicly accessible content and structured data like titles, images, videos, authors, and publication dates.
Geo coordinates (latitude and longitude) allow you to search for news from specific geographic locations. This is useful for finding local news, tracking regional events, or monitoring news from areas relevant to your business operations.
Yes, you can filter search results by specific news sources or domains using the source filters in your search queries. This is useful when you want to monitor specific publications or exclude certain sources.
WorldNewsAPI maintains an extensive archive of historical news articles. The exact coverage period varies by source, but many sources have archives going back several years. Use the date range filters to search historical content.
# Zendesk
Source: https://relevanceai.com/docs/integrations/popular-integrations/zendesk
Connect Zendesk to automate customer support workflows and manage tickets with AI agents
Zendesk is a leading customer service platform that helps businesses manage support tickets, customer communications, and service operations. With the Zendesk integration in Relevance AI, you can automate ticket management, streamline support workflows, and enhance customer service operations using AI agents. The integration connects via OAuth, so tokens refresh automatically and there is no manual credential management required.
This integration is built by Relevance AI. For integration-specific support, contact [Relevance AI support](https://relevanceai.com/docs/get-started/support). For Zendesk platform issues, visit [Zendesk Support](https://support.zendesk.com/).
## Connect the Integration
Follow these steps to connect your Zendesk account to Relevance AI:
Go to the **Integrations & API Keys** page in your Relevance AI dashboard.
Find and click on **Zendesk** from the list of available integrations.
Click the **Add Integration** button to begin the connection process.
Provide your Zendesk subdomain — the part before `.zendesk.com` in your Zendesk URL (e.g., if your Zendesk URL is `yourcompany.zendesk.com`, enter `yourcompany`).
Click **Authorize** to be redirected to Zendesk. Sign in if prompted, then click **Allow** to grant Relevance AI access to your Zendesk account.
You'll be redirected back to Relevance AI. A confirmation message will indicate that your Zendesk account is successfully connected. Tokens refresh automatically — no manual management needed.
## Setting Up Triggers
**Enterprise Plan Required for Triggers** - Zendesk triggers are only available on Enterprise plans. Tool steps (actions) are available on all plans. [Contact sales](https://relevanceai.com/book-a-demo) to learn more.
Zendesk triggers allow you to automatically activate agents when specific events occur in your Zendesk account, such as:
* New ticket created
* Ticket status changed
* Ticket priority updated
* New comment added to ticket
* Ticket assigned to agent
To set up a Zendesk trigger (Enterprise plans only):
Open your agent and go to the **Triggers** tab in the agent settings.
Choose **Zendesk** from the list of available trigger integrations.
Select the specific Zendesk event that should activate your agent (e.g., "New Ticket Created").
Map Zendesk ticket data (subject, description, requester, priority, etc.) to your agent's input variables.
Test your trigger to ensure it works correctly, then activate it to start automating your support workflows.
## Tool Steps for Zendesk
Zendesk tool steps allow you to incorporate Zendesk actions into your agent workflows. These actions are available on all plans and can be used to automate ticket management and customer support operations.
### Ticket Management
Create a new support ticket in Zendesk with specified details including subject, description, priority, type, and assignee.
Retrieve detailed information about a specific ticket using its ticket ID, including status, priority, assignee, requester, and all comments.
Retrieve a list of tickets from your Zendesk account with optional filtering by status, priority, assignee, or date range.
Search for tickets using Zendesk's search query language to find tickets matching specific criteria.
Update an existing ticket's properties such as status, priority, assignee, tags, or add internal notes and public comments.
Delete a ticket from your Zendesk account. Note that this permanently removes the ticket.
To find these tool steps when building your agent or tool, search for "Zendesk" in the tool step search bar.
## Use the Integration's API Tool Step (Advanced)
For advanced use cases, you can use the **Zendesk API Call** tool step to make custom API requests to any Zendesk endpoint. This gives you access to the full Zendesk API beyond the pre-built tool steps.
### How to use the Zendesk API Call tool step
In your agent or tool builder, add the **Zendesk API Call** tool step.
Choose the appropriate HTTP method (GET, POST, PUT, PATCH, DELETE).
Provide the API endpoint path (e.g., `/api/v2/users.json` or `/api/v2/tickets/12345.json`).
For POST, PUT, or PATCH requests, provide the request body in JSON format.
Map the API response to variables in your workflow for further processing.
Test your API call to ensure it returns the expected data.
### Example: Adding Tags to a Ticket
```json theme={null}
{
"method": "PUT",
"endpoint": "/api/v2/tickets/12345.json",
"body": {
"ticket": {
"tags": ["urgent", "vip", "billing"]
}
}
}
```
### Common Zendesk API Endpoints
**Ticket Operations**
* `GET /api/v2/tickets.json` - List all tickets
* `GET /api/v2/tickets/{id}.json` - Get ticket details
* `POST /api/v2/tickets.json` - Create a ticket
* `PUT /api/v2/tickets/{id}.json` - Update a ticket
* `DELETE /api/v2/tickets/{id}.json` - Delete a ticket
**User Management**
* `GET /api/v2/users.json` - List users
* `GET /api/v2/users/{id}.json` - Get user details
* `POST /api/v2/users.json` - Create a user
* `PUT /api/v2/users/{id}.json` - Update a user
**Organization Management**
* `GET /api/v2/organizations.json` - List organizations
* `GET /api/v2/organizations/{id}.json` - Get organization details
**Ticket Comments**
* `GET /api/v2/tickets/{id}/comments.json` - List ticket comments
* `POST /api/v2/tickets/{id}/comments.json` - Add a comment
**Search**
* `GET /api/v2/search.json?query={query}` - Search across Zendesk
For complete API documentation, visit the [Zendesk API Reference](https://developer.zendesk.com/api-reference/).
## Example Use Cases
Automatically categorize and prioritize incoming support tickets based on content analysis, customer history, and urgency indicators. Route tickets to the appropriate team or agent.
Analyze ticket content and customer history to generate suggested responses for support agents, reducing response time and improving consistency.
Monitor ticket sentiment in real-time and automatically escalate tickets with negative sentiment or frustrated customers to senior support staff.
Track ticket response and resolution times, automatically escalate tickets approaching SLA breaches, and notify managers of potential violations.
Automatically suggest relevant knowledge base articles to customers based on their ticket content, or create new articles from frequently asked questions.
Synchronize support requests from multiple channels (email, chat, social media) into Zendesk tickets and maintain consistent customer communication.
Automatically enrich ticket data with information from CRM systems, previous interactions, purchase history, and customer profiles for better context.
Schedule and send automated follow-up messages to customers based on ticket status, resolution time, or customer satisfaction scores.
## Frequently asked questions (FAQs)
The integration uses OAuth, so you authorize access through your Zendesk account directly. For full functionality, the Zendesk account you authorize with should have Admin or Agent permissions.
Yes, you can connect multiple Zendesk accounts by adding separate integrations for each account. Each integration will appear with its account name in your integrations list.
If you encounter authentication errors, check the following: ensure your Zendesk subdomain is entered correctly (just the part before `.zendesk.com`), verify that the Zendesk account you authorized has Admin or Agent permissions, and try disconnecting and reconnecting the integration to trigger a fresh OAuth flow. If issues persist, contact [Relevance AI support](/docs/get-started/support).
Yes! When using the Zendesk API Call tool step, you can access and update custom ticket fields by including them in your API requests. Reference your custom field IDs from your Zendesk Admin Center.
Yes, Zendesk enforces API rate limits based on your Zendesk plan. The integration respects these limits automatically. If you encounter rate limit errors, consider implementing delays between API calls or upgrading your Zendesk plan.
Absolutely! You can use Relevance AI agents to monitor various sources (email, forms, chat, social media) and automatically create Zendesk tickets using the Create Ticket tool step. This enables centralized support management across all channels.
Ticket attachments can be accessed and managed through the Zendesk API Call tool step. Use the appropriate endpoints to upload attachments when creating tickets or retrieve attachments from existing tickets.
***
Contact our support team for assistance with the Zendesk integration
Discover other integrations to enhance your workflows
# Zoom
Source: https://relevanceai.com/docs/integrations/popular-integrations/zoom
Adding support for generating Zoom meeting links
Zoom offers the ability to create cloud web meetings.
### How to add integration?
1. Go to the **Integrations & API Keys** page from the sidebar
2. Select Zoom from the list
3. Click "+ Integration"
4. Complete OAuth flow by logging into Zoom account
### How to use?
Once your account is connected, you can use Zoom steps in the Tool builder. You will have access to a "Zoom API Call" step which you will be able to use to create a meeting, update a meeting, delete a meeting, and more. You can run that step with the required API call for scheduling a meeting.
#### Subdomain field
The Zoom API Call step includes an optional **Subdomain** field for enterprise Zoom deployments that use a custom subdomain. If your organization's Zoom instance is accessed at a URL like `myorg.zoom.us` rather than the standard `zoom.us`, enter the subdomain portion only (e.g., `myorg`, not `myorg.zoom.us`). Leave this field empty if you use the standard zoom.us endpoint — it defaults to zoom.us when not specified.
### How to remove integration?
1. Go to the **Integrations & API Keys** page from the sidebar
2. Select Zoom from the list
3. Click "..." on the account you want to remove
4. Click remove
### Frequently asked questions
This issue occurs when you're trying to connect Zoom as an admin user (not the account owner) and your admin role lacks the necessary permissions for external API connections.
Two specific permissions must be enabled in Zoom's admin role settings:
* **Chat messages** — allows API access to all users' chat messages
* **External Connections** — allows admin accounts to view and manage external connections
To fix this:
1. Log into your Zoom account as an admin.
2. Navigate to **Admin > Role Management**.
3. Select your admin role.
4. Check the boxes for both **Chat messages** and **External Connections**.
5. Save your changes.
6. Retry connecting your Zoom account in Relevance AI.
This applies whether you're connecting directly through Relevance AI or via third-party services like Pipedream.
# ZoomInfo
Source: https://relevanceai.com/docs/integrations/popular-integrations/zoominfo
Search ZoomInfo's B2B database and enrich contact and company records from your AI agents.
ZoomInfo is a B2B database and intelligence platform that provides contact and company information for sales and marketing teams. With the Relevance AI ZoomInfo integration, your AI agents can search ZoomInfo's database for free and enrich records with detailed contact and company data using ZoomInfo credits. This integration is compatible with GTM agents.
The ZoomInfo integration in Relevance AI was built by Relevance AI, and is therefore supported by our team, not ZoomInfo. If you have a question or issue with using ZoomInfo in Relevance AI, please [reach out to our support team](/docs/get-started/support). If you have a question or issue that is only about ZoomInfo, you can reach out to ZoomInfo support directly.
## Connect the integration
The ZoomInfo integration uses credential-based authentication. You will need three values from your ZoomInfo account: your ZoomInfo email address, a client ID, and a private key.
Log in to your ZoomInfo account and navigate to the API settings or developer portal. Locate your **Client ID** and **Private key**. These are generated in your ZoomInfo account under the API or integrations section. If you do not see them, contact your ZoomInfo account administrator.
Go to **Integrations & API Keys** in the sidebar of your Relevance AI dashboard.
Find and click on **ZoomInfo** from the available integrations list.
Click **Add Integration** to open the credentials form.
Fill in the three required fields:
* **ZoomInfo email**: The email address associated with your ZoomInfo account
* **Client ID**: Your ZoomInfo API client ID
* **Private key**: Your ZoomInfo API private key
Click **Save** to connect your account. Once authenticated, your ZoomInfo account will appear as a connected integration.
Keep your private key secure. Do not share it publicly or commit it to version control. If your private key is compromised, regenerate it from your ZoomInfo account settings.
## Understanding credit consumption
ZoomInfo uses a credit-based system for data enrichment. It is important to understand which operations are free and which consume credits before building your workflows.
### Free operations
**Searching does not consume ZoomInfo credits.** The following operations are free:
* Searching for contacts by name, title, company, location, or other criteria
* Searching for companies by name, industry, size, location, or other filters
* Browsing and filtering ZoomInfo's database to build prospect lists
### Credit-consuming operations
**Enrichment operations consume ZoomInfo credits.** Credits are used when you retrieve detailed data for a specific record, including:
* Email addresses
* Phone numbers
* Company revenue figures
* Employee counts
* Other detailed contact and company attributes
The integration includes built-in credit safeguards to help prevent unexpected credit usage. Monitor your credit balance in your ZoomInfo dashboard and design workflows to enrich only when necessary.
Use search operations to filter and qualify prospects first, then enrich only the records that meet your criteria. This approach minimizes credit consumption.
## Tools & tool steps
The ZoomInfo integration provides actions for both free search and credit-based enrichment. You can add these as tool steps when building tools in Relevance AI.
### Search operations (free)
Search for contacts matching criteria such as job title, company, location, or industry. Does not consume credits.
Find companies matching filters like industry, employee count, revenue range, or location. Does not consume credits.
### Enrichment operations (consumes credits)
Retrieve detailed contact data including email addresses, phone numbers, and professional details for a specific person. Consumes credits.
Retrieve detailed company data including revenue, employee count, technologies used, and firmographic details. Consumes credits.
### How to add ZoomInfo tool steps to your agent
1. Create a new tool in your Relevance AI workspace or open an existing one.
2. Scroll down to **Tool steps**.
3. Search for "ZoomInfo" in the tool step search bar.
4. Select the desired ZoomInfo action.
5. Select your connected ZoomInfo account from the dropdown.
6. Configure the action parameters and connect the tool to your agent.
## Use the ZoomInfo API tool step (advanced)
Advanced users can make custom API calls to any ZoomInfo endpoint using the ZoomInfo API Call tool step.
Create a new tool in Relevance AI or open an existing tool you want to add ZoomInfo functionality to.
Scroll down to Tool steps, search for "ZoomInfo API Call", and add it to your workflow.
Select your connected ZoomInfo account from the dropdown.
Set the HTTP method, endpoint path, and request body parameters according to the ZoomInfo API documentation.
Test your API call before deploying to confirm it returns the expected data.
```json theme={null}
{
"endpoint": "/companies/enrich",
"method": "POST",
"body": {
"company_name": "{{input.company_name}}",
"domain": "{{input.domain}}",
"include_attributes": ["industry", "revenue", "employee_count", "technologies", "location"]
}
}
```
This call retrieves specific company attributes for use in lead qualification. Note that enrichment calls consume ZoomInfo credits.
## Example use cases
Build a GTM agent that searches ZoomInfo for companies matching your ideal customer profile, then enriches only the top-scoring matches with detailed contact and company data. The agent can prepare outreach briefs and route leads to the appropriate sales representatives.
Create an agent that first searches ZoomInfo to filter and qualify leads based on free criteria (company size, industry, location), then enriches only the records that pass qualification with email addresses and phone numbers. This pattern keeps credit usage low while maximizing data quality.
Deploy an agent that searches ZoomInfo for decision-makers at target accounts, enriches their contact details, and compiles account briefs for your marketing team without consuming credits on records outside your target list.
Build an agent that identifies incomplete records in your CRM and uses ZoomInfo to fill in missing email addresses, phone numbers, and company details. Implement logic to skip records that already have complete data to avoid unnecessary credit consumption.
## Best practices
Use search operations to filter your prospect pool before enriching. Only enrich records that meet your qualification criteria, and implement checks to avoid enriching the same record twice. Monitor credit usage in your ZoomInfo dashboard and set up alerts if available.
Store your ZoomInfo client ID and private key securely. Do not hard-code credentials in tool configurations visible to other team members. Rotate your private key if you suspect it has been compromised.
Only use ZoomInfo data for legitimate business purposes. Comply with GDPR, CCPA, and other applicable privacy regulations in your region. Review ZoomInfo's terms of service and acceptable use policy before building automated outreach workflows.
## Frequently asked questions (FAQs)
It depends on the operation. **Search operations are free** — searching for contacts or companies does not consume ZoomInfo credits. **Enrichment operations consume credits** — retrieving detailed data such as email addresses, phone numbers, revenue figures, or employee counts for a specific record uses credits. Design your workflows to search first and enrich only when needed.
You need three credentials from your ZoomInfo account: your ZoomInfo email address, a client ID, and a private key. These are available in the API or integrations section of your ZoomInfo account settings. Contact your ZoomInfo account administrator if you do not have API access.
Yes. The ZoomInfo integration is compatible with GTM agents in Relevance AI. You can use ZoomInfo search and enrichment tool steps in GTM agent workflows.
Enrichment operations will fail when your ZoomInfo credit balance is exhausted. Search operations will continue to work since they do not consume credits. Monitor your credit balance in your ZoomInfo dashboard and top up as needed. The integration includes built-in credit safeguards to help prevent unexpected over-usage.
Yes. You need an active ZoomInfo account with API access and valid API credentials (email, client ID, and private key) to connect the integration.
# Remove Integrations
Source: https://relevanceai.com/docs/integrations/remove-integrations
Manage your connected services by removing integrations that are no longer needed.
## Overview
While integrations enhance your AI agents' capabilities by connecting them to external services, there may be times when you need to remove these connections. Whether you're switching service providers, or simply cleaning up unused connections, Relevance AI provides a straightforward process for removing integrations.
## How to Remove Integrations
Follow these steps to remove an integration from your Relevance AI account:
1. Navigate to the **Integrations** page from the left-hand menu of your Relevance AI account.
2. Locate the integration you want to remove in your list of connected services.
3. Click on the integration to expand its details.
4. Click the three dots settings button and click the **Remove** button.
Once disconnected, the integration will no longer appear in your list of available connections, and your AI agents will no longer have access to that service.
## Important Considerations
Before removing an integration, consider the following:
### Impact on Agents
* **Check Dependencies**: Verify which agents are currently using the integration before removing it.
* **Update Agent Workflows**: Agents that rely on the removed integration may need reconfiguration to prevent workflow disruptions.
* **Tool Availability**: Tools that depend on the removed integration will no longer function properly.
## Reconnecting Integrations
If you need to reconnect an integration after removing it:
1. Navigate to the **Integrations** page.
2. Browse the available integrations and select the service you want to reconnect.
3. Follow the authentication steps to reauthorize the connection.
4. Once reconnected, the integration will appear in your list of available connections.
## Frequently asked questions (FAQs)
**Q: How do I know which agents are using a particular integration?**\
A: Before removing an integration, go to each agent's settings and check the "Connected Resources" or "Tools" section to see which integrations they're using.
# Agents
Source: https://relevanceai.com/docs/sdk/agents
Load agents, read their metadata, send messages, and list tasks.
The `Agent` class represents a single agent on the Relevance AI platform. Use it to start conversations, fetch existing tasks, and read configuration set in the dashboard.
## Load a single agent
Fetch an agent by its ID. The agent ID is visible on the agent's page in the dashboard.
```typescript theme={null}
import { Agent } from "@relevanceai/sdk";
const agent = await Agent.get("");
```
To use a specific client instead of the default singleton:
```typescript theme={null}
const agent = await Agent.get("", client);
```
## List all agents
Fetch a paginated list of every agent in the project:
```typescript theme={null}
const agents = await Agent.getAll();
```
Pagination is controlled with `pageSize` and `page`:
```typescript theme={null}
const agents = await Agent.getAll({
pageSize: 50,
page: 2,
});
```
The defaults are `pageSize: 20` and `page: 1`.
## Read agent metadata
Once loaded, an agent exposes a number of fields:
```typescript theme={null}
const agent = await Agent.get("");
console.log(agent.name); // display name
console.log(agent.description); // agent description
console.log(agent.avatar); // avatar emoji or URL
console.log(agent.id); // unique identifier
console.log(agent.region); // deployment region
console.log(agent.project); // project identifier
console.log(agent.createdAt); // Date object
console.log(agent.updatedAt); // Date object
```
`name`, `description`, and `avatar` may be `undefined` if they haven't been configured in the dashboard.
## Start a conversation
Send a message with `sendMessage`. This creates a new task (the conversation thread) and returns it immediately. The method doesn't wait for the agent to respond.
```typescript theme={null}
const task = await agent.sendMessage("What can you help me with?");
```
To continue an existing conversation, pass the task back:
```typescript theme={null}
await agent.sendMessage("Tell me more about that", task);
```
File attachments can be included as well:
```typescript theme={null}
const file = new File([bytes], "report.pdf", {
type: "application/pdf",
});
const task = await agent.sendMessage("Summarize this report", [file]);
```
For a full walkthrough of message types, attachments, and response handling, see [Messaging](/docs/sdk/messaging).
## Retrieve tasks
### A single task
Fetch a specific task by ID:
```typescript theme={null}
const task = await agent.getTask("");
```
### A list of tasks
Fetch a paginated, sortable, and filterable list of tasks for the agent:
```typescript theme={null}
const tasks = await agent.getTasks({
pageSize: 10,
page: 1,
sort: { updatedAt: "desc" },
filter: { status: ["running", "queued"] },
search: "quarterly report",
});
```
All options are optional. The defaults are `pageSize: 100`, `page: 1`, and `sort: { createdAt: "asc" }`.
Filtering by status accepts an array of simplified task statuses. For the full lifecycle and status values, see [Tasks](/docs/sdk/tasks).
# Authentication
Source: https://relevanceai.com/docs/sdk/authentication
API keys for server code, embed keys for the browser, and region selection.
The SDK supports two authentication methods. Each one is designed for a specific environment.
## API keys vs. embed keys
Grant full access to a project. Use in server-side applications, background workers, and other secure environments where the key is never exposed to end users.
Scoped to a single public agent or workforce. Use in browser applications and other client-side contexts where the key is visible in network traffic.
Rule of thumb: if the code runs on a server, use an API key. If it runs in a browser, use an embed key.
## Regions
Every Relevance AI project is deployed to a specific region. Match the region where your project was created — check the project settings in the dashboard.
| Constant | Region |
| ----------- | ------------- |
| `REGION_US` | United States |
| `REGION_EU` | Europe |
| `REGION_AU` | Australia |
```typescript theme={null}
import { REGION_US, REGION_EU, REGION_AU } from "@relevanceai/sdk";
```
## API key authentication
API keys are available in the project settings on the dashboard. They follow the `sk-...` format and grant unrestricted access to every resource in the project.
The fastest way to authenticate is with `createClient`:
```typescript theme={null}
import { createClient, REGION_AU } from "@relevanceai/sdk";
const client = createClient({
apiKey: "sk-...",
region: REGION_AU,
project: "",
});
```
For more control, construct a `Key` instance explicitly and pass it to the `Client` constructor:
```typescript theme={null}
import { Client, Key, REGION_AU } from "@relevanceai/sdk";
const key = new Key({
key: "sk-...",
region: REGION_AU,
project: "",
});
const client = new Client(key);
```
Both approaches produce an authenticated client. For details on `createClient` vs. direct construction, see [Client](/docs/sdk/client).
## Embed key authentication
Embed keys are generated at runtime and scoped to a single public agent or a single workforce. They're safe to use in browser environments because they can't access resources outside their scope.
### For an agent
```typescript theme={null}
import { Key, createClient, REGION_US } from "@relevanceai/sdk";
const key = await Key.generateEmbedKey({
region: REGION_US,
project: "",
agentId: "",
});
const client = createClient(key);
```
The agent must be marked as public in the dashboard. Private agents can't be accessed with embed keys.
### For a workforce
```typescript theme={null}
import { Key, REGION_US } from "@relevanceai/sdk";
const key = await Key.generateEmbedKey({
region: REGION_US,
project: "",
workforceId: "",
});
```
Each embed key is bound to exactly one agent or one workforce. To interact with multiple agents or workforces from the client side, generate a separate embed key for each.
## Persisting embed keys
Generating an embed key involves a network request and, importantly, initializes a specific user session. You should persist keys to avoid unnecessary latency and to ensure session continuity; **regenerating a new key on every page load will prevent the user from restoring their past conversations.**
To maintain the session, persist the key with `toJSON()` and restore it using the `Key` constructor.
### Save to localStorage
```typescript theme={null}
const key = await Key.generateEmbedKey({
region: REGION_US,
project: "",
agentId: "",
});
localStorage.setItem("relevance_key", JSON.stringify(key.toJSON()));
```
### Restore from localStorage
```typescript theme={null}
import { Key, Client } from "@relevanceai/sdk";
const stored = localStorage.getItem("relevance_key");
if (stored) {
const key = new Key(JSON.parse(stored));
const client = new Client(key);
}
```
`toJSON` returns a plain object containing every field needed to reconstruct the key — region, project, scoped agent or workforce ID, and the task prefix used for conversation namespacing.
## Security guidance
Never embed API keys in client-side code, browser-accessible environment variables, or version control. API keys grant full project access and must remain on the server.
* Embed keys are the only safe authentication method for browser environments. They're scoped to a single agent or workforce and can't access other project resources.
* Immediately revoke any compromised API keys before regenerating. Existing keys do not auto-expire and must be manually decommissioned via the dashboard to terminate access.
* Store embed keys in `localStorage`, a secure cookie, or an equivalent client-side persistence mechanism. Regenerate them if the storage is cleared.
# Client
Source: https://relevanceai.com/docs/sdk/client
Initialize the SDK client, use the default singleton, or manage multiple clients.
The `Client` is the authenticated handle the SDK uses to talk to the Relevance AI platform. Most applications only need one.
## Initialize with createClient
`createClient` is the recommended way to set up the SDK. It constructs a `Client`, registers it as the default singleton, and returns it.
```typescript theme={null}
import { createClient, REGION_EU } from "@relevanceai/sdk";
const client = createClient({
apiKey: "sk-...",
region: REGION_EU,
project: "",
});
```
It also accepts a `Key` instance directly, which is useful when working with embed keys:
```typescript theme={null}
import { createClient, Key, REGION_US } from "@relevanceai/sdk";
const key = await Key.generateEmbedKey({
region: REGION_US,
project: "",
agentId: "",
});
const client = createClient(key);
```
For full details on keys, see [Authentication](/docs/sdk/authentication).
Call `createClient` exactly once. It throws if a default client already exists. To work with additional projects or authentication scopes, construct `Client` instances directly — see [Using multiple clients](#using-multiple-clients).
## The default singleton
Once `createClient` runs, the client is stored as a global default. Every SDK method that takes an optional client parameter falls back to this default when none is passed.
```typescript theme={null}
import { createClient, Client, Agent, REGION_US } from "@relevanceai/sdk";
// Set the default at application startup
createClient({
apiKey: "sk-...",
region: REGION_US,
project: "",
});
// Retrieve the default anywhere in the application
const client = Client.default();
// SDK methods pick it up automatically
const agent = await Agent.get("");
```
This keeps authentication centralized. Initialize the client once during startup, then the rest of the application can interact with agents and workforces without passing the client around.
## Using multiple clients
Some apps need to talk to multiple projects, or use different authentication scopes — for example, an API key for admin operations and an embed key for end-user interactions. In those cases, construct `Client` instances directly and pass them explicitly.
```typescript theme={null}
import { Client, Key, Agent, REGION_EU } from "@relevanceai/sdk";
const adminKey = new Key({
key: "sk-admin-key",
region: REGION_EU,
project: "project-one",
});
const userKey = new Key({
key: "sk-user-key",
region: REGION_EU,
project: "project-two",
});
const adminClient = new Client(adminKey);
const userClient = new Client(userKey);
// Pass the client explicitly
const adminAgent = await Agent.get("agent-a", adminClient);
const userAgent = await Agent.get("agent-b", userClient);
```
Only one client can be the default singleton. When using multiple clients, pass the right instance to every SDK method call.
# Installation
Source: https://relevanceai.com/docs/sdk/installation
Install @relevanceai/sdk in Node.js, Deno, Bun, Cloudflare Workers, or the browser.
The SDK ships to both npm and JSR, and works in every major JavaScript runtime with no extra configuration.
## Prerequisites
Before installing, make sure you have:
* A Relevance AI account with access to the project dashboard
* An API key or embed key — see [Authentication](/docs/sdk/authentication)
* One of the supported runtimes below
## Node.js, Bun, and Cloudflare Workers
Install from npm with any package manager.
```bash theme={null}
npm install @relevanceai/sdk@latest
```
```bash theme={null}
yarn add @relevanceai/sdk@latest
```
```bash theme={null}
pnpm add @relevanceai/sdk@latest
```
```bash theme={null}
bun add @relevanceai/sdk@latest
```
Then import the named exports you need:
```typescript theme={null}
import { createClient, Agent } from "@relevanceai/sdk";
```
## Deno
Add the package from JSR:
```bash theme={null}
deno add jsr:@relevanceai/sdk
```
Or import directly without a local install:
```typescript theme={null}
import { createClient } from "jsr:@relevanceai/sdk";
```
## Browser via CDN
For browser apps that don't use a bundler, load the SDK through an import map:
```html theme={null}
```
## Browser bundler configuration
When bundling for the browser with Vite, Webpack, or Rollup, you may see a warning about `node:crypto`. The SDK uses this module for UUID generation and falls back to the native browser equivalent. To silence the warning, add a shim and point the bundler at it.
Save this as `src/shims/crypto.ts`:
```typescript theme={null}
export default globalThis.crypto;
```
In `vite.config.ts`, add a resolve alias:
```typescript theme={null}
import { defineConfig } from "vite";
import path from "node:path";
export default defineConfig({
resolve: {
alias: {
"node:crypto": path.resolve(
__dirname,
"src/shims/crypto.ts"
),
},
},
});
```
In `webpack.config.js`, add a resolve alias:
```javascript theme={null}
module.exports = {
resolve: {
alias: {
"node:crypto": path.resolve(
__dirname,
"src/shims/crypto.js"
),
},
},
};
```
Use the `@rollup/plugin-alias` plugin:
```javascript theme={null}
import alias from "@rollup/plugin-alias";
import path from "node:path";
export default {
plugins: [
alias({
entries: [
{
find: "node:crypto",
replacement: path.resolve(
__dirname,
"src/shims/crypto.js"
),
},
],
}),
],
};
```
## Verify the installation
Run a minimal script to confirm everything is wired up. Replace the placeholder values with real credentials from the dashboard.
```typescript theme={null}
import { createClient, Agent, REGION_US } from "@relevanceai/sdk";
createClient({
apiKey: "",
region: REGION_US,
project: "",
});
const agent = await Agent.get("");
console.log("Connected:", agent.name);
```
If the agent's name prints to the console, the SDK is installed and authenticated correctly.
# JavaScript SDK
Source: https://relevanceai.com/docs/sdk/introduction
Build apps on top of Relevance AI agents and workforces with the official JavaScript/TypeScript SDK.
`@relevanceai/sdk` is the official JavaScript and TypeScript SDK for the Relevance AI platform. Use it to start conversations with agents, trigger workforces, stream responses in real time, and handle file attachments — all from your own application code.
## What's in the box
Works in Node.js, Deno, Bun, Cloudflare Workers, and the browser. Zero dependencies — built on web standards.
Real-time updates through the native `EventTarget` API. No custom event system to learn.
Full TypeScript definitions across agents, tasks, messages, and workforces. Type guards narrow message kinds automatically.
Thinking and typing tokens arrive through the same event stream as final messages — no extra configuration.
## When to use the SDK
* Embedding chat into a web or mobile app
* Triggering agents from a backend service, worker, or cron job
* Running workforces from a server-side pipeline
* Building custom dashboards on top of agent output
If you just need to fire a one-off webhook or call from a language the SDK doesn't support, use the [API trigger](/docs/build/agents/build-your-agent/agent-triggers/api-trigger) instead.
## Where to next
Install, authenticate, and send your first message in under a minute.
API keys for server code, embed keys for the browser, and region selection.
Load agents, send messages, and list tasks.
Trigger multi-agent workforces and handle handover messages.
# Messaging
Source: https://relevanceai.com/docs/sdk/messaging
Send messages, work with message types, manage file attachments, and handle errors.
Messages are how your application and an agent exchange information inside a task. This page covers sending messages, the different kinds of incoming messages, and how to handle them.
## Send a message
Both agents and workforces use `sendMessage`. It accepts a string and returns a `Task` representing the conversation thread.
```typescript theme={null}
const task = await agent.sendMessage("What can you help me with?");
```
The returned task begins processing immediately. The promise resolves as soon as the message is sent — not when the agent responds. To receive the response, listen for events on the task. See [Tasks](/docs/sdk/tasks) for event handling.
## Continue a conversation
To send a follow-up message within the same conversation, pass the existing task as the second argument:
```typescript theme={null}
const task = await agent.sendMessage("Hello");
// Later, continue the same conversation
await agent.sendMessage("Tell me more", task);
```
Each call with an existing task appends to the conversation history. The agent has full context of the prior messages.
## File attachments
Attach files by passing an array of `File` objects as the second argument. The SDK handles the upload.
```typescript theme={null}
const pdf = new File([bytes], "contract.pdf", {
type: "application/pdf",
});
const task = await agent.sendMessage("Summarize this contract", [pdf]);
```
Multiple files in a single message:
```typescript theme={null}
const task = await agent.sendMessage(
"Compare these two documents",
[fileA, fileB]
);
```
To send attachments while continuing a conversation, pass the attachments array and the task:
```typescript theme={null}
await agent.sendMessage(
"Here is an updated version",
[updatedFile],
task
);
```
Pre-uploaded attachments (objects with `fileName` and `fileUrl` fields) can be mixed in with `File` objects in the same array.
Workforce tasks don't support file attachments. Only agent tasks accept files.
## Handle incoming messages
Messages arrive through the `"message"` event on a task. Each event's `detail` includes a `message` property. Use the type guard methods to determine the kind and access the right fields.
```typescript theme={null}
task.addEventListener("message", ({ detail }) => {
const { message } = detail;
if (message.isAgent()) {
console.log("Agent:", message.text);
} else if (message.isTool()) {
console.log("Tool:", message.status);
} else if (message.isThinking()) {
console.log("Thinking:", message.text);
} else if (message.isTyping()) {
console.log("Typing:", message.text);
}
});
```
The type guards narrow the TypeScript type — properties specific to each message kind become available after the check.
## Agent responses
When `message.isAgent()` returns `true`, the message is an `AgentMessage` carrying the agent's response text.
```typescript theme={null}
if (message.isAgent()) {
console.log(message.text);
console.log(message.agentId);
}
```
## Tool executions
When `message.isTool()` returns `true`, the message is a `ToolMessage` representing a tool or subagent execution inside the agent's pipeline.
```typescript theme={null}
if (message.isTool()) {
console.log("Tool:", message.tool?.name);
console.log("Status:", message.status);
}
```
The `status` field tracks where the tool is in its lifecycle:
| Status | Meaning |
| ----------- | -------------------------- |
| `pending` | Scheduled, not yet started |
| `running` | Currently executing |
| `completed` | Finished successfully |
| `error` | Failed with an error |
| `cancelled` | Execution was cancelled |
### Read tool output
Once a tool completes, its output is available:
```typescript theme={null}
if (message.isTool() && message.status === "completed") {
console.log(message.output);
}
```
### Detect subagents
A tool message may represent a subagent rather than a standalone tool. Use `isSubAgent` to check, and `subAgentTaskId` to access the subagent's task:
```typescript theme={null}
if (message.isTool() && message.isSubAgent()) {
console.log("Sub-agent task:", message.subAgentTaskId);
}
```
### Tool errors
Check for errors on a tool message with `hasErrors`:
```typescript theme={null}
if (message.isTool() && message.hasErrors()) {
for (const error of message.errors) {
console.error(error.stepName, error.message);
}
}
```
## User messages
User messages represent input sent by the application or end user. They show up in the message history alongside agent responses.
```typescript theme={null}
task.addEventListener("message", ({ detail }) => {
const { message } = detail;
if (message.isUser()) {
console.log("User:", message.text);
if (message.hasAttachments()) {
for (const attachment of message.attachments) {
console.log("File:", attachment.fileName);
}
}
}
});
```
`isTrigger` returns `true` for the first message in a conversation — the one that created the task:
```typescript theme={null}
if (message.isUser() && message.isTrigger()) {
console.log("Conversation started with:", message.text);
}
```
## Error handling
Agent errors are delivered through the `"error"` event on the task. The event detail contains an `AgentErrorMessage` with one or more error strings.
```typescript theme={null}
task.addEventListener("error", ({ detail }) => {
const { message } = detail;
console.error("Last error:", message.lastError);
// All errors in this cycle
for (const error of message.errors) {
console.error(error);
}
});
```
Error events mean the agent ran into a problem during execution. The task may transition to an `"error"` or `"action"` status depending on the nature of the failure. See [Tasks](/docs/sdk/tasks) for status details.
## Workforce messages
Workforce tasks include two additional message types for multi-agent coordination:
* **`WorkforceAgentMessage`** — an agent within the workforce is executing a subtask. Includes details about which agent is running and the state of its work.
* **`WorkforceAgentHandoverMessage`** — work is being delegated from one agent to another within the workforce. Includes the trigger message and details about the receiving agent.
These messages appear alongside standard agent and tool messages in the event stream. See [Workforces](/docs/sdk/workforces) for workforce-specific behavior.
## Streaming messages
Two message types represent real-time incremental output from the agent:
* **`ThinkingMessage`** — the agent's intermediate reasoning as it processes.
* **`TypingMessage`** — the agent's response text as it's being generated.
Both are identified with the `isThinking` and `isTyping` type guards shown above. For streaming behavior and live typing indicators, see [Streaming](/docs/sdk/streaming).
# Quickstart
Source: https://relevanceai.com/docs/sdk/quickstart
Install the SDK, authenticate, and send your first message in under a minute.
Get from zero to a live agent conversation in five steps. This quickstart uses Node.js — for other runtimes, see [Installation](/docs/sdk/installation).
```bash theme={null}
npm install @relevanceai/sdk
```
Yarn, pnpm, Bun, and Deno are all supported. See [Installation](/docs/sdk/installation) for the full matrix.
From the Relevance AI dashboard, go to **Integrations & API Keys** and generate a Relevance API key. You'll also need your project ID and the region your project is deployed in.
For a walkthrough, see [API integration](/docs/get-started/core-concepts/api-integration).
```typescript theme={null}
import { createClient, REGION_US } from "@relevanceai/sdk";
createClient({
apiKey: process.env.RELEVANCE_API_KEY,
region: REGION_US,
project: process.env.RELEVANCE_PROJECT_ID,
});
```
`createClient` stores the client as the default singleton, so you don't need to pass it around. Replace `REGION_US` with `REGION_EU` or `REGION_AU` to match your project.
```typescript theme={null}
import { Agent } from "@relevanceai/sdk";
const agent = await Agent.get("");
const task = await agent.sendMessage("What can you help me with?");
```
`sendMessage` returns a `Task` immediately — it doesn't wait for the agent to respond. The agent ID is visible on the agent's page in the dashboard.
```typescript theme={null}
task.addEventListener("message", ({ detail: { message } }) => {
if (message.isAgent()) {
console.log("Agent:", message.text);
}
});
```
Messages arrive through the `"message"` event on the task. Use the type guards (`isAgent`, `isTool`, `isTyping`, and so on) to handle each kind. When the conversation is done, call `task.unsubscribe()` to release the connection.
## What to read next
Use embed keys for browser apps, or API keys for server code.
Understand task status, events, and cleanup.
Handle tool calls, user messages, attachments, and errors.
Render responses as the agent types them.
# Streaming
Source: https://relevanceai.com/docs/sdk/streaming
Render thinking and typing tokens in real time as the agent produces them.
Streaming delivers incremental thinking and typing tokens as the agent processes — letting your application render live feedback before the final response is complete.
## What streaming provides
As an agent works through a request, it produces two kinds of incremental output:
The agent's intermediate reasoning and planning. Useful for progress indicators or debug views.
The agent's response text as it's being generated. Enables character-by-character or chunk-by-chunk rendering.
Both arrive through the standard `"message"` event on a task, alongside the final polled messages.
## Streaming is automatic
The SDK enables and manages streaming for you. There's no configuration step. When a task is subscribed to (via `addEventListener`), the SDK opens a streaming connection if one is available. Token refresh, reconnection, and cleanup are handled internally.
Streaming works across every supported runtime: browsers, Node.js, Deno, Bun, and Cloudflare Workers.
## Listen for streaming events
Streaming messages arrive through the same `"message"` event used for every other message type. Identify them with the `isThinking` and `isTyping` type guards:
```typescript theme={null}
task.addEventListener("message", ({ detail }) => {
const { message } = detail;
if (message.isThinking()) {
console.log("[thinking]", message.text);
}
if (message.isTyping()) {
process.stdout.write(message.text);
}
});
```
Both `ThinkingMessage` and `TypingMessage` expose a `text` property with the incremental content.
## Build a live typing indicator
A common pattern is rendering the agent's response in real time as it's generated. Accumulate typing tokens into a buffer and render them as they arrive:
```typescript theme={null}
let buffer = "";
task.addEventListener("message", ({ detail }) => {
const { message } = detail;
if (message.isTyping()) {
buffer += message.text;
renderPartialResponse(buffer);
}
if (message.isAgent()) {
// Final response arrived; replace the buffer
buffer = "";
renderFinalResponse(message.text);
}
});
```
The typing tokens represent the same content that will eventually appear in the final `AgentMessage`. Once the final message arrives, replace the accumulated buffer with the complete response.
## Thinking vs. typing
Thinking and typing are different phases of the agent's processing.
* **Thinking** happens while the agent reasons about what to do next, which tools to call, or how to structure its response. You might show this as a "thinking..." indicator, display it in a debug panel, or ignore it entirely.
* **Typing** happens as the agent generates its actual response text. This is the content that ends up in the final agent message.
```typescript theme={null}
task.addEventListener("message", ({ detail }) => {
const { message } = detail;
if (message.isThinking()) {
showThinkingIndicator(message.text);
}
if (message.isTyping()) {
appendToResponse(message.text);
}
});
```
## Streaming lifecycle
Streaming follows the same lifecycle as task subscriptions:
* **Start** — when the first event listener is added to a task, the SDK subscribes and opens a streaming connection if available.
* **Active** — thinking and typing tokens arrive through the `"message"` event as the agent processes. Connection health and token refresh are managed transparently.
* **End** — when `task.unsubscribe()` is called, the streaming connection is closed along with the polling loop.
There's no separate subscription or connect step for streaming. It's part of the standard task subscription and follows the same cleanup rules described in [Tasks](/docs/sdk/tasks).
# Tasks
Source: https://relevanceai.com/docs/sdk/tasks
Task lifecycle, status model, events, subscriptions, and cleanup.
A task represents a single conversation thread between your application and an agent or workforce. When you send a message, the SDK returns a `Task` — everything that happens next flows through it.
## The shape of a task
```typescript theme={null}
const task = await agent.sendMessage("Hello");
console.log(task.id); // unique task identifier
console.log(task.name); // display title
console.log(task.status); // current status
```
## Task status
Every task has a `status` field. The SDK simplifies the platform's internal states into a concise set:
| Status | Meaning |
| ------------- | ---------------------------------- |
| `not-started` | Created locally, not yet sent |
| `idle` | Agent is idle, awaiting input |
| `paused` | Execution has been paused |
| `queued` | Waiting to start (capacity, queue) |
| `running` | Agent is actively processing |
| `action` | Requires approval or has escalated |
| `completed` | Finished successfully |
| `cancelled` | Cancelled before completion |
| `error` | Encountered a failure |
The platform uses more granular internal states. The SDK maps them to the statuses above so application code doesn't need to handle every variation.
| Platform state | SDK status |
| -------------------------- | ----------- |
| `idle` | `idle` |
| `starting-up` | `queued` |
| `waiting-for-capacity` | `queued` |
| `queued-for-approval` | `queued` |
| `queued-for-rerun` | `queued` |
| `running` | `running` |
| `pending-approval` | `action` |
| `escalated` | `action` |
| `paused` | `paused` |
| `completed` | `completed` |
| `cancelled` | `cancelled` |
| `timed-out` | `error` |
| `unrecoverable` | `error` |
| `errored-pending-approval` | `error` |
For workforce state mappings, see [Workforces](/docs/sdk/workforces).
## Is the task still active?
`isRunning` returns `true` when the status is `queued` or `running`:
```typescript theme={null}
if (task.isRunning()) {
console.log("Agent is working...");
}
```
## Fetch message history
Retrieve every message on a task with `getMessages`:
```typescript theme={null}
const messages = await task.getMessages();
```
To fetch only messages after a specific point, pass an `after` date:
```typescript theme={null}
const recent = await task.getMessages({
after: new Date("2025-06-01T00:00:00Z"),
});
```
Each message is one of the types described in [Messaging](/docs/sdk/messaging). The same type guard methods (`isAgent`, `isTool`, and so on) work here.
## Listen for events
Tasks emit events in real time as the conversation progresses. There are three event types:
| Event | When it fires |
| ----------- | ------------------------------------ |
| `"message"` | A new message is received |
| `"error"` | An agent error occurs |
| `"update"` | Task metadata changes (e.g., status) |
### The "message" event
The primary event for agent responses, tool executions, and streaming content:
```typescript theme={null}
task.addEventListener("message", ({ detail }) => {
const { message } = detail;
if (message.isAgent()) {
console.log("Agent:", message.text);
}
});
```
For the full set of message types and their fields, see [Messaging](/docs/sdk/messaging).
### The "error" event
Fires when the agent runs into a failure:
```typescript theme={null}
task.addEventListener("error", ({ detail }) => {
console.error(detail.message.lastError);
});
```
### The "update" event
Fires when the task's metadata changes, such as a status transition:
```typescript theme={null}
task.addEventListener("update", () => {
console.log("New status:", task.status);
});
```
The current SDK has a TypeScript type mismatch on this event — the declared event map key differs from the string dispatched at runtime. The `"update"` string shown above is correct and events fire as expected. If the type checker complains, add `// @ts-expect-error` above the line until the upstream fix lands.
## Subscriptions are automatic
The first call to `addEventListener` on a task activates its subscription. There's no need to call `subscribe` manually.
Once subscribed, the SDK keeps the task up to date by polling for new messages and metadata changes, and opens a streaming connection when available to deliver real-time thinking and typing events. See [Streaming](/docs/sdk/streaming) for details.
The SDK manages the polling frequency internally — faster when the task is active, slower when idle. This is transparent to the application.
## Clean up
Always call `unsubscribe` when a task is no longer needed. This stops the polling loop and closes any active connections, freeing network and memory resources.
```typescript theme={null}
task.unsubscribe();
```
Failing to unsubscribe from tasks that have left scope is a common source of resource leaks. In component-based UI frameworks, call `unsubscribe` from the cleanup or teardown handler.
```typescript React theme={null}
useEffect(() => {
const handler = ({ detail }) => {
setMessages((prev) => [...prev, detail.message]);
};
task.addEventListener("message", handler);
return () => {
task.unsubscribe();
};
}, [task]);
```
```typescript Vanilla JavaScript theme={null}
// When navigating away from a conversation view
function teardown() {
task.unsubscribe();
}
```
# Workforces
Source: https://relevanceai.com/docs/sdk/workforces
Trigger multi-agent workforces, continue conversations, and handle handover messages.
A workforce is a team of agents that coordinate to handle complex, multistep tasks through delegation and handover. The platform routes messages to the right agent, and agents can pass work between each other as the task progresses — your application doesn't have to manage the coordination.
## Load a workforce
Fetch a workforce by ID. The workforce ID is available on the workforce's page in the dashboard.
```typescript theme={null}
import { Workforce } from "@relevanceai/sdk";
const workforce = await Workforce.get("");
```
To use a specific client instead of the default singleton:
```typescript theme={null}
const workforce = await Workforce.get("", client);
```
Once loaded, the workforce exposes its metadata:
```typescript theme={null}
console.log(workforce.name); // display name
console.log(workforce.id); // unique identifier
console.log(workforce.region); // deployment region
console.log(workforce.project); // project identifier
```
## Start a workforce task
Send a message with `sendMessage`. This creates a new task and returns it immediately. The workforce begins routing the message to the appropriate agent.
```typescript theme={null}
const task = await workforce.sendMessage(
"Analyze last quarter's sales data and prepare a summary"
);
```
As with agent tasks, `sendMessage` resolves when the message is sent, not when the workforce finishes. Listen for events on the returned task to receive results — see [Tasks](/docs/sdk/tasks).
## Continue a conversation
Pass the existing task to `sendMessage` to add follow-up messages:
```typescript theme={null}
await workforce.sendMessage("Include a regional breakdown", task);
```
Unlike agent tasks, workforce tasks don't support file attachments.
## Retrieve workforce tasks
### A single task
Fetch a specific task by ID:
```typescript theme={null}
const task = await workforce.getTask("");
```
### A list of tasks
Fetch a list of workforce tasks with `getTasks`. Workforce task listing uses cursor-based pagination and supports search:
```typescript theme={null}
const tasks = await workforce.getTasks({
pageSize: 50,
search: "quarterly report",
});
```
To paginate through results, pass the cursor from the previous response:
```typescript theme={null}
const firstPage = await workforce.getTasks({ pageSize: 20 });
// Use the cursor from the response to get the next page
const nextPage = await workforce.getTasks({
pageSize: 20,
cursor: "",
});
```
### Differences from agent task retrieval
Workforce and agent task listings don't support the same options:
| Feature | Agent tasks | Workforce tasks |
| ---------------- | ----------- | --------------- |
| Pagination | Page-based | Cursor-based |
| Sort options | Supported | Not supported |
| Status filtering | Supported | Not supported |
| Search | Supported | Supported |
| File attachments | Supported | Not supported |
## Workforce task states
Workforce tasks use a different set of internal states than agent tasks. The SDK maps them to the same simplified statuses used elsewhere.
| Workforce state | SDK status |
| -------------------------- | ----------- |
| `running` | `running` |
| `completed` | `completed` |
| `execution-limit-reached` | `error` |
| `pending-approval` | `action` |
| `escalated` | `action` |
| `errored-pending-approval` | `error` |
The `action` status means the workforce needs human intervention — either through an approval step or because the task was escalated.
## Workforce-specific messages
Workforce tasks emit two message types that don't appear in agent tasks.
### Agent run messages
A `WorkforceAgentMessage` (type `"workforce-agent-run"`) indicates that an agent within the workforce is executing a subtask. These messages include details about which agent is running and the current state of its work.
```typescript theme={null}
task.addEventListener("message", ({ detail }) => {
const { message } = detail;
if (message.type === "workforce-agent-run") {
// An agent in the workforce is working
}
});
```
### Handover messages
A `WorkforceAgentHandoverMessage` (type `"workforce-agent-handover"`) indicates that work is being delegated from one agent to another. The message includes the trigger message that started the handover and details about the receiving agent.
```typescript theme={null}
task.addEventListener("message", ({ detail }) => {
const { message } = detail;
if (message.type === "workforce-agent-handover") {
// Work is being handed to another agent
}
});
```
These messages appear interleaved with standard agent and tool messages in the event stream. For full details on all message types and type guards, see [Messaging](/docs/sdk/messaging).