Custom Integrations

Build Custom Integrations

Need to connect to a tool that’s not in our library? Build your own custom integration using our API connector, webhooks, or SDK.

No Coding Required: Most custom integrations can be built using our visual API connector without writing any code.

API Connector

Connect Any REST API

Our visual API connector lets you integrate any REST API in minutes:

Add API Details

Enter the base URL, authentication method, and API documentation URL.

Define Actions

Create actions by specifying endpoints, methods (GET, POST, etc.), and parameters.

Test Connection

Test your integration with real API calls to verify it works correctly.

Deploy

Make the integration available to your AI agents with one click.

Supported Authentication Methods

API Key

Simple API key authentication in headers or query parameters

OAuth 2.0

Full OAuth 2.0 flow with automatic token refresh

Basic Auth

Username and password authentication

Bearer Token

JWT and bearer token authentication

Example: Custom CRM Integration

{
  "name": "Custom CRM",
  "baseUrl": "https://api.customcrm.com/v1",
  "auth": {
    "type": "api_key",
    "location": "header",
    "key": "X-API-Key"
  },
  "actions": [
    {
      "name": "Create Contact",
      "method": "POST",
      "endpoint": "/contacts",
      "parameters": {
        "name": "string",
        "email": "string",
        "phone": "string"
      }
    },
    {
      "name": "Get Contact",
      "method": "GET",
      "endpoint": "/contacts/{id}",
      "parameters": {
        "id": "string"
      }
    }
  ]
}

Webhooks

Receive Real-Time Events

Webhooks allow external services to send data to LinkAI in real-time:

Create Webhook

Generate a unique webhook URL in your LinkAI dashboard.

Configure Source

Add the webhook URL to your external service (e.g., Stripe, GitHub).

Define Triggers

Specify what should happen when LinkAI receives webhook data.

Test & Deploy

Send test webhooks to verify everything works correctly.

Webhook Security

Signature Verification

Verify webhook signatures to ensure requests come from legitimate sources. Supports HMAC-SHA256 and other signing methods.

IP Allowlisting

Restrict webhook access to specific IP addresses for added security.

Rate Limiting

Automatic rate limiting prevents abuse and protects your system.

Retry Logic

Failed webhooks are automatically retried with exponential backoff.

Example: Stripe Webhook

// Webhook URL: https://api.linkai.com/webhooks/your-unique-id

// Stripe sends this when a payment succeeds
{
  "type": "payment_intent.succeeded",
  "data": {
    "object": {
      "id": "pi_123456",
      "amount": 5000,
      "currency": "usd",
      "customer": "cus_123456"
    }
  }
}

// LinkAI can trigger actions like:
// - Send confirmation email
// - Update CRM
// - Notify team in Slack
// - Create invoice in QuickBooks

SDK Integration

For Developers

Build advanced integrations using our Python or TypeScript SDK:

Python
TypeScript

from linkai import Integration, Action

# Define custom integration
class CustomToolIntegration(Integration):
    name = "Custom Tool"
    auth_type = "oauth2"
    
    @Action(name="fetch_data")
    def fetch_data(self, user_id: str):
        """Fetch data from custom tool"""
        response = self.client.get(f"/users/{user_id}")
        return response.json()
    
    @Action(name="create_record")
    def create_record(self, data: dict):
        """Create a new record"""
        response = self.client.post("/records", json=data)
        return response.json()

# Register integration
integration = CustomToolIntegration()
integration.register()

import { Integration, Action } from '@linkai/sdk';

// Define custom integration
class CustomToolIntegration extends Integration {
  name = 'Custom Tool';
  authType = 'oauth2';
  
  @Action({ name: 'fetch_data' })
  async fetchData(userId: string) {
    const response = await this.client.get(`/users/${userId}`);
    return response.data;
  }
  
  @Action({ name: 'create_record' })
  async createRecord(data: object) {
    const response = await this.client.post('/records', data);
    return response.data;
  }
}

// Register integration
const integration = new CustomToolIntegration();
await integration.register();

SDK Features

Type Safety

Full TypeScript support with type definitions for all methods

Auth Handling

Built-in OAuth 2.0, API key, and token management

Auto-Retry

Automatic retry logic with exponential backoff

Observability

Built-in logging, tracing, and error reporting

Integration Best Practices

Security

Use Environment Variables

Never hardcode API keys or secrets. Use environment variables or secure credential storage.

Implement Rate Limiting

Respect API rate limits to avoid being blocked. Implement exponential backoff for retries.

Validate Input

Always validate and sanitize user input before sending to external APIs.

Handle Errors Gracefully

Implement proper error handling and provide meaningful error messages.

Performance

Cache Responses

Cache API responses when appropriate to reduce latency and API calls.

Use Batch Operations

When possible, batch multiple operations into single API calls.

Implement Timeouts

Set reasonable timeouts to prevent hanging requests.

Monitor Performance

Track API response times and error rates to identify issues early.

Reliability

Implement Idempotency

Ensure operations can be safely retried without side effects.

Handle Partial Failures

Design integrations to handle partial failures gracefully.

Log Everything

Comprehensive logging helps debug issues in production.

Test Thoroughly

Test with real API calls, not just mocks, before deploying.

Testing Your Integration

Test Environment

LinkAI provides a sandbox environment for testing:

Create Test Integration

Build your integration in the test environment first.

Use Test Credentials

Use sandbox/test API keys from the external service.

Run Test Cases

Test all actions with various inputs and edge cases.

Monitor Logs

Review logs to ensure everything works as expected.

Deploy to Production

Once tested, deploy to production with real credentials.

Common Test Cases

Authentication - Verify credentials work correctly
Success Cases - Test normal operation with valid inputs
Error Handling - Test with invalid inputs and API errors
Rate Limiting - Verify rate limit handling works
Timeouts - Test behavior with slow/unresponsive APIs
Retries - Verify retry logic works correctly

Private Integrations

Organization-Only Access

Build integrations visible only to your organization:

Private by Default

Custom integrations are private to your organization unless you choose to share them.

Team Access

Control which team members can use and manage the integration.

Credential Isolation

Each user can connect with their own credentials for user-specific access.

Audit Trails

Complete logging of who uses the integration and when.

Publishing Integrations

If you build a useful integration, consider sharing it:

Submit for Review

Submit your integration through the dashboard for review.

Security Audit

Our team reviews the integration for security and best practices.

Documentation

We help you create documentation for other users.

Publication

Once approved, your integration is available to all LinkAI users.

Benefits of publishing:

Help the community
Get feedback and contributions
Build your reputation
Potential revenue sharing (coming soon)

Integration Limits

By Plan

Free - 2 custom integrations
Starter - 5 custom integrations
Growth - 20 custom integrations
Scale - Unlimited custom integrations
Agency - Unlimited + white-label

API Limits

Rate Limits - Respect external API rate limits
Timeout - 30 seconds per API call
Payload Size - 10MB max per request
Concurrent Requests - 100 per integration

Support

Need help building your integration?

Documentation

Comprehensive guides and API reference

Community

Get help from other developers

Support

Contact our integration specialists

Examples

Browse example integrations

Get Started

Build Your First Integration

Start building custom integrations today

Documentation Index

​Build Custom Integrations

​API Connector

​Connect Any REST API

​Supported Authentication Methods

API Key

OAuth 2.0

Basic Auth

Bearer Token

​Example: Custom CRM Integration

​Webhooks

​Receive Real-Time Events

​Webhook Security

​Example: Stripe Webhook

​SDK Integration

​For Developers

​SDK Features

Type Safety

Auth Handling

Auto-Retry

Observability

​Integration Best Practices

​Security

​Performance

​Reliability

​Testing Your Integration

​Test Environment

​Common Test Cases

​Private Integrations

​Organization-Only Access

Private by Default

Team Access

Credential Isolation

Audit Trails

​Publishing Integrations

​Share with the Community

​Integration Limits

​By Plan

​API Limits

​Support

Documentation

Community

Support

Examples

​Get Started

Build Your First Integration

Build Custom Integrations

API Connector

Connect Any REST API

Supported Authentication Methods

Example: Custom CRM Integration

Webhooks

Receive Real-Time Events

Webhook Security

Example: Stripe Webhook

SDK Integration

For Developers

SDK Features

Integration Best Practices

Security

Performance

Reliability

Testing Your Integration

Test Environment

Common Test Cases

Private Integrations

Organization-Only Access

Publishing Integrations

Share with the Community

Integration Limits

By Plan

API Limits

Support

Get Started