Integrating OpenClaw Rating API Edge with Slack, Discord, and Zapier: A Reusable Integration Package

1. Introduction

Modern SaaS products often need to surface real‑time ratings, sentiment scores, or compliance checks directly inside the collaboration tools that teams already use. OpenClaw’s Rating API Edge delivers a low‑latency, edge‑optimized endpoint for such use‑cases, but wiring it to Slack, Discord, and Zapier can become repetitive if each channel is built from scratch.

This guide walks you through a reusable integration package that abstracts the API call, normalizes responses, and provides adapters for three popular destinations. You’ll receive ready‑to‑run code snippets, a step‑by‑step deployment checklist, and best‑practice recommendations that keep your integration secure, observable, and future‑proof.

2. Overview of OpenClaw Rating API Edge

OpenClaw’s Rating API Edge is a globally distributed HTTP endpoint that evaluates content against a configurable set of rules (e.g., profanity, brand safety, compliance). It returns a JSON payload such as:

{
  "requestId": "abc123",
  "score": 0.87,
  "flags": ["safe"],
  "details": {
    "language": "en",
    "categories": ["politics", "technology"]
  }
}

The API supports POST with a plain‑text body or a structured application/json payload, and it can be secured with API keys or JWTs. For edge performance, the service is hosted on a CDN‑backed compute layer, reducing round‑trip latency to under 30 ms for most regions.

3. Integration Architecture

The reusable package follows a micro‑adapter pattern:

• Core Service: A thin Node.js/TypeScript function that calls the OpenClaw Rating API Edge, handles retries, and normalizes the response.
• Slack Adapter: Formats the normalized payload into a Slack Block Kit message and posts it via an incoming webhook.
• Discord Adapter: Transforms the payload into an embed object and sends it through a Discord webhook.
• Zapier Adapter: Exposes the core service as a Zapier “Trigger” that downstream actions can consume.

All adapters share the same core logic, which lives in a single src/core folder. This eliminates duplication and makes future updates (e.g., adding a new rating rule) a one‑time change.

4. Slack Integration

Slack expects JSON payloads that conform to Block Kit. The adapter builds a concise message that includes the rating score, any flags, and a link back to the source content.

4.1. Create a Slack Incoming Webhook

1. Navigate to Workspace Settings → Apps → Manage → Custom Integrations → Incoming Webhooks.
2. Click Add New Webhook to Workspace and select the channel where ratings should appear.
3. Copy the generated webhook URL; you’ll store it as SLACK_WEBHOOK_URL in the UBOS environment.

4.2. Slack Adapter Code

// src/adapters/slack.ts
import fetch from 'node-fetch';
import { NormalizedRating } from '../core/types';

export async function sendToSlack(rating: NormalizedRating) {
  const payload = {
    blocks: [
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `*OpenClaw Rating* :star: *${(rating.score * 100).toFixed(1)}%*`
        }
      },
      {
        type: 'context',
        elements: rating.flags.map(flag => ({
          type: 'mrkdwn',
          text: `\`${flag}\``
        }))
      },
      {
        type: 'divider'
      },
      {
        type: 'section',
        fields: [
          {
            type: 'mrkdwn',
            text: `*Request ID:*\n${rating.requestId}`
          },
          {
            type: 'mrkdwn',
            text: `*Categories:*\n${rating.details.categories.join(', ')}`
          }
        ]
      }
    ]
  };

  const response = await fetch(process.env.SLACK_WEBHOOK_URL!, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(payload)
  });

  if (!response.ok) {
    throw new Error(`Slack webhook failed: ${response.statusText}`);
  }
}

The function pulls the webhook URL from the environment, builds a Block Kit message, and posts it. Errors are thrown so the core service can retry or log appropriately.

5. Discord Integration

Discord uses webhook embeds to display rich content. The adapter mirrors the Slack message but leverages Discord’s embed fields for a cleaner look.

5.1. Create a Discord Webhook

1. Open your Discord server, go to Server Settings → Integrations → Webhooks.
2. Click New Webhook, assign a channel, and copy the webhook URL.
3. Store the URL as DISCORD_WEBHOOK_URL in the UBOS environment.

5.2. Discord Adapter Code

// src/adapters/discord.ts
import fetch from 'node-fetch';
import { NormalizedRating } from '../core/types';

export async function sendToDiscord(rating: NormalizedRating) {
  const embed = {
    title: 'OpenClaw Rating',
    color: rating.score > 0.8 ? 0x00ff00 : 0xff0000,
    fields: [
      { name: 'Score', value: `${(rating.score * 100).toFixed(1)}%`, inline: true },
      { name: 'Flags', value: rating.flags.join(', ') || 'None', inline: true },
      { name: 'Request ID', value: rating.requestId, inline: false }
    ],
    footer: { text: `Categories: ${rating.details.categories.join(', ')}` }
  };

  const response = await fetch(process.env.DISCORD_WEBHOOK_URL!, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ embeds:  })
  });

  if (!response.ok) {
    throw new Error(`Discord webhook failed: ${response.statusText}`);
  }
}

The embed color changes based on the score, giving a quick visual cue. Like the Slack adapter, any failure bubbles up for retry handling.

6. Zapier Integration

Zapier enables non‑technical users to chain the rating result into thousands of downstream apps (e.g., Google Sheets, Trello). The integration is exposed as a Zapier Trigger that emits the normalized rating payload.

6.1. Create a Zapier CLI App

1. Install the Zapier Platform CLI: npm install -g zapier-platform-cli.
2. Run zapier init openclaw-rating and choose “Node.js” as the runtime.
3. Replace the generated triggers/rating.js with the code below.

6.2. Zapier Trigger Code

// triggers/rating.js
const { fetchRating } = require('../src/core/rating');

module.exports = {
  key: 'rating',
  noun: 'Rating',
  display: {
    label: 'New OpenClaw Rating',
    description: 'Triggers when a new rating is returned from OpenClaw.'
  },
  operation: {
    perform: async (z, bundle) => {
      const rating = await fetchRating(bundle.inputData.text);
      return [rating]; // Zapier expects an array of results
    },
    inputFields: [
      { key: 'text', required: true, type: 'string', label: 'Content to Rate' }
    ],
    sample: {
      requestId: 'sample123',
      score: 0.92,
      flags: ['safe'],
      details: { language: 'en', categories: ['tech'] }
    }
  }
};

The trigger calls the same core fetchRating function used by Slack and Discord, guaranteeing consistent logic across all channels.

7. Code Snippets – Core Service

The heart of the package lives in src/core/rating.ts. It abstracts API authentication, retries, and response normalization.

// src/core/rating.ts
import fetch from 'node-fetch';

export interface NormalizedRating {
  requestId: string;
  score: number; // 0‑1 range
  flags: string[];
  details: {
    language: string;
    categories: string[];
  };
}

/**
 * Calls OpenClaw Rating API Edge and returns a NormalizedRating.
 * @param content - Plain‑text or JSON payload to be evaluated.
 */
export async function fetchRating(content: string): Promise<NormalizedRating> {
  const response = await fetch('https://api.openclaw.io/v1/rate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${process.env.OPENCLAW_API_KEY}`
    },
    body: JSON.stringify({ text: content })
  });

  if (!response.ok) {
    throw new Error(`OpenClaw API error: ${response.statusText}`);
  }

  const raw = await response.json();

  // Normalization step – ensures a stable contract for adapters
  return {
    requestId: raw.requestId,
    score: raw.score,
    flags: raw.flags ?? [],
    details: {
      language: raw.details?.language ?? 'unknown',
      categories: raw.details?.categories ?? []
    }
  };
}

By centralizing the logic, any future change (e.g., switching to a new authentication scheme) requires editing only this file.

8. Deployment Steps

UBOS provides a low‑code “Web App Editor” and a “Workflow Automation Studio” that can host the integration as a serverless function. Follow these steps to get the package live:

1. Clone the repository into your UBOS workspace:

   git clone https://github.com/your-org/openclaw-integration.git

2. Install dependencies:

   npm ci

3. Configure environment variables in the UBOS dashboard:
   • OPENCLAW_API_KEY
   • SLACK_WEBHOOK_URL
   • DISCORD_WEBHOOK_URL
4. Build the project:

   npm run build

5. Deploy as a serverless function using UBOS’s “Deploy” button. The platform automatically provisions an edge‑optimized container.
6. Test each adapter:
   • Send a POST request to /api/rate with sample text.
   • Verify that Slack and Discord channels receive the formatted messages.
   • In Zapier, create a new Zap using the “New OpenClaw Rating” trigger and confirm the payload appears.
7. Enable monitoring via UBOS’s built‑in logging and alerting. Set thresholds for latency (>100 ms) and error rate (>1%).

Once deployed, the integration can be versioned and reused across multiple projects simply by updating the webhook URLs in the environment.

9. Best‑Practice Tips

10. Conclusion

By leveraging a single, reusable package built on the UBOS platform, developers can deliver real‑time OpenClaw ratings to Slack, Discord, and Zapier with less than 200 lines of code. The micro‑adapter architecture guarantees consistency, while UBOS’s serverless edge runtime ensures sub‑100 ms latency worldwide.

Adopt this pattern for any future communication channel—whether it’s Microsoft Teams, Mattermost, or a custom mobile push service—and you’ll keep your integration stack DRY, secure, and easy to monitor.

Ready to start building? Visit the official OpenClaw Rating API documentation for the latest endpoint details, and spin up your first instance on the UBOS hosting page.