# RevCent Third Party Integrations Overview for AI/MCP

AI/MCP-focused overview for Third Party Integrations in RevCent.

This document explains how RevCent **Site Third Party Integrations** and **User Third Party Integrations** work, why they matter, how native integrations are configured, and how ecommerce businesses can still integrate with virtually any third-party system using RevCent Functions and other platform tools when a native integration does not exist.

---

## Core Concept

RevCent has two related but different integration concepts:

```text
Site Third Party Integration = RevCent-native integration definition
User Third Party Integration = merchant/user-connected instance of that native integration
```

A **Site Third Party Integration** is native to RevCent. It defines what RevCent supports directly, what type of integration it is, what credentials are required, and what provider-specific options may need to be configured.

A **User Third Party Integration** is the user’s connected version of that native integration. It stores the user’s configuration, enabled state, saved credentials, and saved options.

Simple model:

```text
RevCent native integration definition
    ↓
User connects their account securely
    ↓
User Third Party Integration is created
    ↓
RevCent features use that user integration
```

Examples of RevCent features that may use User Third Party Integrations:

- Tax Profiles,
- shipping / shipment tracking workflows,
- alternate/offline payment mapping,
- AI Assistants,
- AI Voice Agents,
- RevCent-native workflows that depend on external providers.

---

## Native Integrations vs Custom Integrations

Site Third Party Integrations are **native RevCent integrations**.

They represent third-party providers RevCent knows how to connect to directly.

However, RevCent is not limited only to native Site Third Party Integrations.

A user can implement virtually any third-party integration, even if it is not a native integration, by using RevCent tools such as:

- Functions,
- Function URLs,
- Webhook Functions,
- Account Event Functions,
- Schedule Functions,
- API/AI direct Functions,
- Email Template Functions,
- Payment Profile Functions,
- AI Assistant system tools,
- AI Voice Agent pre-agent Functions,
- Key Values and encrypted values,
- RevCent API / MCP operations.

Recommended rule:

```text
Use native Site/User Third Party Integrations when RevCent provides one.
Use Functions and related RevCent automation tools when a native integration does not exist.
```

Native integrations are preferred when available because RevCent already understands the provider’s credentials/options and can connect that provider to built-in RevCent features.

Functions are the extension layer for custom or non-native systems.

---

## Source Operations

This overview is based on the following RevCent MCP operations:

| Operation | Purpose |
|---|---|
| `GetSiteThirdPartyIntegrations` | Lists native RevCent Site Third Party Integrations available to connect. |
| `GetSiteThirdPartyIntegration` | Retrieves one Site Third Party Integration, including required credentials and options. |
| `GetUserThirdPartyIntegrations` | Lists the user’s connected User Third Party Integrations. |
| `GetUserThirdPartyIntegration` | Retrieves one User Third Party Integration, including saved credentials/options and account-specific option values. |
| `CreateUserThirdPartyIntegration` | Creates a user-connected integration from a native Site Third Party Integration. |
| `EditUserThirdPartyIntegration` | Edits a user-connected integration, including name, description, enabled state, credentials, and options. |
| `CreateSecureForm` | Securely collects sensitive credentials for integrations without exposing secrets in chat/logs. |
| `CreateFunction` / `EditFunction` | Creates or edits custom RevCent Functions for custom/non-native integrations. |

---

## Related Overview Links

| Overview / Guide | Link | Why It Matters |
|---|---|---|
| Functions Overview | `https://revcent.com/documentation/markdown/mcp/operation/OverviewFunction.md` | Explains how Functions can integrate with non-native third-party systems using account events, webhooks, function URLs, schedules, API/AI tools, email-template functions, and payment-profile functions. |
| Tax Overview | `https://revcent.com/documentation/markdown/mcp/operation/OverviewTax.md` | Explains Tax Profiles and why tax integrations must be type `tax`. |
| CreateTaxProfile Guide | `https://revcent.com/documentation/markdown/mcp/operation/CreateTaxProfile.md` | Explains how Tax Profiles require a tax-type User Third Party Integration. |
| Shipping Overview | `https://revcent.com/documentation/markdown/mcp/operation/OverviewShipping.md` | Explains shipment/fulfillment workflows and shipping-related integrations. |
| Shop Overview | `https://revcent.com/documentation/markdown/mcp/operation/OverviewShop.md` | Explains WooCommerce/Third-Party Shops and how RevCent acts as the ecommerce backend. |
| Offline Payment Overview | `https://revcent.com/documentation/markdown/mcp/operation/OverviewOfflinePayment.md` | Explains alternate/offline payment integration context. |
| AI Assistant Overview | `https://revcent.com/documentation/markdown/mcp/operation/OverviewAIAssistant.md` | Explains how AI Assistants can use connected AI integrations and custom Function tools. |
| AI Voice Agent Overview | `https://revcent.com/documentation/markdown/mcp/operation/OverviewAIVoiceAgent.md` | Explains AI Voice integrations and voice agent use cases. |

---

# Site Third Party Integrations

A Site Third Party Integration is a RevCent-native integration that is available for users to connect.

It is not the user’s connected account. It is the RevCent-defined integration template.

A Site Third Party Integration can include:

- ID,
- name,
- description,
- integration type,
- required credential definition,
- required credential fields,
- optional third-party options,
- option fields,
- selectable option behavior,
- remote third-party asset behavior.

Site integrations answer:

```text
What native third-party integrations does RevCent support?
What type of integration is this?
What credentials are required?
What extra options may need to be configured?
```

---

## Site Third Party Integration Types

Site Third Party Integrations have an `integration_type`.

Known integration types:

| Type | Purpose |
|---|---|
| `ai` | Integrations meant for AI use, such as powering AI chat and AI Assistants. |
| `ai_voice` | Integrations meant for AI voice use, such as powering AI Voice Agents. |
| `offline_payment` | Integrations meant for alternate payments such as Sezzle, Afterpay, Affirm, Klarna, Amazon Pay, and similar providers. |
| `tax` | Integrations meant for calculating taxes on purchases. |
| `shipping` | Integrations meant for tracking shipments and pulling shipment updates such as delivery status. |

The `integration_type` determines where the integration can be used.

Examples:

```text
Tax Profile requires a User Third Party Integration whose Site Third Party Integration type is tax.

AI Assistant/AI features require an AI integration where applicable.

AI Voice Agents require an ai_voice integration where applicable.

Offline/alternate payment mapping should use offline_payment integrations where applicable.

Shipping/tracking workflows should use shipping integrations where applicable.
```

Do not use a User Third Party Integration in a feature that expects a different integration type.

---

## GetSiteThirdPartyIntegrations

Use:

```text
GetSiteThirdPartyIntegrations
```

to list native RevCent Site Third Party Integrations.

Input:

```json
{}
```

The response includes site integration objects with fields such as:

- `id`,
- `name`,
- `description`,
- `integration_type`,
- `third_party_credentials`,
- `third_party_options`.

Use this operation when:

- user wants to connect a new provider,
- AI/MCP needs to find available native integrations,
- AI/MCP needs to choose an integration by type,
- AI/MCP needs to find a site integration ID before creating a user integration.

AI/MCP must inspect `integration_type` before choosing an integration.

---

## GetSiteThirdPartyIntegration

Use:

```text
GetSiteThirdPartyIntegration
```

to retrieve one native Site Third Party Integration.

Input:

```json
{
  "site_third_party_integration_id": "SSSSSSSSSSSSSSSSSSSS"
}
```

This is especially important before creating a User Third Party Integration.

Review:

- `integration_type`,
- credential requirements,
- credential field IDs,
- required credential fields,
- option requirements,
- option field IDs,
- remote option behavior.

Important:

```text
The fields and option IDs from the Site Third Party Integration are what AI/MCP uses to correctly configure the User Third Party Integration.
```

Do not invent credential field IDs or option IDs.

---

## Third Party Credentials

Site Third Party Integrations can define:

```text
third_party_credentials
```

This object describes what credentials are required for RevCent to connect to the provider.

It can include:

- credential object ID,
- credential name,
- credential description,
- fields,
- field IDs,
- field names,
- required flags.

These fields are used when creating or modifying User Third Party Integration credentials.

Sensitive credential values should be collected using:

```text
CreateSecureForm
```

Never ask the user to paste secrets into chat.

---

## Third Party Options

Site Third Party Integrations can define:

```text
third_party_options
```

Options represent provider-specific settings that may need to be configured after the user integration is created.

Options can include:

- option ID,
- option name,
- option description,
- required flag,
- fields,
- field IDs,
- field names,
- field type,
- select settings,
- static select options,
- remote third-party assets.

Important schema behavior:

```text
If a Site Third Party Integration has third_party_options, AI/MCP may need to retrieve the User Third Party Integration after creation and then use EditUserThirdPartyIntegration to save the required options.
```

If no `third_party_options` exist, there may be no additional option configuration needed after creation.

---

## Remote Third Party Asset Options

Some option fields may use remote third-party assets.

In those cases:

```text
Credentials must be saved first.
Then GetUserThirdPartyIntegration can retrieve account-specific options from the third party.
Then EditUserThirdPartyIntegration can save the selected option values.
```

Example conceptual flow:

```text
Site integration has option field with remote third-party assets
    ↓
Create Secure Form
    ↓
Create User Third Party Integration with credentials
    ↓
GetUserThirdPartyIntegration
    ↓
RevCent pulls account-specific options from provider
    ↓
User selects correct option
    ↓
EditUserThirdPartyIntegration saves that option
```

AI/MCP should not guess remote asset values.

---

# User Third Party Integrations

A User Third Party Integration is the user’s connected instance of a native Site Third Party Integration.

It can include:

- user integration ID,
- name,
- description,
- enabled state,
- saved credentials,
- saved options,
- associated Site Third Party Integration,
- site integration type,
- site integration options.

User integrations answer:

```text
Which third-party accounts has this RevCent user connected?
Are credentials saved?
Are required options saved?
Is the integration enabled?
Which native site integration does it belong to?
```

User integrations are the IDs that other RevCent operations usually reference.

Example:

```text
CreateTaxProfile.third_party_integration = User Third Party Integration ID
```

not the Site Third Party Integration ID.

---

## GetUserThirdPartyIntegrations

Use:

```text
GetUserThirdPartyIntegrations
```

to list connected User Third Party Integrations.

Input:

```json
{}
```

Use this operation when:

- looking for an existing integration,
- checking whether the user already connected a provider,
- determining whether a tax/shipping/AI/voice/offline payment integration exists,
- deciding whether a new user integration must be created,
- asking the user to choose among multiple integrations of the same type.

AI/MCP should inspect:

```text
site_third_party_integration.integration_type
```

before using a user integration for a feature.

---

## GetUserThirdPartyIntegration

Use:

```text
GetUserThirdPartyIntegration
```

to retrieve one connected User Third Party Integration.

Input:

```json
{
  "user_third_party_integration_id": "UUUUUUUUUUUUUUUUUUUU"
}
```

Use this operation to inspect:

- enabled state,
- saved credentials,
- saved third-party options,
- underlying site integration,
- integration type,
- account-specific remote options,
- whether configuration appears complete.

This is especially important after creating a user integration when the Site Third Party Integration has options that must be configured.

---

## CreateUserThirdPartyIntegration

Use:

```text
CreateUserThirdPartyIntegration
```

to create a user-connected integration from a native Site Third Party Integration.

Required fields:

| Field | Type | Required | Purpose |
|---|---:|---:|---|
| `name` | string | Yes | Unique User Third Party Integration name. |
| `site_third_party_integration` | string | Yes | 20-character Site Third Party Integration ID. |

Optional fields:

| Field | Type | Purpose |
|---|---:|---|
| `description` | string | Human-readable description. |
| `enabled` | boolean | Whether the integration is enabled. |
| `secure_form_id` | string | Secure Form ID containing credentials. |

Example:

```json
{
  "name": "Main Tax Provider",
  "description": "Tax provider integration used for RevCent Tax Profiles.",
  "enabled": true,
  "site_third_party_integration": "SSSSSSSSSSSSSSSSSSSS",
  "secure_form_id": "FFFFFFFFFFFFFFFFFFFF"
}
```

The response includes:

```text
user_third_party_integration_id
```

This returned user integration ID is what downstream RevCent features reference.

---

## Secure Credential Handling

Third-party credentials are sensitive.

AI/MCP clients must not ask users to paste API keys, usernames, passwords, tokens, secrets, private keys, or provider credentials into chat.

Use:

```text
CreateSecureForm
```

for credentials.

For third-party integrations:

```json
{
  "form_source": "third_party_integration",
  "form_source_id": "SSSSSSSSSSSSSSSSSSSS"
}
```

where:

```text
form_source_id = Site Third Party Integration ID
```

Secure Form returns:

- `secure_form_id`,
- `form_url`,
- `completed`,
- `expiration_date_unix`.

Important:

```text
Secure Forms expire after 1 hour.
```

After the user completes the Secure Form, use the `secure_form_id` when creating or editing the User Third Party Integration.

---

## EditUserThirdPartyIntegration

Use:

```text
EditUserThirdPartyIntegration
```

to edit a connected User Third Party Integration.

Required:

| Field | Type | Required | Purpose |
|---|---:|---:|---|
| `user_third_party_integration_id` | string | Yes | 20-character User Third Party Integration ID. |

Editable fields:

| Field | Type | Purpose |
|---|---:|---|
| `name` | string | Rename the integration. |
| `description` | string | Update description. |
| `enabled` | boolean | Enable or disable the integration. |
| `secure_form_id` | string | Provide only when modifying credentials. |
| `third_party_options` | array | Save provider-specific required options. |

Important:

```text
Only include the properties you wish to modify.
```

If only renaming, send only `name`.

If only disabling, send only `enabled`.

If only updating credentials, use a new Secure Form and send `secure_form_id`.

If configuring options, send `third_party_options`.

Do not include fields that should not change.

---

## Editing Third Party Options

Use `EditUserThirdPartyIntegration` with `third_party_options` when the Site Third Party Integration requires options or when the user needs to change configured options.

Example shape:

```json
{
  "user_third_party_integration_id": "UUUUUUUUUUUUUUUUUUUU",
  "third_party_options": [
    {
      "id": "option_id_from_site_integration",
      "fields": [
        {
          "id": "field_id_from_site_integration",
          "value": [
            "selected_or_entered_value"
          ]
        }
      ]
    }
  ]
}
```

Rules:

- use option IDs from the Site Third Party Integration,
- use field IDs from the Site Third Party Integration,
- use values selected from account-specific remote assets when required,
- do not guess IDs,
- retrieve the User Third Party Integration after editing to verify saved options.

---

## Standard Native Integration Setup Workflow

Recommended AI/MCP workflow for native integrations:

```text
1. Ask what the user wants to connect and why.
2. Use GetSiteThirdPartyIntegrations.
3. Find matching Site Third Party Integration.
4. Verify integration_type is correct for the intended feature.
5. Use GetSiteThirdPartyIntegration.
6. Review credential fields and third_party_options.
7. Create Secure Form for credentials.
8. User completes Secure Form.
9. Call CreateUserThirdPartyIntegration.
10. Store returned user_third_party_integration_id.
11. Use GetUserThirdPartyIntegration to inspect saved credentials/options.
12. If required options exist, select/configure them.
13. Call EditUserThirdPartyIntegration with third_party_options.
14. Use GetUserThirdPartyIntegration again to verify.
15. Use the user integration ID in the relevant RevCent feature.
```

---

## Common Native Integration Flows

### Tax Integration Flow

```text
GetSiteThirdPartyIntegrations
    ↓
Choose integration_type = tax
    ↓
Create Secure Form
    ↓
CreateUserThirdPartyIntegration
    ↓
Configure options if required
    ↓
CreateTaxProfile with third_party_integration = user_third_party_integration_id
```

### Shipping Integration Flow

```text
GetSiteThirdPartyIntegrations
    ↓
Choose integration_type = shipping
    ↓
Create Secure Form
    ↓
CreateUserThirdPartyIntegration
    ↓
Configure options if required
    ↓
Use integration in shipping/tracking-related workflows where applicable
```

### Offline Payment Integration Flow

```text
GetSiteThirdPartyIntegrations
    ↓
Choose integration_type = offline_payment
    ↓
Create Secure Form
    ↓
CreateUserThirdPartyIntegration
    ↓
Configure options if required
    ↓
Map alternate/offline payment methods to the integration where applicable
```

### AI Integration Flow

```text
GetSiteThirdPartyIntegrations
    ↓
Choose integration_type = ai
    ↓
Create Secure Form
    ↓
CreateUserThirdPartyIntegration
    ↓
Configure options if required
    ↓
Use integration for AI Assistants / AI features where applicable
```

### AI Voice Integration Flow

```text
GetSiteThirdPartyIntegrations
    ↓
Choose integration_type = ai_voice
    ↓
Create Secure Form
    ↓
CreateUserThirdPartyIntegration
    ↓
Configure options if required
    ↓
Use integration for AI Voice Agents where applicable
```

---

# Non-Native Third Party Integrations With Functions

Not every third-party provider needs to be a native Site Third Party Integration.

If RevCent has a native integration:

```text
Use Site Third Party Integration + User Third Party Integration.
```

If RevCent does not have a native integration:

```text
Use Functions and RevCent API/MCP tools.
```

A non-native integration can often be implemented with Functions if the third-party system supports APIs, webhooks, or HTTP callbacks.

Examples:

| Need | RevCent Function Pattern |
|---|---|
| Send Sale to external CRM | Account Event Function on sale created. |
| Receive webhook from fulfillment partner | Webhook Function. |
| Create custom lookup endpoint | Function URL. |
| Run nightly sync to external system | Schedule Function. |
| Add custom Email Template data | Email Template Function. |
| Add custom AI Assistant tool | API/AI Function triggered by AI tool call. |
| Filter AI Voice Agent calls | Filter Function returning `pass` or `fail`. |
| Add custom payment routing logic | Payment Profile Function. |
| Receive status updates from non-native provider | Webhook Function + API/MCP updates. |
| Send data to Slack/Teams/CRM/helpdesk | Account Event Function or Schedule Function. |

This is how RevCent supports virtually any third-party system even when no native integration exists.

---

## Functions as the Universal Extension Layer

RevCent Functions allow custom JavaScript to run inside RevCent.

Functions can:

- react to ecommerce events,
- send data to third-party systems,
- receive data from external systems,
- generate custom Email Template data,
- add AI Assistant and AI Voice Agent logic,
- run scheduled jobs,
- control payment profile logic,
- create custom URL endpoints,
- create webhook receivers,
- store/use encrypted values,
- read/update Key Values,
- make outbound internet requests.

Supported trigger categories include:

| Trigger | Use Case |
|---|---|
| `account_event` | Run when RevCent events occur, such as sale, subscription, shipment, refund, fraud, tax, or chargeback events. |
| `schedule` | Run recurring jobs. |
| `function_url` | Create a public endpoint that returns a Function response. |
| `webhook` | Receive third-party POST webhooks. |
| `email_template` | Generate `custom_data` for Email Templates. |
| `api_direct` / API/AI | Trigger directly by API/MCP or AI. |
| `payment_profile` | Run logic during payment flows. |

Use Functions when the user’s desired third-party is not available as a native Site Third Party Integration.

---

## How to Decide: Native Integration or Function

| Question | Recommendation |
|---|---|
| Does RevCent have a native Site Third Party Integration for this provider? | Use native Site/User Third Party Integration. |
| Does the RevCent feature require a typed integration, such as `tax`, `shipping`, `ai`, `ai_voice`, or `offline_payment`? | Use a User Third Party Integration with the correct underlying `integration_type`. |
| Is the provider not native but has an API? | Use Functions to call the API. |
| Is the provider not native but sends webhooks? | Use a Webhook Function. |
| Does the user need a custom endpoint? | Use a Function URL. |
| Does the user need scheduled sync/reporting? | Use a Schedule Function. |
| Does AI need a safe custom action? | Use an API/AI Function as an AI tool. |
| Does payment flow need custom logic? | Use a Payment Profile Function. |
| Does email need custom data from a non-native provider? | Use an Email Template Function. |

---

## Security Guidance

Third-party integrations often require sensitive credentials.

AI/MCP clients must follow these rules:

- do not collect secrets in chat,
- use Secure Form for native User Third Party Integration credentials,
- use encrypted values or secure credential patterns for Functions,
- do not log secrets,
- do not echo secrets back to the user,
- validate inbound webhooks,
- verify signatures when available,
- check shared secrets or headers when using public endpoints,
- restrict sensitive Function behavior,
- avoid returning sensitive data from public Function URLs,
- use idempotency for inbound webhook processing,
- avoid duplicate side effects from repeated webhook events.

For Secure Forms:

```text
CreateSecureForm expires after 1 hour.
```

Make sure the user completes the form before using the `secure_form_id`.

---

## AI/MCP Operation Selection Guide

| User Intent | Correct Operation / Tool |
|---|---|
| See native integrations RevCent supports | `GetSiteThirdPartyIntegrations` |
| Inspect one native integration’s requirements | `GetSiteThirdPartyIntegration` |
| See connected user integrations | `GetUserThirdPartyIntegrations` |
| Inspect one connected user integration | `GetUserThirdPartyIntegration` |
| Connect a native third-party provider | `CreateUserThirdPartyIntegration` |
| Update connected integration settings | `EditUserThirdPartyIntegration` |
| Save credentials securely | `CreateSecureForm` |
| Configure required provider options | `EditUserThirdPartyIntegration` |
| Build non-native integration | `CreateFunction` / `EditFunction` |
| Receive webhook from non-native provider | Webhook Function |
| Send RevCent event to external system | Account Event Function |
| Build custom endpoint | Function URL |
| Add custom AI tool/action | API/AI Function |
| Generate custom email data | Email Template Function |
| Run recurring sync/report | Schedule Function |

---

## Best Practices

1. Use native Site/User Third Party Integrations when available.
2. Always verify `integration_type` before using a User Third Party Integration in a feature.
3. Use `GetSiteThirdPartyIntegration` before creating a User Third Party Integration.
4. Use Secure Form for native integration credentials.
5. Never ask the user to paste API keys, tokens, passwords, or secrets into chat.
6. After creating a User Third Party Integration, retrieve it with `GetUserThirdPartyIntegration`.
7. Configure required `third_party_options` with `EditUserThirdPartyIntegration`.
8. Do not guess option IDs, field IDs, or remote asset values.
9. Use clear names and descriptions for user integrations.
10. Disable integrations while testing when appropriate.
11. Use Functions for non-native third-party systems.
12. Use Function URL/webhook security for public endpoints.
13. Use account-event Functions instead of polling when possible.
14. Use BigQuery for reporting and metrics, not integration list operations.
15. Document which RevCent feature uses each integration.

---

## Common Mistakes to Avoid

Do not:

- confuse Site Third Party Integration ID with User Third Party Integration ID,
- use a Site Third Party Integration ID where a User Third Party Integration ID is required,
- use the wrong `integration_type`,
- create a Tax Profile with a non-tax integration,
- configure AI Voice Agents with a non-voice integration where voice integration is required,
- skip required third-party options,
- guess remote option values before credentials are saved,
- ask users to paste credentials into chat,
- fail to retrieve the user integration after creation,
- enable a partially configured integration,
- assume RevCent cannot integrate with a provider just because there is no native Site Third Party Integration,
- build custom integrations without webhook/API security,
- use list endpoints for reporting or metrics.

---

## Example: Tax User Integration Before Tax Profile

Correct flow:

```text
GetUserThirdPartyIntegrations
    ↓
No existing tax integration found
    ↓
GetSiteThirdPartyIntegrations
    ↓
Choose site integration where integration_type = tax
    ↓
GetSiteThirdPartyIntegration
    ↓
CreateSecureForm
    ↓
User completes credentials
    ↓
CreateUserThirdPartyIntegration
    ↓
GetUserThirdPartyIntegration
    ↓
Configure options if required
    ↓
CreateTaxProfile with user_third_party_integration_id
```

Key rule:

```text
CreateTaxProfile.third_party_integration expects a User Third Party Integration ID, not a Site Third Party Integration ID.
```

---

## Example: Non-Native CRM Integration With Functions

If the user wants to send new customers or sales to a CRM that is not a native RevCent integration:

```text
Create Function
    trigger = account_event
    event = customer.created or sale.created.success
    ↓
Function validates event data
    ↓
Function sends formatted payload to CRM API
    ↓
Function stores response / creates note / updates metadata if needed
```

This avoids the need for a native Site Third Party Integration while still allowing the business to connect RevCent to its CRM.

---

## Example: Non-Native Fulfillment Webhook Receiver

If a fulfillment provider sends shipment status updates but is not native to RevCent:

```text
Create Function
    trigger = webhook
    ↓
Provider POSTs status update to Function webhook URL
    ↓
Function validates signature/shared secret
    ↓
Function maps provider shipment ID to RevCent shipment
    ↓
Function updates RevCent or triggers appropriate MCP/API operation
```

Use idempotency to avoid duplicate status processing.

---

## Example: AI Tool for Custom Third-Party Lookup

If an AI Assistant needs to look up customer loyalty points in a non-native system:

```text
Create Function
    trigger = api_direct / AI
    custom argument = customer_email
    ↓
AI Assistant calls Function as a safe tool
    ↓
Function calls loyalty provider API
    ↓
Function returns safe JSON summary
    ↓
AI Assistant uses result in workflow
```

This makes the third-party system available to AI without exposing arbitrary API access.

---

## Final AI/MCP Instruction

Site Third Party Integrations are RevCent-native integration definitions. They define the provider, integration type, credential requirements, and option requirements.

User Third Party Integrations are the merchant/user-connected instances of those native integrations. They contain saved credentials, saved options, enabled state, and the User Third Party Integration ID used by other RevCent features.

Use native Site/User Third Party Integrations when RevCent supports the provider directly. Always verify the `integration_type`, collect credentials through Secure Form, and configure required options.

If RevCent does not have a native Site Third Party Integration for a provider, the user can still integrate with virtually any third-party system by using RevCent Functions, webhooks, Function URLs, scheduled jobs, API/AI Functions, Email Template Functions, Payment Profile Functions, Key Values, and RevCent API/MCP operations.


---
Document Parent Directory
* [Operations](https://revcent.com/documentation/markdown/mcp/operation/index.md) - AI/MCP details and overviews for operations available within the RevCent MCP.