Skip to main content

​
Other Platforms

Beyond the main channels, you can connect your agent to virtually any platform using webhooks or the REST API.

​
Discord

Deploy your agent as a Discord bot for community servers.

​
Setup

  1. Go to Discord Developer Portal
  2. Click New Application and name it
  3. Go to Bot > Add Bot
  4. Copy the Bot Token
  5. Under Privileged Gateway Intents, enable:
    • Message Content Intent
    • Server Members Intent
  6. Go to OAuth2 > URL Generator:
    • Scopes: bot
    • Bot Permissions: Send Messages, Read Message History
  7. Copy the generated URL and open it to invite the bot to your server

​
Configure in thinnestAI

  1. Open your agent > Deploy tab
  2. Select Discord
  3. Enter:
    • Bot Token — From Discord Developer Portal
    • Application ID — From General Information
  4. Click Save & Enable

​
Set Webhook

Configure the webhook URL in your Discord bot’s interactions settings: 
https://api.thinnest.ai/webhooks/discord/YOUR_AGENT_ID

​
How It Works

  • Users @mention the bot or DM it
  • The bot responds in the same channel/DM
  • Each user gets their own conversation session
  • Leads are automatically captured with Discord user ID

​
Mobile Apps

​
React Native

import { useState } from 'react';

const AGENT_ID = 'agent_abc123';
const API_KEY = 'ak_your_key';

export function useAgent() {
  const [messages, setMessages] = useState([]);
  const [sessionId] = useState(() => `mobile_${Date.now()}`);

  const sendMessage = async (text) => {
    setMessages(prev => [...prev, { role: 'user', content: text }]);

    const response = await fetch(`https://api.thinnest.ai/v1/agents/${AGENT_ID}/chat`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        message: text,
        session_id: sessionId,
      }),
    });

    const data = await response.json();
    setMessages(prev => [...prev, { role: 'assistant', content: data.response }]);
  };

  return { messages, sendMessage };
}

​
Flutter

import 'dart:convert';
import 'package:http/http.dart' as http;

class AgentService {
  static const _agentId = 'agent_abc123';
  static const _apiKey = 'ak_your_key';
  final String sessionId;

  AgentService() : sessionId = 'flutter_${DateTime.now().millisecondsSinceEpoch}';

  Future<String> sendMessage(String message) async {
    final response = await http.post(
      Uri.parse('https://api.thinnest.ai/v1/agents/$_agentId/chat'),
      headers: {
        'Authorization': 'Bearer $_apiKey',
        'Content-Type': 'application/json',
      },
      body: jsonEncode({
        'message': message,
        'session_id': sessionId,
      }),
    );

    final data = jsonDecode(response.body);
    return data['response'];
  }
}

​
Swift (iOS)

import Foundation

struct AgentService {
    static let agentId = "agent_abc123"
    static let apiKey = "ak_your_key"
    let sessionId = "ios_\(Int(Date().timeIntervalSince1970))"

    func sendMessage(_ message: String) async throws -> String {
        let url = URL(string: "https://api.thinnest.ai/v1/agents/\(Self.agentId)/chat")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("Bearer \(Self.apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONEncoder().encode([
            "message": message,
            "session_id": sessionId,
        ])

        let (data, _) = try await URLSession.shared.data(for: request)
        let response = try JSONDecoder().decode([String: String].self, from: data)
        return response["response"] ?? ""
    }
}

​
Custom Webhooks

Build your own integration by forwarding messages to the REST API: 
# Example: Custom webhook handler
from fastapi import FastAPI
import httpx

app = FastAPI()
AGENT_ID = "agent_abc123"
API_KEY = "ak_your_key"

@app.post("/my-webhook")
async def handle_webhook(request: dict):
    user_message = request["message"]
    user_id = request["user_id"]

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"https://api.thinnest.ai/v1/agents/{AGENT_ID}/chat",
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={
                "message": user_message,
                "session_id": f"custom_{user_id}",
            },
        )

    return {"reply": response.json()["response"]}

​
Shopify

Add the chat widget to your Shopify store:
  1. Go to Online Store > Themes > Edit code
  2. Open theme.liquid
  3. Before the closing </body> tag, add:
<script
  src="https://app.thinnest.ai/embed.js"
  data-agent-id="YOUR_AGENT_ID"
  data-theme="light"
  data-welcome-message="Hi! Need help finding something?"
  async
></script>
  1. Save

​
Webflow

  1. Go to Project Settings > Custom Code
  2. In the Footer Code section, add the embed script
  3. Publish your site

​
Squarespace

  1. Go to Settings > Advanced > Code Injection
  2. In the Footer section, add the embed script
  3. Save

​
Wix

  1. Go to your site editor
  2. Click Add > Embed > Custom Embeds > Embed a Widget
  3. Click Enter Code and paste the embed script
  4. Position the widget and publish

​
Bubble.io

  1. Add an HTML element to your page
  2. Paste the embed script in the element’s HTML content
  3. Preview and deploy

​
Any Platform

The REST API works with any platform that can make HTTP requests. The general pattern is:
  1. Receive a message from your platform
  2. Forward it to POST /v1/agents/{agent_id}/chat with your API key
  3. Return the response to the user
This works for:
  • Email bots (via SendGrid, Mailgun webhooks)
  • SMS (via Twilio, directly — not WhatsApp)
  • Voice assistants (via speech-to-text + text-to-speech)
  • IoT devices
  • Game chat systems
  • Internal tools and dashboards