FastComments JavaScript/TypeScript SDK

This is the official JavaScript/TypeScript SDK for FastComments.

Manage comments, users, SSO, and moderation from Node.js or the browser.

Repository

AI coding agents

Give your coding agent the FastComments context it needs - widgets, configuration, Secure SSO, the REST API, and the SDKs:

npx skills add fastcomments/skills

Works with Claude Code, Codex, Cursor, Copilot, Gemini, and every other agent the skills CLI supports.

Installation

npm install fastcomments-sdk

API Documentation

Full API reference: docs/api/README.md

Browser vs Server Compatibility

This SDK uses dual entry points to ensure optimal compatibility and prevent runtime errors:

fastcomments-sdk/browser - Browser-safe version with native fetch
fastcomments-sdk/server - Full Node.js version with SSO support
fastcomments-sdk (default) - Types only, safe to import anywhere

Usage

This SDK provides separate entry points for browser and server environments to ensure optimal compatibility and security:

Browser Usage (Client-Side)

For browser/frontend applications, use the browser-safe export that excludes Node.js dependencies:

// Browser-safe import (no Node.js dependencies)
import { createFastCommentsBrowserSDK } from 'fastcomments-sdk/browser';

// Create browser SDK instance
const sdk = createFastCommentsBrowserSDK({
  basePath: 'https://fastcomments.com' // optional, defaults to https://fastcomments.com
});

// Use public APIs (no API key needed - safe for browsers)
const comments = await sdk.publicApi.getCommentsPublic({ 
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

Server Usage (Node.js)

For server/backend applications, use the full SDK with SSO and authentication features:

// Server-side import (includes SSO and designed to work with NodeJS)
import { createFastCommentsSDK } from 'fastcomments-sdk/server';

// Create server SDK instance
const sdk = createFastCommentsSDK({
  apiKey: 'your-api-key', // Keep this secret on the server!
  basePath: 'https://fastcomments.com' // optional, defaults to https://fastcomments.com
});

// Use secured APIs with your API key
const comments = await sdk.defaultApi.getComments({ 
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

Types Only Import

If you only need TypeScript types (no runtime code), use the default import:

// Types only (no runtime dependencies - safe everywhere)
import type { 
  PublicComment, 
  CreateCommentParams, 
  GetCommentsPublic200Response 
} from 'fastcomments-sdk';

Using Individual API Classes

Browser Environment

import { PublicApi, Configuration } from 'fastcomments-sdk/browser';

const config = new Configuration({
  basePath: 'https://fastcomments.com'
});

const publicApi = new PublicApi(config);

Server Environment

import { DefaultApi, PublicApi, Configuration } from 'fastcomments-sdk/server';

const config = new Configuration({
  apiKey: 'your-api-key',
  basePath: 'https://fastcomments.com'
});

const defaultApi = new DefaultApi(config);
const publicApi = new PublicApi(config);

Public vs Secured APIs

The SDK provides these API classes:

DefaultApi - Secured endpoints that require your API key for authentication. Use these for server-side operations.
PublicApi - Public endpoints that can be accessed without an API key. These can be called directly from browsers/mobile devices/etc.
ModerationApi - Moderator dashboard endpoints (comment moderation, bans, badges, trust factor, search). Authenticated by the moderator's session; pass the sso query param for SSO-authenticated moderators.
HiddenApi - Internal/admin endpoints for advanced use cases.

Example: Using Public API (browser-safe)

import { PublicApi } from 'fastcomments-sdk/browser';

const publicApi = new PublicApi();

// Get comments for a page (no API key required)
const response = await publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

Example: Using Default API (server-side only)

import { DefaultApi, Configuration } from 'fastcomments-sdk/server';

const config = new Configuration({
  apiKey: 'your-api-key' // Keep this secret!
});
const defaultApi = new DefaultApi(config);

// Get comments with full admin access
const response = await defaultApi.getComments({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

Example: Using Moderation API

import { createFastCommentsSDK } from 'fastcomments-sdk/server';

const sdk = createFastCommentsSDK({ /* basePath, etc. */ });

// Moderator-authenticated calls (session cookie, or pass `sso` for an SSO moderator).
const comments = await sdk.moderationApi.getApiComments({
  tenantId: 'your-tenant-id'
});

await sdk.moderationApi.postSetCommentSpamStatus({
  commentId: 'comment-id',
  spam: true
});

SSO (Single Sign-On) Integration

FastComments supports SSO to integrate with your existing user authentication system. SSO functionality is only available in the server export since it requires Node.js crypto features.

Simple SSO (Server-Side Only)

Simple SSO should be generated server-side and sent to the client:

// Server-side code (Node.js/backend)
import { FastCommentsSSO, PublicApi } from 'fastcomments-sdk/server';

// Create simple SSO using the built-in helper  
const userData = {
  username: 'john_doe',
  email: 'john@example.com',
  displayName: 'John Doe',
  avatar: 'https://example.com/avatar.jpg'
};

const sso = FastCommentsSSO.createSimple(userData, {
  loginURL: '/login',
  logoutURL: '/logout'
});

const ssoToken = sso.createToken();

// Send ssoToken to your client-side code
// Client-side code can then use this token with the browser SDK

Secure SSO (Server-Side, Recommended)

Secure SSO should be implemented server-side and provides better security:

// Server-side code (Node.js/backend)
import { FastCommentsSSO, PublicApi } from 'fastcomments-sdk/server';

// Create secure SSO using the built-in helper
const userData = {
  id: 'user-123',
  email: 'john@example.com',
  username: 'john_doe',
  displayName: 'John Doe',
  avatar: 'https://example.com/avatar.jpg',
  isAdmin: false,
  isModerator: false
};

const sso = FastCommentsSSO.createSecure('your-api-key', userData, {
  loginURL: '/login',
  logoutURL: '/logout'
});

const ssoConfig = sso.prepareToSend();

// Use with API calls on the server
const publicApi = new PublicApi();
const response = await publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id',
  sso: JSON.stringify(ssoConfig)
});

// Or send ssoConfig to client for browser usage

Using SSO from Browser (with Server-Generated Token)

// Client-side code (browser)
import { PublicApi } from 'fastcomments-sdk/browser';

// Get SSO token from your server endpoint
const ssoToken = await fetch('/api/sso-token').then(r => r.json());

const publicApi = new PublicApi();
const response = await publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id',
  sso: ssoToken // Use the server-generated SSO token
});

SSO with Comment Creation

// Server-side: Create SSO and comment
import { FastCommentsSSO, PublicApi } from 'fastcomments-sdk/server';

const sso = FastCommentsSSO.createSecure('your-api-key', userData);
const ssoConfig = sso.prepareToSend();

const response = await publicApi.createCommentPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id',
  broadcastId: 'unique-broadcast-id',
  commentData: {
    comment: 'This is my comment',
    date: Date.now(),
    commenterName: 'John Doe',
    url: 'https://example.com/page',
    urlId: 'page-url-id'
  },
  sso: JSON.stringify(ssoConfig)
});

Common Use Cases

Getting Comments for a Page

const comments = await sdk.publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'article-123'
});

Creating a Comment

const newComment = await sdk.publicApi.createCommentPublic({
  createCommentParams: {
    tenantId: 'your-tenant-id',
    urlId: 'article-123',
    comment: 'Great article!',
    commenterName: 'John Doe',
    commenterEmail: 'john@example.com'
  }
});

Voting on a Comment

const voteResponse = await sdk.publicApi.voteComment({
  voteBodyParams: {
    commentId: 'comment-id',
    direction: 1 // 1 for upvote, -1 for downvote
  }
});

User Management (Requires API Key)

// Search for users (requires DefaultApi)
const users = await sdk.defaultApi.searchUsers({
  tenantId: 'your-tenant-id',
  urlId: 'page-id',
  usernameStartsWith: 'john'
});

Live Events (Real-time Updates)

Subscribe to live events to get real-time updates for comments, votes, and other activities.

Page-Level Events

Listen for live events on a specific page (comments, votes, etc.):

import { subscribeToChanges, LiveEvent, LiveEventType } from 'fastcomments-sdk/browser';

const config = {
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id',
};

// Subscribe to live events for a page
const subscription = subscribeToChanges(
  config,
  'your-tenant-id', // tenantIdWS
  'page-url-id',    // urlIdWS  
  'user-session-id', // userIdWS (get this from getComments response)
  (event: LiveEvent) => {
    console.log('Live event received:', event);
    
    switch (event.type) {
      case LiveEventType.new_comment:
        console.log('New comment:', event.comment);
        // Update your UI with the new comment
        break;
      case LiveEventType.new_vote:
        console.log('New vote:', event.vote);
        // Update vote counts in your UI
        break;
      case LiveEventType.updated_comment:
        console.log('Comment updated:', event.comment);
        break;
      default:
        console.log('Other event type:', event.type);
    }
    
    return true; // Return true if event was handled
  },
  (isConnected: boolean) => {
    console.log('Connection status:', isConnected ? 'Connected' : 'Disconnected');
  }
);

// Close the subscription when done
subscription.close();

Listen for user-specific events (notifications, mentions, etc.):

import { subscribeToUserFeed, LiveEvent, LiveEventType } from 'fastcomments-sdk/browser';

const userConfig = {
  userIdWS: 'user-session-id', // Get this from getComments response
};

// Subscribe to user's personal feed
const userSubscription = subscribeToUserFeed(
  userConfig,
  (event: LiveEvent) => {
    console.log('User event received:', event);
    
    switch (event.type) {
      case LiveEventType.notification:
        console.log('New notification:', event.notification);
        // Show notification in your UI
        break;
      case LiveEventType.notification_update:
        console.log('Notification updated:', event.notification);
        break;
      default:
        console.log('Other user event:', event.type);
    }
    
    return true;
  },
  (isConnected: boolean) => {
    console.log('User feed connection:', isConnected ? 'Connected' : 'Disconnected');
  }
);

// Close when done
userSubscription.close();

Getting userIdWS

The userIdWS parameter is required for live events and can be obtained from API responses:

const response = await sdk.publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-id'
});

// Extract userIdWS from the response
const userIdWS = response.data?.userSessionInfo?.userIdWS;

if (userIdWS) {
  // Now you can subscribe to live events
  const subscription = subscribeToChanges(config, tenantIdWS, urlIdWS, userIdWS, handleEvent);
}

Broadcast IDs

You'll see you're supposed to pass a broadcastId in some API calls. When you receive events, you'll get this ID back, so you know to ignore the event if you plan to optimistically apply changes on the client (which you'll probably want to do since it offers the best experience). Pass a UUID here. The ID should be unique enough to not occur twice in a browser session.

import { v4 as uuidv4 } from 'uuid';

const response = await sdk.publicApi.createCommentPublic({
  createCommentParams: {
    tenantId: 'your-tenant-id',
    urlId: 'page-id',
    comment: 'My comment',
    broadcastId: uuidv4() // Unique ID for this operation
  }
});

Error Handling

try {
  const comments = await sdk.publicApi.getCommentsPublic({
    tenantId: 'your-tenant-id',
    urlId: 'page-id'
  });
} catch (error) {
  if (error.response?.status === 404) {
    console.log('Page not found');
  } else {
    console.error('API Error:', error.message);
  }
}

createAgentTenant

Creates a new trial account for an AI agent without a human signup. No API key is needed to call this.

The response contains the tenant id, an API key that works immediately against the REST API and the MCP server, and a claim URL. Give the claim URL to the human you are working for: opening it while logged in to FastComments attaches the account to them. Unclaimed accounts, and their keys, are deleted 72 hours after creation. Until claimed, the account has the standard trial limits.

Parameters

Name	Type	Required	Description
createAgentTenantBody	CreateAgentTenantBody	Yes

Response

Returns: CreateAgentTenantResponse

Example

createAgentTenant Example

Copy

const tenantBody: CreateAgentTenantBody = {
  name: "Acme Corp",
  domain: "acme.example.com",
  contactEmail: "admin@acme.example.com", // optional
  planId: 3 // optional
};
const result: CreateAgentTenantResponse = await createAgentTenant(tenantBody);

aggregate

Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations. Different operations (e.g. sum, countDistinct, avg, etc.) are supported.

Parameters

Name	Type	Required
tenantId	string	Yes
aggregationRequest	AggregationRequest	Yes
parentTenantId	string	No
includeStats	boolean	No

Response

Returns: AggregateResponse

Example

aggregate Example

Copy

const tenantId: string = "tenant-12345";
const aggregationRequest: AggregationRequest = {
  predicates: [
    {
      field: "status",
      operator: "eq",
      value: { type: "string", value: "approved" }
    }
  ],
  operations: [
    { type: "count", field: "commentId" }
  ],
  sort: { field: "createdAt", direction: "desc" }
};
const parentTenantId: string = "parent-001";
const includeStats: boolean = true;
const result: AggregateResponse = await aggregate(
  tenantId,
  aggregationRequest,
  parentTenantId,
  includeStats
);

getAuditLogs

Parameters

Name	Type	Required
tenantId	string	Yes
limit	number	No
skip	number	No
order	SORTDIR	No
after	number	No
before	number	No
username	string	No
ip	string	No
crudType	string	No
resourceName	string	No
targetId	string	No
target	string	No
includeManagedTenants	boolean	No

Response

Returns: GetAuditLogsResponse

Example

getAuditLogs Example

Copy

async function fetchAuditLogs(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const limit: number = 50;
  const skip: number = 0;
  const order: SORTDIR = { direction: "DESC" };
  const after: number = Date.now() - 86400000; // 1 day ago
  const before: number = Date.now();
  const username: string = "alice.smith";
  const ip: string = "198.51.100.23";
  const crudType: string = "CREATE";
  const resourceName: string = "thread";
  const targetId: string = "thread_45678";
  const target: string = "forum_12";
  const includeManagedTenants: boolean = false;
  const logs: GetAuditLogsResponse = await getAuditLogs(
    tenantId,
    limit,
    skip,
    order,
    after,
    before,
    username,
    ip,
    crudType,
    resourceName,
    targetId,
    target,
    includeManagedTenants
  );
  console.log(logs);
}
fetchAuditLogs();

blockFromCommentPublic

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Response

Returns: BlockSuccess

Example

blockFromCommentPublic Example

Copy

async function demoBlock() {
  const tenantId: string = "tenant_9f8b7c";
  const commentId: string = "comment_3e2d1a";
  const blockParams: PublicBlockFromCommentParams = {
    reason: "harassment",
    expiresInHours: 48
  };
  const ssoToken: string = "sso_5g6h7i";
  const resultWithSso: BlockSuccess = await blockFromCommentPublic(tenantId, commentId, blockParams, ssoToken);
  const resultWithoutSso: BlockSuccess = await blockFromCommentPublic(tenantId, commentId, blockParams);
}

unBlockCommentPublic

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Response

Returns: UnblockSuccess

Example

unBlockCommentPublic Example

Copy

const tenantId: string = "c9f1e2a4-5b6d-4f8a-9c2e-123456789abc";
const commentId: string = "d3b2c1a9-8f7e-4d6b-9a0b-987654321def";
const unblockParams: PublicBlockFromCommentParams = {
    reason: "User request resolved",
    moderatorId: "mod-456"
};
const ssoToken: string = "sso-token-789xyz";
const unblockResult: UnblockSuccess = await unBlockCommentPublic(tenantId, commentId, unblockParams, ssoToken);
const unblockResultNoSso: UnblockSuccess = await unBlockCommentPublic(tenantId, commentId, unblockParams);

checkedCommentsForBlocked

Parameters

Name	Type	Required
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

Response

Returns: CheckBlockedCommentsResponse

Example

checkedCommentsForBlocked Example

Copy

(async () => {
    const tenantId: string = "tenant_12345";
    const commentIds: string = "cmt_9876,cmt_5432";
    const ssoToken: string = "sso_user_abc123";
    const responseWithSso: CheckBlockedCommentsResponse = await checkedCommentsForBlocked(tenantId, commentIds, ssoToken);
    const responseWithoutSso: CheckBlockedCommentsResponse = await checkedCommentsForBlocked(tenantId, commentIds);
})();

blockUserFromComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
blockFromCommentParams	BlockFromCommentParams	Yes
userId	string	No
anonUserId	string	No

Response

Returns: BlockSuccess

Example

blockUserFromComment Example

Copy

async function demo() {
  const tenantId: string = "tenant-123e4567-e89b-12d3-a456-426614174000";
  const commentId: string = "cmt-9876543210";
  const blockParams: BlockFromCommentParams = {
    reason: "spam",
    durationHours: 24
  };
  const userId: string = "user-abc123";
  const anonUserId: string = "anon-xyz789";
  const result: BlockSuccess = await blockUserFromComment(tenantId, commentId, blockParams, userId, anonUserId);
  console.log(result);
}
demo();

createCommentPublic

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
commentData	CommentData	Yes
sessionId	string	No
sso	string	No

Response

Returns: SaveCommentsResponseWithPresence

Example

createCommentPublic Example

Copy

async function runExample() {
  const tenantId: string = "tenant-456";
  const urlId: string = "url-789";
  const broadcastId: string = "broadcast-101112";
  const commentData: CommentData = { text: "This is a comment", userId: "user-123" };
  const sessionId: string = "session-131415";
  const sso: string = "sso-token-xyz";
  const result: SaveCommentsResponseWithPresence = await createCommentPublic(tenantId, urlId, broadcastId, commentData, sessionId, sso);
  const resultNoOpt: SaveCommentsResponseWithPresence = await createCommentPublic(tenantId, urlId, broadcastId, commentData);
}

deleteComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
contextUserId	string	No
isLive	boolean	No

Response

Returns: DeleteCommentResult

Example

deleteComment Example

Copy

async function removeComment(): Promise<void> {
    const tenantId: string = "tenant_12345";
    const commentId: string = "comment_9876";
    const contextUserId: string = "user_42";
    const result: DeleteCommentResult = await deleteComment(tenantId, commentId, contextUserId, true);
    console.log(result);
}
removeComment();

deleteCommentPublic

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
editKey	string	No
sso	string	No

Response

Returns: PublicAPIDeleteCommentResponse

Example

deleteCommentPublic Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_9876";
  const broadcastId: string = "brd_5555";
  const editKey: string = "edit_abc123";
  const sso: string = "sso_token_xyz";
  const resultWithoutOptional: PublicAPIDeleteCommentResponse = await deleteCommentPublic(tenantId, commentId, broadcastId);
  const resultWithOptional: PublicAPIDeleteCommentResponse = await deleteCommentPublic(tenantId, commentId, broadcastId, editKey, sso);
})();

deleteCommentVote

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
editKey	string	No
sso	string	No

Response

Returns: VoteDeleteResponse

Example

deleteCommentVote Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_9876";
const voteId: string = "vote_555";
const urlId: string = "url_abcde";
const broadcastId: string = "brd_2023";
const editKey: string = "edit_abc123"; // optional
const ssoToken: string = "sso_token_xyz"; // optional
// Call with only the required parameters and one optional
const deleteResult: VoteDeleteResponse = await deleteCommentVote(
  tenantId,
  commentId,
  voteId,
  urlId,
  broadcastId,
  editKey
);
// Call with both optional parameters
const deleteResultWithSSO: VoteDeleteResponse = await deleteCommentVote(
  tenantId,
  commentId,
  voteId,
  urlId,
  broadcastId,
  editKey,
  ssoToken
);

flagComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
userId	string	No
anonUserId	string	No

Response

Returns: FlagCommentResponse

Example

flagComment Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const commentId: string = "comment-20230915-001";
  const userId: string = "user-42";
  const anonUserId: string = "anon-abc123";
  const response: FlagCommentResponse = await flagComment(tenantId, commentId, userId, anonUserId);
  console.log(response);
})();

getComment

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIGetCommentResponse

Example

getComment Example

Copy

async function fetchComment(): Promise<void> {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_1234567890";
  const response: APIGetCommentResponse = await getComment(tenantId, commentId);
  const comment: APIComment | undefined = response.comment;
  // Optional fields demonstration
  const badgeInfo: CommentUserBadgeInfo | undefined = comment?.user?.badge;
  const hashtags: CommentUserHashTagInfo[] | undefined = comment?.user?.hashtags;
  const mentions: CommentUserMentionInfo[] | undefined = comment?.user?.mentions;
  const meta: APICommentBaseMeta | undefined = comment?.meta;
  console.log(comment?.id, badgeInfo?.type);
}
fetchComment();

getComments

Parameters

Name	Type	Required
tenantId	string	Yes
page	number	No
limit	number	No
skip	number	No
asTree	boolean	No
skipChildren	number	No
limitChildren	number	No
maxTreeDepth	number	No
urlId	string	No
userId	string	No
anonUserId	string	No
contextUserId	string	No
hashTag	string	No
parentId	string	No
direction	SortDirections	No
fromDate	number	No
toDate	number	No

Response

Returns: APIGetCommentsResponse

Example

getComments Example

Copy

async function loadComments(): Promise<void> {
  const tenantId: string = "acme-corp";
  const page: number = 1;
  const limit: number = 50;
  const asTree: boolean = false;
  const direction: SortDirections = "asc";
  const fromDate: number = Date.now() - 30 * 24 * 60 * 60 * 1000; // 30 days ago
  const toDate: number = Date.now();
  const commentsResponse: APIGetCommentsResponse = await getComments(
    tenantId,
    page,
    limit,
    undefined,
    asTree,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    direction,
    fromDate,
    toDate
  );
  console.log(commentsResponse);
}

getCommentsPublic

req tenantId urlId

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
page	number	No
direction	SortDirections	No
sso	string	No
skip	number	No
skipChildren	number	No
limit	number	No
limitChildren	number	No
countChildren	boolean	No
fetchPageForCommentId	string	No
includeConfig	boolean	No
countAll	boolean	No
includei10n	boolean	No
locale	string	No
modules	string	No
isCrawler	boolean	No
includeNotificationCount	boolean	No
asTree	boolean	No
maxTreeDepth	number	No
useFullTranslationIds	boolean	No
parentId	string	No
searchText	string	No
hashTags	Array	No
userId	string	No
customConfigStr	string	No
afterCommentId	string	No
beforeCommentId	string	No

Response

Returns: GetCommentsResponseWithPresencePublicComment

Example

getCommentsPublic Example

Copy

async function loadComments(): Promise<void> {
  const tenantId: string = "tenant-42",
        urlId: string = "post-2023-09-15",
        page: number = 1,
        direction: SortDirections = "desc",
        limit: number = 30,
        includeConfig: boolean = true,
        locale: string = "en-US",
        isCrawler: boolean = false,
        asTree: boolean = true,
        maxTreeDepth: number = 2,
        searchText: string = "fastcomments",
        hashTags: string[] = ["fastcomments","typescript"],
        userId: string = "user-123";
  const result: GetCommentsResponseWithPresencePublicComment = await getCommentsPublic(
    tenantId,
    urlId,
    page,
    direction,
    undefined,
    undefined,
    undefined,
    limit,
    undefined,
    undefined,
    undefined,
    includeConfig,
    undefined,
    undefined,
    locale,
    undefined,
    isCrawler,
    undefined,
    asTree,
    maxTreeDepth,
    undefined,
    undefined,
    searchText,
    hashTags,
    userId
  );
}

getCommentText

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
editKey	string	No
sso	string	No

Response

Returns: PublicAPIGetCommentTextResponse

Example

getCommentText Example

Copy

const tenantId: string = "acme-corp-tenant";
const commentId: string = "comment-987654321";
const editKey: string = "edit-key-abc123";
const sso: string = "sso-token-xyz789";
const commentWithEdit: PublicAPIGetCommentTextResponse = await getCommentText(
  tenantId,
  commentId,
  editKey,
  sso
);
const commentBasic: PublicAPIGetCommentTextResponse = await getCommentText(
  tenantId,
  commentId
);

getCommentVoteUserNames

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
dir	number	Yes
sso	string	No

Response

Returns: GetCommentVoteUserNamesSuccessResponse

Example

getCommentVoteUserNames Example

Copy

async function example() {
  const tenantId: string = 'tenant-9876';
  const commentId: string = 'comment-abc123';
  const dir: number = 1;
  const ssoToken: string = 'sso-xyz789';
  const resultWithSso: GetCommentVoteUserNamesSuccessResponse = await getCommentVoteUserNames(tenantId, commentId, dir, ssoToken);
  const resultWithoutSso: GetCommentVoteUserNamesSuccessResponse = await getCommentVoteUserNames(tenantId, commentId, dir);
}

lockComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Response

Returns: APIEmptyResponse

Example

lockComment Example

Copy

async function demoLockComment() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_9876";
  const broadcastId: string = "brd_5555";
  const ssoToken: string = "sso_user_abc";
  const resultWithSso: APIEmptyResponse = await lockComment(tenantId, commentId, broadcastId, ssoToken);
  const resultWithoutSso: APIEmptyResponse = await lockComment(tenantId, commentId, broadcastId);
}
demoLockComment();

pinComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Response

Returns: ChangeCommentPinStatusResponse

Example

pinComment Example

Copy

async function demoPinComment() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const broadcastId: string = "brd_54321";
  const resultWithoutSso: ChangeCommentPinStatusResponse = await pinComment(tenantId, commentId, broadcastId);
  const ssoToken: string = "sso_abcde12345";
  const resultWithSso: ChangeCommentPinStatusResponse = await pinComment(tenantId, commentId, broadcastId, ssoToken);
}
demoPinComment();

saveComment

Parameters

Name	Type	Required
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
isLive	boolean	No
doSpamCheck	boolean	No
sendEmails	boolean	No
populateNotifications	boolean	No

Response

Returns: APISaveCommentResponse

Example

saveComment Example

Copy

const tenantId: string = "tenant_12345";
const commentParams: CreateCommentParams = {
  content: "This is a comment with a mention and a hashtag.",
  userId: "user_987",
  mentions: [
    { userId: "user_123", start: 27, end: 34 }
  ] as CommentUserMentionInfo[],
  hashtags: [
    { tag: "feedback", start: 45, end: 53 }
  ] as CommentUserHashTagInfo[],
  poll: {
    question: "Do you like this feature?",
    options: ["Yes", "No"]
  } as CommentPollInput,
};
const response: APISaveCommentResponse = await saveComment(
  tenantId,
  commentParams,
  true,   // isLive
  true,   // doSpamCheck
  false,  // sendEmails
  true    // populateNotifications
);

saveCommentsBulk

Parameters

Name	Type	Required
tenantId	string	Yes
createCommentParams	Array	Yes
isLive	boolean	No
doSpamCheck	boolean	No
sendEmails	boolean	No
populateNotifications	boolean	No

Response

Returns: Array<SaveCommentsBulkResponse

Example

saveCommentsBulk Example

Copy

const tenantId: string = "tenant_12345";
const mention1: CommentUserMentionInfo = {
  userId: "user_002",
  start: 10,
  end: 20,
};
const hashtag1: CommentUserHashTagInfo = {
  tag: "news",
  start: 30,
  end: 35,
};
const poll1: CommentPollInput = {
  question: "Did you find this helpful?",
  options: ["Yes", "No"],
};
const commentA: CreateCommentParams = {
  content: "This is a great article!",
  userId: "user_001",
  mentions: [mention1],
  hashtags: [hashtag1],
  poll: poll1,
};
const commentB: CreateCommentParams = {
  content: "I have a question about the topic.",
  userId: "user_003",
};
const createCommentParams: CreateCommentParams[] = [commentA, commentB];
const isLive: boolean = true;
const doSpamCheck: boolean = false;
const sendEmails: boolean = true;
const populateNotifications: boolean = false;
const results: SaveCommentsBulkResponse[] = await saveCommentsBulk(
  tenantId,
  createCommentParams,
  isLive,
  doSpamCheck,
  sendEmails,
  populateNotifications
);

setCommentText

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
editKey	string	No
sso	string	No

Response

Returns: PublicAPISetCommentTextResponse

Example

setCommentText Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const broadcastId: string = "brd_54321";
  const commentTextUpdateRequest: CommentTextUpdateRequest = {
    text: "Revised comment text with additional details."
  };
  const editKey: string = "edit_abc123";
  const sso: string = "sso_token_456def";
  const response: PublicAPISetCommentTextResponse = await setCommentText(
    tenantId,
    commentId,
    broadcastId,
    commentTextUpdateRequest,
    editKey,
    sso
  );
})();

unBlockUserFromComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
userId	string	No
anonUserId	string	No

Response

Returns: UnblockSuccess

Example

unBlockUserFromComment Example

Copy

(async () => {
  const tenantId: string = "tenant-9f8b7c6d";
  const commentId: string = "comment-4a3b2c1d";
  const params: UnBlockFromCommentParams = {
    reason: "User appealed the block",
    adminNote: "Reviewed and unblocked"
  };
  const userId: string = "user-5e6f7g8h";
  const anonUserId: string = "anon-1a2b3c4d";
  const result: UnblockSuccess = await unBlockUserFromComment(
    tenantId,
    commentId,
    params,
    userId,
    anonUserId
  );
  console.log(result);
})();

unFlagComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
userId	string	No
anonUserId	string	No

Response

Returns: FlagCommentResponse

Example

unFlagComment Example

Copy

async function runExample() {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt-20230915-001";
  const userId: string = "user-42";
  const unflaggedByUser: FlagCommentResponse = await unFlagComment(tenantId, commentId, userId);
  const unflaggedByAnon: FlagCommentResponse = await unFlagComment(tenantId, commentId, undefined, "anon-xyz");
  console.log(unflaggedByUser, unflaggedByAnon);
}

unLockComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Response

Returns: APIEmptyResponse

Example

unLockComment Example

Copy

async function demoUnlock() {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_1234567890";
  const broadcastId: string = "brd_987654321";
  const ssoToken: string = "sso_abcdef123456";
  const resultWithoutSso: APIEmptyResponse = await unLockComment(tenantId, commentId, broadcastId);
  const resultWithSso: APIEmptyResponse = await unLockComment(tenantId, commentId, broadcastId, ssoToken);
}

unPinComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Response

Returns: ChangeCommentPinStatusResponse

Example

unPinComment Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const commentId: string = "comment-20230915-001";
  const broadcastId: string = "broadcast-2023-09-15";
  const ssoToken: string = "sso-abc123";
  const result: ChangeCommentPinStatusResponse = await unPinComment(tenantId, commentId, broadcastId, ssoToken);
  const resultWithoutSso: ChangeCommentPinStatusResponse = await unPinComment(tenantId, commentId, broadcastId);
})();

updateComment

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
contextUserId	string	No
doSpamCheck	boolean	No
isLive	boolean	No

Response

Returns: APIEmptyResponse

Example

updateComment Example

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const commentId: string = "comment-9876543210";
const updateParams: UpdatableCommentParams = {
  content: "Edited comment content",
  isApproved: true
};
const contextUserId: string = "user-11223344";
const doSpamCheck: boolean = true;
const isLive: boolean = false;
const response: APIEmptyResponse = await updateComment(
  tenantId,
  commentId,
  updateParams,
  contextUserId,
  doSpamCheck,
  isLive
);

voteComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
sessionId	string	No
sso	string	No

Response

Returns: VoteResponse

Example

voteComment Example

Copy

async function runVote() {
  const tenantId: string = 'tenant_001';
  const commentId: string = 'cmt_987654';
  const urlId: string = 'url_12345';
  const broadcastId: string = 'brd_56789';
  const voteBody: VoteBodyParams = { direction: 'up' };
  const sessionId: string = 'sess_abc123';
  const sso: string = 'sso_token_xyz';
  const response: VoteResponse = await voteComment(
    tenantId,
    commentId,
    urlId,
    broadcastId,
    voteBody,
    sessionId,
    sso
  );
  console.log(response);
}
runVote();

getCommentsForUser

Parameters

Name	Type	Required
userId	string	No
direction	SortDirections	No
repliesToUserId	string	No
page	number	No
includei10n	boolean	No
locale	string	No
isCrawler	boolean	No

Response

Returns: GetCommentsForUserResponse

Example

getCommentsForUser Example

Copy

const userId: string = '550e8400-e29b-41d4-a716-446655440000';
const direction: SortDirections = SortDirections.Descending;
const page: number = 3;
const includei10n: boolean = true;
const locale: string = 'fr-FR';
const isCrawler: boolean = false;
const commentsResponse: GetCommentsForUserResponse = await getCommentsForUser(
  userId,
  direction,
  undefined,
  page,
  includei10n,
  locale,
  isCrawler
);

addDomainConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
addDomainConfigParams	AddDomainConfigParams	Yes

Response

Returns: AddDomainConfigResponse

Example

addDomainConfig Example

Copy

(async () => {
  const tenantId: string = 'tenant_12345';
  const config: AddDomainConfigParams = {
    domain: 'myblog.example.com',
    enabled: true,
    // description is optional and omitted here
  };
  const response: AddDomainConfigResponse = await addDomainConfig(tenantId, config);
  console.log(response);
})();

deleteDomainConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
domain	string	Yes

Response

Returns: DeleteDomainConfigResponse

Example

deleteDomainConfig Example

Copy

async function runExample() {
  const tenantId: string = 'acme-corp';
  const domain: string = 'blog.acme.com';
  const response: DeleteDomainConfigResponse = await deleteDomainConfig(tenantId, domain);
  console.log(response);
}
runExample();

getDomainConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
domain	string	Yes

Response

Returns: GetDomainConfigResponse

Example

getDomainConfig Example

Copy

async function main() {
  const tenantId: string = "acme-corp-123";
  const domain: string = "blog.acme.com";
  const config: GetDomainConfigResponse = await getDomainConfig(tenantId, domain);
  console.log(config);
}
main();

getDomainConfigs

Parameters

Name	Type	Required	Description
tenantId	string	Yes

Response

Returns: GetDomainConfigsResponse

Example

getDomainConfigs Example

Copy

async function fetchDomainConfigs(): Promise<void> {
  const tenantId: string = "acme-corp-567";
  const configs: GetDomainConfigsResponse = await getDomainConfigs(tenantId);
  console.log(configs);
}

patchDomainConfig

Parameters

Name	Type	Required
tenantId	string	Yes
domainToUpdate	string	Yes
patchDomainConfigParams	PatchDomainConfigParams	Yes

Response

Returns: PatchDomainConfigResponse

Example

patchDomainConfig Example

Copy

async function updateDomainConfig() {
  const tenantId: string = "tenant_98765";
  const domainToUpdate: string = "forum.mycompany.com";
  const patchParams: PatchDomainConfigParams = {
    enableComments: true,
    moderationLevel: "strict",
    allowAnonymous: false, // optional parameter demonstrated
  };
  const response: PatchDomainConfigResponse = await patchDomainConfig(tenantId, domainToUpdate, patchParams);
  console.log(response);
}
updateDomainConfig();

putDomainConfig

Parameters

Name	Type	Required
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

Response

Returns: PutDomainConfigResponse

Example

putDomainConfig Example

Copy

async function runExample() {
  const tenantId: string = 'tenant-9f8c7b1a';
  const domainToUpdate: string = 'comments.mywebsite.org';
  const updateDomainConfigParams: UpdateDomainConfigParams = {
    enableModeration: true,
    // optional field omitted, e.g., maxCommentLength?: number
  };
  const result: PutDomainConfigResponse = await putDomainConfig(
    tenantId,
    domainToUpdate,
    updateDomainConfigParams,
  );
  console.log(result);
}
runExample();

createEmailTemplate

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createEmailTemplateBody	CreateEmailTemplateBody	Yes

Response

Returns: CreateEmailTemplateResponse

Example

createEmailTemplate Example

Copy

const tenantId: string = "tenant_9f8b7c6d";
const templateBody: CreateEmailTemplateBody = {
  name: "Weekly Summary",
  subject: "Your weekly activity report",
  // optional field
  replyTo: "no-reply@myapp.com",
  htmlContent: "<p>Hello \{{userName}}, here is your summary...</p>"
};
const response: CreateEmailTemplateResponse = await createEmailTemplate(tenantId, templateBody);
console.log(response.template.id);

deleteEmailTemplate

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptyResponse

Example

deleteEmailTemplate Example

Copy

interface APIStatus {
  code: number;
  message: string;
}
interface APIEmptyResponse {
  status?: APIStatus;
}
(async () => {
  const tenantId: string = "tenant_12345";
  const templateId: string = "template_987";
  const result: APIEmptyResponse = await deleteEmailTemplate(tenantId, templateId);
})();

deleteEmailTemplateRenderError

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
errorId	string	Yes

Response

Returns: APIEmptyResponse

Example

deleteEmailTemplateRenderError Example

Copy

async function removeRenderError() {
  const tenantId: string = "acme-corp-tenant";
  const templateId: string = "welcome-email-template";
  const errorId: string = "render-err-20230915";
  const result: APIEmptyResponse = await deleteEmailTemplateRenderError(tenantId, templateId, errorId);
}

getEmailTemplate

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetEmailTemplateResponse

Example

getEmailTemplate Example

Copy

async function fetchTemplate() {
  const tenantId: string = "acme-corp-123";
  const templateId: string = "welcome-email-456";
  const response: GetEmailTemplateResponse = await getEmailTemplate(tenantId, templateId);
  const status: APIStatus | undefined = response.status;
  const customTemplate: CustomEmailTemplate | undefined = response.template;
}

getEmailTemplateDefinitions

Parameters

Name	Type	Required	Description
tenantId	string	Yes

Response

Returns: GetEmailTemplateDefinitionsResponse

Example

getEmailTemplateDefinitions Example

Copy

async function fetchEmailTemplates() {
    const tenantId: string = "acme-corp-456";
    const result: GetEmailTemplateDefinitionsResponse = await getEmailTemplateDefinitions(tenantId);
    const status: APIStatus = result.status;
    const definitions: EmailTemplateDefinition[] = result.definitions ?? [];
    console.log(`Status: ${status.code}, Templates: ${definitions.length}`);
}

getEmailTemplateRenderErrors

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
skip	number	No

Response

Returns: GetEmailTemplateRenderErrorsResponse

Example

getEmailTemplateRenderErrors Example

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const templateId: string = "template_9876";
  const resultWithSkip: GetEmailTemplateRenderErrorsResponse = await getEmailTemplateRenderErrors(tenantId, templateId, 10);
  const resultWithoutSkip: GetEmailTemplateRenderErrorsResponse = await getEmailTemplateRenderErrors(tenantId, templateId);
  console.log(resultWithSkip, resultWithoutSkip);
}
demo();

getEmailTemplates

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetEmailTemplatesResponse

Example

getEmailTemplates Example

Copy

async function fetchEmailTemplates() {
  const tenantId: string = "acme-corp-123";
  const skip: number = 20;
  const templatesWithSkip: GetEmailTemplatesResponse = await getEmailTemplates(tenantId, skip);
  const templatesWithoutSkip: GetEmailTemplatesResponse = await getEmailTemplates(tenantId);
}

renderEmailTemplate

Parameters

Name	Type	Required
tenantId	string	Yes
renderEmailTemplateBody	RenderEmailTemplateBody	Yes
locale	string	No

Response

Returns: RenderEmailTemplateResponse

Example

renderEmailTemplate Example

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const templateBody: RenderEmailTemplateBody = {
  templateId: "welcome-email",
  variables: {
    userName: "Jane Doe",
    signupDate: "2024-04-01"
  }
};
const locale: string = "en-US";
(async () => {
  const rendered: RenderEmailTemplateResponse = await renderEmailTemplate(
    tenantId,
    templateBody,
    locale
  );
  console.log(rendered);
})();

updateEmailTemplate

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateEmailTemplateBody	UpdateEmailTemplateBody	Yes

Response

Returns: APIEmptyResponse

Example

updateEmailTemplate Example

Copy

async function runUpdate() {
  const tenantId: string = "tenant_12345";
  const templateId: string = "template_67890";
  const updateBody: UpdateEmailTemplateBody = {
    subject: "New Comment Notification",
    // htmlContent is optional and omitted
    status: { code: 200, message: "Active" } // APIStatus
  };
  const response: APIEmptyResponse = await updateEmailTemplate(tenantId, templateId, updateBody);
  console.log(response);
}

getEventLog

req tenantId urlId userIdWS

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	number	Yes
endTime	number	No

Response

Returns: GetEventLogResponse

Example

getEventLog Example

Copy

const tenantId: string = "tenant_12345";
const urlId: string = "url_9876";
const userIdWS: string = "user_abcde";
const startTime: number = Date.now() - 86_400_000; // 24 hours ago
const endTime: number = Date.now();
const fullLog: GetEventLogResponse = await getEventLog(tenantId, urlId, userIdWS, startTime, endTime);
const partialLog: GetEventLogResponse = await getEventLog(tenantId, urlId, userIdWS, startTime);

getGlobalEventLog

req tenantId urlId userIdWS

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
userIdWS	string	Yes
startTime	number	Yes
endTime	number	No

Response

Returns: GetEventLogResponse

Example

getGlobalEventLog Example

Copy

async function fetchEventLogs() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "url_9876";
  const userIdWS: string = "user_ws_abcde";
  const startTime: number = Date.now() - 24 * 60 * 60 * 1000; // 24 hours ago
  const endTime: number = Date.now();
  const logWithEnd: GetEventLogResponse = await getGlobalEventLog(tenantId, urlId, userIdWS, startTime, endTime);
  const logWithoutEnd: GetEventLogResponse = await getGlobalEventLog(tenantId, urlId, userIdWS, startTime);
}

createFeedPost

Parameters

Name	Type	Required
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
broadcastId	string	No
isLive	boolean	No
doSpamCheck	boolean	No
skipDupCheck	boolean	No

Response

Returns: CreateFeedPostsResponse

Example

createFeedPost Example

Copy

(async () => {
  const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
  const broadcastId: string = "b1c2d3e4-5678-90ab-cdef-1234567890cd";
  const isLive: boolean = true;
  const doSpamCheck: boolean = false;
  const skipDupCheck: boolean = true;
  const mediaAsset: FeedPostMediaItemAsset = {
    url: "https://cdn.example.com/photos/sunrise.jpg",
    type: "image/jpeg"
  };
  const mediaItem: FeedPostMediaItem = {
    asset: mediaAsset,
    caption: "Sunrise over the mountains"
  };
  const linkItem: FeedPostLink = {
    url: "https://blog.example.com/tech-trends-2024",
    title: "Top Tech Trends for 2024"
  };
  const postParams: CreateFeedPostParams = {
    text: "Excited to share the latest tech trends!",
    media: [mediaItem],
    link: linkItem
  };
  const response: CreateFeedPostsResponse = await createFeedPost(
    tenantId,
    postParams,
    broadcastId,
    isLive,
    doSpamCheck,
    skipDupCheck
  );
  console.log(response);
})();

createFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
broadcastId	string	No
sso	string	No

Response

Returns: CreateFeedPostResponse

Example

createFeedPostPublic Example

Copy

const tenantId: string = "tenant_12345";
const mediaAsset: FeedPostMediaItemAsset = {
  url: "https://cdn.example.com/image.jpg",
  width: 800,
  height: 600,
  mimeType: "image/jpeg"
};
const mediaItem: FeedPostMediaItem = {
  type: "image",
  asset: mediaAsset,
  caption: "Sunset over the hills"
};
const link: FeedPostLink = {
  url: "https://example.com/blog/post",
  title: "Exciting New Features",
  description: "Read about our latest updates."
};
const createFeedPostParams: CreateFeedPostParams = {
  content: "Check out our latest blog post!",
  media: [mediaItem],
  link: link,
  visibility: "public"
};
const broadcastId: string = "broadcast_9876";
const sso: string = "sso_token_abc123";
const response: CreateFeedPostResponse = await createFeedPostPublic(
  tenantId,
  createFeedPostParams,
  broadcastId,
  sso
);

deleteFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Yes
postId	string	Yes
broadcastId	string	No
sso	string	No

Response

Returns: DeleteFeedPostPublicResponse

Example

deleteFeedPostPublic Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const postId: string = "post_98765";
  const broadcastId: string = "broadcast_abcde";
  const sso: string = "sso_token_xyz";
  const responseWithOpts: DeleteFeedPostPublicResponse = await deleteFeedPostPublic(
    tenantId,
    postId,
    broadcastId,
    sso
  );
  const responseWithoutOpts: DeleteFeedPostPublicResponse = await deleteFeedPostPublic(
    tenantId,
    postId
  );
})();

getFeedPosts

req tenantId afterId

Parameters

Name	Type	Required
tenantId	string	Yes
afterId	string	No
limit	number	No
tags	Array	No

Response

Returns: GetFeedPostsResponse

Example

getFeedPosts Example

Copy

async function loadFeed() {
  const tenantId: string = '123e4567-e89b-12d3-a456-426614174000';
  const afterId: string = 'post_987654321';
  const limit: number = 25;
  const tags: string[] = ['technology', 'innovation'];
  const response: GetFeedPostsResponse = await getFeedPosts(tenantId, afterId, limit, tags);
  console.log(response);
}
loadFeed();

getFeedPostsPublic

req tenantId afterId

Parameters

Name	Type	Required
tenantId	string	Yes
afterId	string	No
limit	number	No
tags	Array	No
sso	string	No
isCrawler	boolean	No
includeUserInfo	boolean	No

Response

Returns: PublicFeedPostsResponse

Example

getFeedPostsPublic Example

Copy

const tenantId: string = "acme-corp-tenant";
const afterId: string = "post-20230915-abc123";
const limit: number = 15;
const tags: string[] = ["technology", "innovation"];
const sso: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiIxMjM0NSJ9.s3cr3tSignature";
const isCrawler: boolean = false;
const includeUserInfo: boolean = true;
const feedResponse: PublicFeedPostsResponse = await getFeedPostsPublic(
  tenantId,
  afterId,
  limit,
  tags,
  sso,
  isCrawler,
  includeUserInfo
);

getFeedPostsStats

Parameters

Name	Type	Required
tenantId	string	Yes
postIds	Array	Yes
sso	string	No

Response

Returns: FeedPostsStatsResponse

Example

getFeedPostsStats Example

Copy

const tenantId: string = "tenant-9f8b7c6d";
const postIds: string[] = ["post-1a2b3c", "post-4d5e6f", "post-7g8h9i"];
const ssoToken: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...";
const feedStats: FeedPostsStatsResponse = await getFeedPostsStats(tenantId, postIds, ssoToken);

getUserReactsPublic

Parameters

Name	Type	Required
tenantId	string	Yes
postIds	Array	No
sso	string	No

Response

Returns: UserReactsResponse

Example

getUserReactsPublic Example

Copy

const tenantId: string = "tenant_12345";
const postIds: string[] = ["post_abc", "post_def"];
const ssoToken: string = "sso_token_987";
const fullResponse: UserReactsResponse = await getUserReactsPublic(tenantId, postIds, ssoToken);
const minimalResponse: UserReactsResponse = await getUserReactsPublic(tenantId);

reactFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Yes
postId	string	Yes
reactBodyParams	ReactBodyParams	Yes
isUndo	boolean	No
broadcastId	string	No
sso	string	No

Response

Returns: ReactFeedPostResponse

Example

reactFeedPostPublic Example

Copy

async function demoReact() {
  const tenantId: string = "tenant_12345";
  const postId: string = "post_98765";
  const reactBodyParams: ReactBodyParams = {
    type: "like",
    userId: "user_abcde"
  };
  const response: ReactFeedPostResponse = await reactFeedPostPublic(
    tenantId,
    postId,
    reactBodyParams,
    true,
    "broadcast_001",
    "sso_token_xyz"
  );
}

updateFeedPost

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
feedPost	FeedPost	Yes

Response

Returns: APIEmptyResponse

Example

updateFeedPost Example

Copy

async function runUpdate() {
  const tenantId: string = "tenant_12345";
  const postId: string = "post_98765";
  const mediaAsset: FeedPostMediaItemAsset = {
    url: "https://cdn.example.com/image.jpg",
    width: 800,
    height: 600,
    mimeType: "image/jpeg"
  };
  const mediaItem: FeedPostMediaItem = {
    type: "image",
    asset: mediaAsset,
    caption: "Sunrise over the hills"
  };
  const link: FeedPostLink = {
    url: "https://example.com/blog",
    title: "Latest Blog Post",
    description: "Insights on recent developments"
  };
  const feedPost: FeedPost = {
    title: "Daily Highlights",
    content: "Check out today’s top stories.",
    mediaItems: [mediaItem], // optional
    links: [link] // optional
  };
  const response: APIEmptyResponse = await updateFeedPost(tenantId, postId, feedPost);
  console.log(response);
}
runUpdate();

updateFeedPostPublic

Parameters

Name	Type	Required
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
broadcastId	string	No
sso	string	No

Response

Returns: CreateFeedPostResponse

Example

updateFeedPostPublic Example

Copy

// Define parameters
const tenantId: string = "tenant_12345";
const postId: string = "post_98765";
const mediaAsset: FeedPostMediaItemAsset = {
  url: "https://cdn.example.com/image.jpg",
  width: 800,
  height: 600,
  mimeType: "image/jpeg"
};
const mediaItem: FeedPostMediaItem = {
  type: "image",
  asset: mediaAsset,
  caption: "A beautiful scenery"
};
const link: FeedPostLink = {
  url: "https://example.com/article",
  title: "Interesting Article",
  description: "An article about TypeScript best practices."
};
const updateParams: UpdateFeedPostParams = {
  content: "Updated post content with new media and link.",
  media: [mediaItem],
  link: link,
  isPublic: true
};
const broadcastId: string = "broadcast_001";
const sso: string = "sso_token_abc123";
const response: CreateFeedPostResponse = await updateFeedPostPublic(
  tenantId,
  postId,
  updateParams,
  broadcastId,
  sso
);

flagCommentPublic

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
isFlagged	boolean	Yes
sso	string	No

Response

Returns: APIEmptyResponse

Example

flagCommentPublic Example

Copy

const tenantId: string = "tenant_42";
const commentId: string = "comment_1001";
const isFlagged: boolean = true;
const sso: string = "sso_user_5678";
const resultWithSso: APIEmptyResponse = await flagCommentPublic(tenantId, commentId, isFlagged, sso);
const resultWithoutSso: APIEmptyResponse = await flagCommentPublic(tenantId, commentId, false);

getGifLarge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Response

Returns: GifGetLargeResponse

Example

getGifLarge Example

Copy

async function runExample() {
    const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
    const largeInternalURLSanitized: string = "https://cdn.fastcomments.com/gifs/large/abc123.gif";
    const response: GifGetLargeResponse = await getGifLarge(tenantId, largeInternalURLSanitized);
    console.log(response);
}

getGifsSearch

Parameters

Name	Type	Required
tenantId	string	Yes
search	string	Yes
locale	string	No
rating	string	No
page	number	No

Response

Returns: GetGifsSearchResponse

Example

getGifsSearch Example

Copy

async function runExample() {
  const tenantId: string = "tenant_9876";
  const search: string = "celebration fireworks";
  const locale: string = "fr-FR";
  const rating: string = "g";
  const page: number = 1;
  const fullResult: GetGifsSearchResponse = await getGifsSearch(tenantId, search, locale, rating, page);
  const minimalResult: GetGifsSearchResponse = await getGifsSearch(tenantId, "dog memes");
}
runExample();

getGifsTrending

Parameters

Name	Type	Required
tenantId	string	Yes
locale	string	No
rating	string	No
page	number	No

Response

Returns: GetGifsTrendingResponse

Example

getGifsTrending Example

Copy

async function runExample(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c6d";
  const locale: string = "en-US";
  const rating: string = "PG-13";
  const page: number = 1;
  const trendingAll: GetGifsTrendingResponse = await getGifsTrending(tenantId, locale, rating, page);
  console.log(trendingAll);
  // Using only the required parameter
  const trendingMinimal: GetGifsTrendingResponse = await getGifsTrending(tenantId);
  console.log(trendingMinimal);
}
runExample();

addHashTag

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createHashTagBody	CreateHashTagBody	No

Response

Returns: CreateHashTagResponse

Example

addHashTag Example

Copy

const tenantId: string = "c3f5e8b2-9d4a-4f6a-8b2c-1a2b3c4d5e6f";
const tagPayload: CreateHashTagBody = {
  tag: "typescript",
  description: "Discussions about TypeScript"
};
const responseWithBody: CreateHashTagResponse = await addHashTag(tenantId, tagPayload);
const responseWithoutBody: CreateHashTagResponse = await addHashTag(tenantId);

addHashTagsBulk

Parameters

Name	Type	Required	Description
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	No

Response

Returns: BulkCreateHashTagsResponse

Example

addHashTagsBulk Example

Copy

const tenantId: string = "tenant_9f8b7c6d";
const tags: BulkCreateHashTagsBodyTagsInner[] = [
  { name: "typescript", color: "#3178c6" },
  { name: "fastcomments", color: "#ff6600" }
];
const bulkBody: BulkCreateHashTagsBody = { tags };
const resultWithBody: BulkCreateHashTagsResponse = await addHashTagsBulk(tenantId, bulkBody);
const resultWithoutBody: BulkCreateHashTagsResponse = await addHashTagsBulk(tenantId);

deleteHashTag

Parameters

Name	Type	Required
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	No

Response

Returns: APIEmptyResponse

Example

deleteHashTag Example

Copy

const tenantId: string = "tenant_42";
const tag: string = "high-priority";
const requestBody: DeleteHashTagRequestBody = {
  // populate fields as needed
};
const resultWithBody: APIEmptyResponse = await deleteHashTag(tenantId, tag, requestBody);
const resultWithoutBody: APIEmptyResponse = await deleteHashTag(tenantId, tag);

getHashTags

Parameters

Name	Type	Required	Description
tenantId	string	Yes
page	number	No

Response

Returns: GetHashTagsResponse

Example

getHashTags Example

Copy

(async () => {
    const tenantId: string = "acme-corp-123";
    const page: number = 1;
    const result: GetHashTagsResponse = await getHashTags(tenantId, page);
    console.log(result);
})();

patchHashTag

Parameters

Name	Type	Required
tenantId	string	Yes
tag	string	Yes
updateHashTagBody	UpdateHashTagBody	No

Response

Returns: UpdateHashTagResponse

Example

patchHashTag Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const tag: string = "news";
  // Call without optional body
  const responseWithoutBody: UpdateHashTagResponse = await patchHashTag(tenantId, tag);
  // Prepare body for update
  const updateBody: UpdateHashTagBody = {
    name: "Latest News",
    description: "Tag for the most recent news articles"
  };
  const responseWithBody: UpdateHashTagResponse = await patchHashTag(tenantId, tag, updateBody);
})();

getMe

Identifies the credential in use: the tenant it belongs to and, for OAuth tokens, the user who authorized it. Integrations use this to test a connection and label it.

Parameters

Name	Type	Required	Description
tenantId	string	Yes

Response

Returns: GetMeResponse

Example

getMe Example

Copy

(async () => {
  const tenantId: string = "acme-corp-tenant";
  const me: GetMeResponse = await getMe(tenantId);
  const authType: MeAuthType = me.auth.type;
  const scopes: OAuthScope[] = me.auth.scopes ?? [];
  const status: APIStatus = me.status;
})();

deleteModerationVote

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
broadcastId	string	No
sso	string	No

Response

Returns: VoteDeleteResponse

Example

deleteModerationVote Example

Copy

async function runDeleteModerationVote(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c6a";
  const commentId: string = "comment_4d3e2f1a";
  const voteId: string = "vote_12345abcde";
  const broadcastId: string | undefined = "broadcast_2023_09_15";
  const sso: string | undefined = "sso_user_7890token";
  const result: VoteDeleteResponse = await deleteModerationVote(
    tenantId,
    commentId,
    voteId,
    broadcastId,
    sso
  );
  console.log(result);
}

getApiComments

Parameters

Name	Type	Required
tenantId	string	Yes
page	number	No
count	number	No
textSearch	string	No
byIPFromComment	string	No
filters	string	No
searchFilters	string	No
sorts	string	No
demo	boolean	No
sso	string	No

Response

Returns: ModerationAPIGetCommentsResponse

Example

getApiComments Example

Copy

async function fetchComments(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const page: number = 2;
  const count: number = 20;
  const textSearch: string = "typescript";
  const byIPFromComment: string = "192.168.1.100";
  const filters: string = "spam,offensive";
  const searchFilters: string = "user:john";
  const sorts: string = "date_desc";
  const demo: boolean = true;
  const sso: string = "sso_token_abc";
  const response: ModerationAPIGetCommentsResponse = await getApiComments(
    tenantId,
    page,
    count,
    textSearch,
    byIPFromComment,
    filters,
    searchFilters,
    sorts,
    demo,
    sso
  );
}
fetchComments();

getApiExportStatus

Parameters

Name	Type	Required
tenantId	string	Yes
batchJobId	string	No
sso	string	No

Response

Returns: ModerationExportStatusResponse

Example

getApiExportStatus Example

Copy

async function run() {
  const tenantId: string = "tenant_12345";
  const batchJobId: string = "job_98765";
  const ssoToken: string = "sso_abcde12345";
  const statusOnlyTenant: ModerationExportStatusResponse = await getApiExportStatus(tenantId);
  const statusWithBatch: ModerationExportStatusResponse = await getApiExportStatus(tenantId, batchJobId);
  const statusFull: ModerationExportStatusResponse = await getApiExportStatus(tenantId, batchJobId, ssoToken);
}
run();

getApiIds

Parameters

Name	Type	Required
tenantId	string	Yes
textSearch	string	No
byIPFromComment	string	No
filters	string	No
searchFilters	string	No
afterId	string	No
demo	boolean	No
sso	string	No

Response

Returns: ModerationAPIGetCommentIdsResponse

Example

getApiIds Example

Copy

async function run(): Promise<void> {
  const tenantId: string = "acme-corp";
  const textSearch: string = "offensive language";
  const byIPFromComment: string = "203.0.113.45";
  const filters: string = "status:unmoderated";
  const searchFilters: string = "author:alice";
  const afterId: string = "cmt_00123";
  const demo: boolean = true;
  const sso: string = "sso_9f8e7d6c";
  const fullResult: ModerationAPIGetCommentIdsResponse = await getApiIds(
    tenantId,
    textSearch,
    byIPFromComment,
    filters,
    searchFilters,
    afterId,
    demo,
    sso
  );
  const minimalResult: ModerationAPIGetCommentIdsResponse = await getApiIds(tenantId);
}

getBanUsersFromComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Response

Returns: GetBannedUsersFromCommentResponse

Example

getBanUsersFromComment Example

Copy

const tenantId: string = "tenant_9f8b7c";
const commentId: string = "comment_a1b2c3";
const ssoToken: string = "sso_abc123";
const bannedUsers: GetBannedUsersFromCommentResponse = await getBanUsersFromComment(tenantId, commentId, ssoToken);
const bannedUsersNoSso: GetBannedUsersFromCommentResponse = await getBanUsersFromComment(tenantId, commentId);

getCommentBanStatus

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Response

Returns: GetCommentBanStatusResponse

Example

getCommentBanStatus Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_987654";
  const ssoToken: string = "sso_user_abc";
  const statusWithSso: GetCommentBanStatusResponse = await getCommentBanStatus(tenantId, commentId, ssoToken);
  const statusWithoutSso: GetCommentBanStatusResponse = await getCommentBanStatus(tenantId, commentId);
})();

getCommentChildren

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Response

Returns: ModerationAPIChildCommentsResponse

Example

getCommentChildren Example

Copy

async function fetchChildren() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const ssoToken: string = "sso_user_abc123";
  const responseWithSSO: ModerationAPIChildCommentsResponse = await getCommentChildren(tenantId, commentId, ssoToken);
  const responseWithoutSSO: ModerationAPIChildCommentsResponse = await getCommentChildren(tenantId, commentId);
}
fetchChildren();

getCount

Parameters

Name	Type	Required
tenantId	string	Yes
textSearch	string	No
byIPFromComment	string	No
filter	string	No
searchFilters	string	No
demo	boolean	No
sso	string	No

Response

Returns: ModerationAPICountCommentsResponse

Example

getCount Example

Copy

const tenantId: string = "tenant_12345";
const basicCount: ModerationAPICountCommentsResponse = await getCount(tenantId);
const detailedCount: ModerationAPICountCommentsResponse = await getCount(
  tenantId,
  "spam",
  "192.168.1.100",
  "status:pending",
  "user:john",
  true,
  "sso_token_abc"
);

getCounts

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: GetBannedUsersCountResponse

Example

getCounts Example

Copy

async function run() {
  const tenantId: string = "tenant_9876";
  const ssoToken: string = "sso_user_42";
  const resultWithOnlyTenant: GetBannedUsersCountResponse = await getCounts(tenantId);
  const resultWithBoth: GetBannedUsersCountResponse = await getCounts(tenantId, ssoToken);
}
run();

getLogs

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Response

Returns: ModerationAPIGetLogsResponse

Example

getLogs Example

Copy

(async () => {
  const tenantId: string = "acme-corp-123";
  const commentId: string = "cmt_4567890";
  const ssoToken: string = "sso_abcdef123456";
  const logsWithSso: ModerationAPIGetLogsResponse = await getLogs(tenantId, commentId, ssoToken);
  const logsWithoutSso: ModerationAPIGetLogsResponse = await getLogs(tenantId, commentId);
})();

getManualBadges

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: GetTenantManualBadgesResponse

Example

getManualBadges Example

Copy

async function fetchBadges() {
  const tenantId: string = "tenant-987654321";
  const ssoToken: string = "sso-token-abc123";
  const badgesWithSso: GetTenantManualBadgesResponse = await getManualBadges(tenantId, ssoToken);
  const badgesWithoutSso: GetTenantManualBadgesResponse = await getManualBadges(tenantId);
}

getManualBadgesForUser

Parameters

Name	Type	Required
tenantId	string	Yes
badgesUserId	string	No
commentId	string	No
sso	string	No

Response

Returns: GetUserManualBadgesResponse

Example

getManualBadgesForUser Example

Copy

async () => {
  const tenantId: string = "tenant_12345";
  const badgesUserId: string | undefined = "user_98765";
  const commentId: string | undefined = "comment_abcde";
  const sso: string | undefined = "sso_token_xyz";
  const basicResponse: GetUserManualBadgesResponse = await getManualBadgesForUser(tenantId);
  const fullResponse: GetUserManualBadgesResponse = await getManualBadgesForUser(
    tenantId,
    badgesUserId,
    commentId,
    sso
  );
  console.log(basicResponse, fullResponse);
}();

getModerationComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
includeEmail	boolean	No
includeIP	boolean	No
sso	string	No

Response

Returns: ModerationAPICommentResponse

Example

getModerationComment Example

Copy

async function fetchComments() {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_1234567890";
  // Call with only required parameters
  const basicResponse: ModerationAPICommentResponse = await getModerationComment(tenantId, commentId);
  // Call with optional parameters
  const includeEmail: boolean = true;
  const includeIP: boolean = false;
  const sso: string = "sso-token-abc123";
  const detailedResponse: ModerationAPICommentResponse = await getModerationComment(
    tenantId,
    commentId,
    includeEmail,
    includeIP,
    sso
  );
}

getModerationCommentText

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Response

Returns: GetCommentTextResponse

Example

getModerationCommentText Example

Copy

async function fetchComment() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const ssoToken: string = "sso_abcde12345";
  const commentWithoutSso: GetCommentTextResponse = await getModerationCommentText(tenantId, commentId);
  const commentWithSso: GetCommentTextResponse = await getModerationCommentText(tenantId, commentId, ssoToken);
}
fetchComment();

getPreBanSummary

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
includeByUserIdAndEmail	boolean	No
includeByIP	boolean	No
includeByEmailDomain	boolean	No
sso	string	No

Response

Returns: PreBanSummary

Example

getPreBanSummary Example

Copy

async function fetchSummary(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const includeByUserIdAndEmail: boolean = true;
  const includeByIP: boolean = false;
  const includeByEmailDomain: boolean = true;
  const sso: string = "sso_token_abc";
  const summary: PreBanSummary = await getPreBanSummary(
    tenantId,
    commentId,
    includeByUserIdAndEmail,
    includeByIP,
    includeByEmailDomain,
    sso
  );
  console.log(summary);
}
fetchSummary();

getSearchCommentsSummary

Parameters

Name	Type	Required
tenantId	string	Yes
value	string	No
filters	string	No
searchFilters	string	No
sso	string	No

Response

Returns: ModerationCommentSearchResponse

Example

getSearchCommentsSummary Example

Copy

async function runSearch() {
  const tenantId: string = "tenant_12345";
  const value: string = "spam";
  const filters: string = "status:pending";
  const searchFilters: string = "author:john";
  const sso: string = "sso_token_abc";
  const result: ModerationCommentSearchResponse = await getSearchCommentsSummary(
    tenantId,
    value,
    filters,
    searchFilters,
    sso
  );
  console.log(result);
}
runSearch();

getSearchPages

Parameters

Name	Type	Required
tenantId	string	Yes
value	string	No
sso	string	No

Response

Returns: ModerationPageSearchResponse

Example

getSearchPages Example

Copy

const tenantId: string = "acme-corp-123";
const searchValue: string = "spam";
const ssoToken: string = "sso-abc123def456";
const result1: ModerationPageSearchResponse = await getSearchPages(tenantId);
const result2: ModerationPageSearchResponse = await getSearchPages(tenantId, searchValue);
const result3: ModerationPageSearchResponse = await getSearchPages(tenantId, searchValue, ssoToken);

getSearchSites

Parameters

Name	Type	Required
tenantId	string	Yes
value	string	No
sso	string	No

Response

Returns: ModerationSiteSearchResponse

Example

getSearchSites Example

Copy

async function runSearches(): Promise<void> {
  const tenantId: string = "tenant-987654";
  const query: string = "offensive content";
  const ssoToken: string = "sso-token-xyz";
  const fullResult: ModerationSiteSearchResponse = await getSearchSites(tenantId, query, ssoToken);
  const minimalResult: ModerationSiteSearchResponse = await getSearchSites(tenantId);
}
runSearches();

getSearchSuggest

Parameters

Name	Type	Required
tenantId	string	Yes
textSearch	string	No
sso	string	No

Response

Returns: ModerationSuggestResponse

Example

getSearchSuggest Example

Copy

(async () => {
  const tenantId: string = "tenant-9f8b7c6d";
  const textSearch: string = "harassment";
  const sso: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...";
  const suggestResponse: ModerationSuggestResponse = await getSearchSuggest(tenantId, textSearch, sso);
  const minimalResponse: ModerationSuggestResponse = await getSearchSuggest(tenantId);
})();

getSearchUsers

Parameters

Name	Type	Required
tenantId	string	Yes
value	string	No
sso	string	No

Response

Returns: ModerationUserSearchResponse

Example

getSearchUsers Example

Copy

async function runSearch() {
  const tenantId: string = "tenant-9876";
  const emailFragment: string = "jane";
  const ssoToken: string = "sso-token-456";
  const resultWithAll: ModerationUserSearchResponse = await getSearchUsers(tenantId, emailFragment, ssoToken);
  const resultWithTenantOnly: ModerationUserSearchResponse = await getSearchUsers(tenantId);
}

getTrustFactor

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
sso	string	No

Response

Returns: GetUserTrustFactorResponse

Example

getTrustFactor Example

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const userId: string = "user_98765";
  const sso: string = "sso_token_abcde";
  const trustFactor: GetUserTrustFactorResponse = await getTrustFactor(tenantId);
  const trustFactorWithUser: GetUserTrustFactorResponse = await getTrustFactor(tenantId, userId);
  const trustFactorFull: GetUserTrustFactorResponse = await getTrustFactor(tenantId, userId, sso);
}

getUserBanPreference

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: APIModerateGetUserBanPreferencesResponse

Example

getUserBanPreference Example

Copy

async function demoGetUserBanPreference() {
  const tenantId: string = "tenant_987654321";
  const ssoToken: string = "sso_user_abc123xyz";
  const responseWithSso: APIModerateGetUserBanPreferencesResponse = await getUserBanPreference(tenantId, ssoToken);
  const responseWithoutSso: APIModerateGetUserBanPreferencesResponse = await getUserBanPreference(tenantId);
}

getUserInternalProfile

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	No
sso	string	No

Response

Returns: GetUserInternalProfileResponse

Example

getUserInternalProfile Example

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_9876";
  const ssoToken: string = "sso_abcde12345";
  const profileOnly: GetUserInternalProfileResponse = await getUserInternalProfile(tenantId);
  const profileWithComment: GetUserInternalProfileResponse = await getUserInternalProfile(tenantId, commentId);
  const fullProfile: GetUserInternalProfileResponse = await getUserInternalProfile(tenantId, commentId, ssoToken);
}
demo();

postAdjustCommentVotes

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
adjustCommentVotesParams	AdjustCommentVotesParams	Yes
broadcastId	string	No
sso	string	No

Response

Returns: AdjustVotesResponse

Example

postAdjustCommentVotes Example

Copy

const tenantId: string = "acme-corp";
const commentId: string = "cmt_987654321";
const adjustParams: AdjustCommentVotesParams = { voteDelta: 1 };
const broadcastId: string = "brd_112233";
const sso: string = "sso-token-xyz";
const result: AdjustVotesResponse = await postAdjustCommentVotes(
  tenantId,
  commentId,
  adjustParams,
  broadcastId,
  sso
);

postApiExport

Parameters

Name	Type	Required
tenantId	string	Yes
textSearch	string	No
byIPFromComment	string	No
filters	string	No
searchFilters	string	No
sorts	string	No
sso	string	No

Response

Returns: ModerationExportResponse

Example

postApiExport Example

Copy

async function runExport() {
  const tenantId: string = "c9f1e2b4-8a6d-4f3a-9d2e-5b6c7d8e9f0a";
  const textSearch: string = "spam";
  const byIPFromComment: string = "203.0.113.45";
  const filters: string = "status:pending";
  const searchFilters: string = "createdAt>2023-01-01";
  const sorts: string = "createdAt:desc";
  const sso: string = "sso-token-abc123";
  const fullExport: ModerationExportResponse = await postApiExport(
    tenantId,
    textSearch,
    byIPFromComment,
    filters,
    searchFilters,
    sorts,
    sso
  );
  const minimalExport: ModerationExportResponse = await postApiExport(tenantId);
  console.log(fullExport, minimalExport);
}
runExport();

postBanUserFromComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
banEmail	boolean	No
banEmailDomain	boolean	No
banIP	boolean	No
deleteAllUsersComments	boolean	No
bannedUntil	string	No
isShadowBan	boolean	No
updateId	string	No
banReason	string	No
sso	string	No

Response

Returns: BanUserFromCommentResult

Example

postBanUserFromComment Example

Copy

async function banUserExample(): Promise<void> {
  const result: BanUserFromCommentResult = await postBanUserFromComment(
    "tenant_42",
    "comment_1001",
    true,                     // banEmail
    undefined,                // banEmailDomain (omitted)
    true,                     // banIP
    false,                    // deleteAllUsersComments
    "2025-01-01T00:00:00Z",   // bannedUntil
    true,                     // isShadowBan
    undefined,                // updateId (omitted)
    "Harassment",             // banReason
    undefined                 // sso (omitted)
  );
  console.log(result);
}

postBanUserUndo

Parameters

Name	Type	Required
tenantId	string	Yes
banUserUndoParams	BanUserUndoParams	Yes
sso	string	No

Response

Returns: APIEmptyResponse

Example

postBanUserUndo Example

Copy

const tenantId: string = "tenant_9876";
const undoParams: BanUserUndoParams = {
  userId: "user_12345",
  // additional required fields can be added here
};
const resultWithoutSSO: APIEmptyResponse = await postBanUserUndo(tenantId, undoParams);
const ssoToken: string = "sso_abcdef123456";
const resultWithSSO: APIEmptyResponse = await postBanUserUndo(tenantId, undoParams, ssoToken);

postBulkPreBanSummary

Parameters

Name	Type	Required
tenantId	string	Yes
bulkPreBanParams	BulkPreBanParams	Yes
includeByUserIdAndEmail	boolean	No
includeByIP	boolean	No
includeByEmailDomain	boolean	No
sso	string	No

Response

Returns: BulkPreBanSummary

Example

postBulkPreBanSummary Example

Copy

const tenantId: string = "c1f2e3d4-5678-90ab-cdef-1234567890ab";
const bulkPreBanParams: BulkPreBanParams = {
  userIds: ["user123"],
  emails: ["spam@example.com"],
  ips: ["192.0.2.1"],
  emailDomains: ["example.com"]
};
const includeByUserIdAndEmail: boolean = true;
const includeByIP: boolean = false;
const includeByEmailDomain: boolean = true;
const sso: string = "sso-token-abc123";
const summary: BulkPreBanSummary = await postBulkPreBanSummary(
  tenantId,
  bulkPreBanParams,
  includeByUserIdAndEmail,
  includeByIP,
  includeByEmailDomain,
  sso
);

postCommentsByIds

Parameters

Name	Type	Required
tenantId	string	Yes
commentsByIdsParams	CommentsByIdsParams	Yes
sso	string	No

Response

Returns: ModerationAPIChildCommentsResponse

Example

postCommentsByIds Example

Copy

const tenantId: string = 'tenant-9f8b7c6d-1234-5678-90ab-cdef12345678';
const commentsByIdsParams: CommentsByIdsParams = {
  commentIds: ['comment-1', 'comment-2'],
  includeUserBadges: true
};
const responseWithoutSso: ModerationAPIChildCommentsResponse = await postCommentsByIds(tenantId, commentsByIdsParams);
const sso: string = 'sso-abc123def456';
const responseWithSso: ModerationAPIChildCommentsResponse = await postCommentsByIds(tenantId, commentsByIdsParams, sso);

postFlagComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	No
sso	string	No

Response

Returns: APIEmptyResponse

Example

postFlagComment Example

Copy

async function runExample() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  // Required parameters only
  const result1: APIEmptyResponse = await postFlagComment(tenantId, commentId);
  // Including optional parameters
  const broadcastId: string = "brd_54321";
  const sso: string = "user@example.com";
  const result2: APIEmptyResponse = await postFlagComment(tenantId, commentId, broadcastId, sso);
  console.log(result1, result2);
}
runExample();

postRemoveComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	No
sso	string	No

Response

Returns: PostRemoveCommentApiResponse

Example

postRemoveComment Example

Copy

async function removeCommentExample() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const broadcastId: string = "brd_555";
  const sso: string = "sso_token_abc";
  const response: PostRemoveCommentApiResponse = await postRemoveComment(
    tenantId,
    commentId,
    broadcastId,
    sso
  );
  console.log(response);
}
removeCommentExample();

postRestoreDeletedComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	No
sso	string	No

Response

Returns: APIEmptyResponse

Example

postRestoreDeletedComment Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_98765";
const resultRequired: APIEmptyResponse = await postRestoreDeletedComment(tenantId, commentId);
const broadcastId: string = "brd_001";
const sso: string = "sso_token_abc123";
const resultAll: APIEmptyResponse = await postRestoreDeletedComment(
  tenantId,
  commentId,
  broadcastId,
  sso
);

postSetCommentApprovalStatus

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
approved	boolean	No
broadcastId	string	No
sso	string	No

Response

Returns: SetCommentApprovedResponse

Example

postSetCommentApprovalStatus Example

Copy

(async () => {
  const tenantId: string = "tenant_001";
  const commentId: string = "comment_123";
  const approved: boolean = false;
  const broadcastId: string = "broadcast_456";
  const sso: string = "sso_789";
  const result: SetCommentApprovedResponse = await postSetCommentApprovalStatus(
    tenantId,
    commentId,
    approved,
    broadcastId,
    sso
  );
  const minimalResult: SetCommentApprovedResponse = await postSetCommentApprovalStatus(
    tenantId,
    commentId
  );
})();

postSetCommentReviewStatus

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
reviewed	boolean	No
broadcastId	string	No
sso	string	No

Response

Returns: APIEmptyResponse

Example

postSetCommentReviewStatus Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_98765";
const reviewed: boolean = true;
const broadcastId: string = "brd_001";
const sso: string = "sso_token_abc";
const result: APIEmptyResponse = await postSetCommentReviewStatus(
  tenantId,
  commentId,
  reviewed,
  broadcastId,
  sso
);

postSetCommentSpamStatus

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
spam	boolean	No
permNotSpam	boolean	No
broadcastId	string	No
sso	string	No

Response

Returns: APIEmptyResponse

Example

postSetCommentSpamStatus Example

Copy

const tenantId: string = "tenant_42";
const commentId: string = "comment_1001";
const spam: boolean = true;
const permNotSpam: boolean = false;
const broadcastId: string = "broadcast_2023";
const sso: string = "sso_user_5678";
const resultFull: APIEmptyResponse = await postSetCommentSpamStatus(
  tenantId,
  commentId,
  spam,
  permNotSpam,
  broadcastId,
  sso
);
const resultMinimal: APIEmptyResponse = await postSetCommentSpamStatus(
  tenantId,
  commentId
);

postSetCommentText

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
broadcastId	string	No
sso	string	No

Response

Returns: SetCommentTextResponse

Example

postSetCommentText Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_9876";
const setCommentTextParams: SetCommentTextParams = {
  text: "Revised comment after user edit.",
  format: "plain"
};
const broadcastId: string = "broadcast_2023_09";
const response: SetCommentTextResponse = await postSetCommentText(
  tenantId,
  commentId,
  setCommentTextParams,
  broadcastId
);
console.log(response);

postUnFlagComment

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	No
sso	string	No

Response

Returns: APIEmptyResponse

Example

postUnFlagComment Example

Copy

async function runExample() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "comment_98765";
  const broadcastId: string = "broadcast_55555";
  const sso: string = "sso_token_abcde";
  const result1: APIEmptyResponse = await postUnFlagComment(tenantId, commentId);
  const result2: APIEmptyResponse = await postUnFlagComment(tenantId, commentId, broadcastId, sso);
}
runExample();

postVote

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
direction	string	No
broadcastId	string	No
sso	string	No

Response

Returns: VoteResponse

Example

postVote Example

Copy

async function runVoteExamples(): Promise<void> {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_1234567890";
  // Call with only required parameters
  const simpleVote: VoteResponse = await postVote(tenantId, commentId);
  // Call with optional parameters
  const direction: string = "down";
  const broadcastId: string = "brd_987654321";
  const sso: string = "user-42";
  const detailedVote: VoteResponse = await postVote(tenantId, commentId, direction, broadcastId, sso);
  console.log(simpleVote, detailedVote);
}

putAwardBadge

Parameters

Name	Type	Required
tenantId	string	Yes
badgeId	string	Yes
userId	string	No
commentId	string	No
broadcastId	string	No
sso	string	No

Response

Returns: AwardUserBadgeResponse

Example

putAwardBadge Example

Copy

async function awardBadgeExample(): Promise<void> {
  const tenantId: string = "tenant_42";
  const badgeId: string = "badge_superstar";
  const userId: string = "user_1001";
  const commentId: string = "comment_2023";
  const result: AwardUserBadgeResponse = await putAwardBadge(
    tenantId,
    badgeId,
    userId,
    commentId
  );
  console.log(result);
}

putCloseThread

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Response

Returns: APIEmptyResponse

Example

putCloseThread Example

Copy

(async () => {
  const tenantId: string = "my-company";
  const urlId: string = "post-2023-09-15";
  const ssoToken: string = "sso-abc123def";
  const resultWithSso: APIEmptyResponse = await putCloseThread(tenantId, urlId, ssoToken);
  const resultWithoutSso: APIEmptyResponse = await putCloseThread(tenantId, urlId);
})();

putRemoveBadge

Parameters

Name	Type	Required
tenantId	string	Yes
badgeId	string	Yes
userId	string	No
commentId	string	No
broadcastId	string	No
sso	string	No

Response

Returns: RemoveUserBadgeResponse

Example

putRemoveBadge Example

Copy

async function demoRemoveBadge() {
  const tenantId: string = "tenant_42";
  const badgeId: string = "badge_gold";
  const userId: string = "user_1001";
  const commentId: string = "comment_20230915";
  const broadcastId: string = "broadcast_live_01";
  const sso: string = "sso_abcdef123456";
  const result: RemoveUserBadgeResponse = await putRemoveBadge(
    tenantId,
    badgeId,
    userId,
    commentId,
    broadcastId,
    sso
  );
  console.log(result);
}

putReopenThread

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Response

Returns: APIEmptyResponse

Example

putReopenThread Example

Copy

async function reopenThreadExample() {
    const tenantId: string = "tenant_12345";
    const urlId: string = "post-9876";
    const sso: string = "user-abc123";
    const responseWithoutSso: APIEmptyResponse = await putReopenThread(tenantId, urlId);
    const responseWithSso: APIEmptyResponse = await putReopenThread(tenantId, urlId, sso);
}
reopenThreadExample();

setTrustFactor

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
trustFactor	string	No
sso	string	No

Response

Returns: SetUserTrustFactorResponse

Example

setTrustFactor Example

Copy

async function demoSetTrustFactor() {
  const tenantId: string = "acme-corp";
  const userId: string = "user-9876";
  const trustFactor: string = "high";
  const sso: string = "sso-token-xyz";
  const fullResponse: SetUserTrustFactorResponse = await setTrustFactor(
    tenantId,
    userId,
    trustFactor,
    sso
  );
  const minimalResponse: SetUserTrustFactorResponse = await setTrustFactor(tenantId);
}

createModerator

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Response

Returns: CreateModeratorResponse

Example

createModerator Example

Copy

const tenantId: string = "tenant_12345";
const moderatorPayload: CreateModeratorBody = {
  userId: "user_9876",
  // optional field; can be omitted if not needed
  notes: "Temporary moderator for event"
};
const response: CreateModeratorResponse = await createModerator(tenantId, moderatorPayload);

deleteModerator

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
sendEmail	string	No

Response

Returns: APIEmptyResponse

Example

deleteModerator Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const moderatorId: string = "mod_9876";
  const notifyEmail: string = "admin@company.com";
  const resultWithEmail: APIEmptyResponse = await deleteModerator(tenantId, moderatorId, notifyEmail);
  const resultWithoutEmail: APIEmptyResponse = await deleteModerator(tenantId, moderatorId);
})();

getModerator

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetModeratorResponse

Example

getModerator Example

Copy

async function fetchModerator() {
  const tenantId: string = "c9f1e2b3-4d5a-6f78-90ab-cdef12345678";
  const moderatorId: string = "mod-987654";
  const response: GetModeratorResponse = await getModerator(tenantId, moderatorId);
  const isActive: boolean | undefined = response.moderator?.isActive;
  const statusCode: number | undefined = response.status?.code;
}

getModerators

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetModeratorsResponse

Example

getModerators Example

Copy

const tenantId: string = "tenant_987654321";
const moderators: GetModeratorsResponse = await getModerators(tenantId);
const skip: number = 20;
const moreModerators: GetModeratorsResponse = await getModerators(tenantId, skip);

sendInvite

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
fromName	string	Yes

Response

Returns: APIEmptyResponse

Example

sendInvite Example

Copy

const tenantId: string = "tenant-987654321";
const id: string = "user-123456789";
const fromName: string = "Alice Johnson";
const result: APIEmptyResponse = await sendInvite(tenantId, id, fromName);
console.log(result);

updateModerator

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateModeratorBody	UpdateModeratorBody	Yes

Response

Returns: APIEmptyResponse

Example

updateModerator Example

Copy

const tenantId: string = "tenant_9f8b7c6d";
const moderatorId: string = "mod_12345";
const updateBody: UpdateModeratorBody = {
  isActive: true,
  // role?: string is optional and omitted here
};
const result: APIEmptyResponse = await updateModerator(tenantId, moderatorId, updateBody);

deleteNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptyResponse

Example

deleteNotificationCount Example

Copy

let tenantId: string = "tenant-42f9b8c1";
let notificationId: string = "notif-7e3a9d4f";
const result: APIEmptyResponse = await deleteNotificationCount(tenantId, notificationId);

getCachedNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetCachedNotificationCountResponse

Example

getCachedNotificationCount Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const id: string = "user_9876";
  const response: GetCachedNotificationCountResponse = await getCachedNotificationCount(tenantId, id);
})();

getNotificationCount

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
urlId	string	No
fromCommentId	string	No
viewed	boolean	No
type	string	No

Response

Returns: GetNotificationCountResponse

Example

getNotificationCount Example

Copy

const tenantId: string = "acme-corp";
const userId: string = "user-12345";
const urlId: string = "https://app.example.com/dashboard";
const fromCommentId: string = "cmt-9876";
const viewed: boolean = false;
const type: string = "reply";
const notificationCount: GetNotificationCountResponse = await getNotificationCount(
  tenantId,
  userId,
  urlId,
  fromCommentId,
  viewed,
  type
);

getNotifications

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
urlId	string	No
fromCommentId	string	No
viewed	boolean	No
type	string	No
skip	number	No

Response

Returns: GetNotificationsResponse

Example

getNotifications Example

Copy

async function fetchNotifications(): Promise<void> {
  const tenantId: string = "tenant_42";
  const userId: string = "user_1001";
  const urlId: string = "url_2023";
  const viewed: boolean = true;
  const skip: number = 0;
  const notifications: GetNotificationsResponse = await getNotifications(
    tenantId,
    userId,
    urlId,
    undefined,
    viewed,
    undefined,
    skip
  );
  console.log(notifications);
}

updateNotification

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateNotificationBody	UpdateNotificationBody	Yes
userId	string	No

Response

Returns: APIEmptyResponse

Example

updateNotification Example

Copy

async function main(): Promise<void> {
  const tenantId: string = "tenant-abc123";
  const notificationId: string = "notif-9876";
  const updateBody: UpdateNotificationBody = {
    title: "System Maintenance",
    message: "Scheduled maintenance at 02:00 UTC.",
    enabled: true
  };
  const userId: string = "user-42";
  const resultWithoutUser: APIEmptyResponse = await updateNotification(tenantId, notificationId, updateBody);
  const resultWithUser: APIEmptyResponse = await updateNotification(tenantId, notificationId, updateBody, userId);
}

createV1PageReact

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
title	string	No
sso	string	No

Response

Returns: CreateV1PageReact

Example

createV1PageReact Example

Copy

const tenantId: string = "my-tenant-123";
const urlId: string = "article-456";
const pageTitle: string = "Understanding TypeScript Generics";
const ssoToken: string = "user-789-token";
const fullResult: CreateV1PageReact = await createV1PageReact(tenantId, urlId, pageTitle, ssoToken);
const minimalResult: CreateV1PageReact = await createV1PageReact(tenantId, urlId);

createV2PageReact

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
title	string	No
sso	string	No

Response

Returns: CreateV1PageReact

Example

createV2PageReact Example

Copy

async function run() {
  const tenantId: string = "acme-corp";
  const urlId: string = "product-page-123";
  const pageId: string = "page-456";
  const pageTitle: string = "Product Overview";
  const ssoToken: string = "jwt-token-abc123";
  const pageFull: CreateV1PageReact = await createV2PageReact(tenantId, urlId, pageId, pageTitle, ssoToken);
  const pageTitleOnly: CreateV1PageReact = await createV2PageReact(tenantId, urlId, pageId, pageTitle);
  const pageMinimal: CreateV1PageReact = await createV2PageReact(tenantId, urlId, pageId);
}
run();

deleteV1PageReact

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Response

Returns: CreateV1PageReact

Example

deleteV1PageReact Example

Copy

async function runExamples() {
  const tenantId: string = "tenant_9f8b7c6d";
  const urlId: string = "blog/post-2024-06-15";
  const ssoToken: string = "sso_user_42";
  const resultWithSso: CreateV1PageReact = await deleteV1PageReact(tenantId, urlId, ssoToken);
  const resultWithoutSso: CreateV1PageReact = await deleteV1PageReact(tenantId, urlId);
}

deleteV2PageReact

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
sso	string	No

Response

Returns: CreateV1PageReact

Example

deleteV2PageReact Example

Copy

async function runDeleteExamples() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "page_98765";
  const commentId: string = "comment_abcde";
  // Call without optional sso
  const resultWithoutSso: CreateV1PageReact = await deleteV2PageReact(tenantId, urlId, commentId);
  // Call with optional sso
  const ssoToken: string = "sso_token_xyz";
  const resultWithSso: CreateV1PageReact = await deleteV2PageReact(tenantId, urlId, commentId, ssoToken);
}

getV1PageLikes

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Response

Returns: GetV1PageLikes

Example

getV1PageLikes Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const urlId: string = "https://myblog.com/post/42";
  const ssoToken: string = "sso_user_987";
  const likesWithSSO: GetV1PageLikes = await getV1PageLikes(tenantId, urlId, ssoToken);
  const likesWithoutSSO: GetV1PageLikes = await getV1PageLikes(tenantId, urlId);
})();

getV2PageReacts

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Response

Returns: GetV2PageReacts

Example

getV2PageReacts Example

Copy

const tenantId: string = "tenant-42";
const urlId: string = "article-9876";
const ssoToken: string = "sso-abc123";
const reactsWithSso: GetV2PageReacts = await getV2PageReacts(tenantId, urlId, ssoToken);
const reactsWithoutSso: GetV2PageReacts = await getV2PageReacts(tenantId, urlId);

getV2PageReactUsers

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
sso	string	No

Response

Returns: GetV2PageReactUsersResponse

Example

getV2PageReactUsers Example

Copy

async function demoGetUsers() {
  const tenantId: string = "d4e5f6a7-89ab-4cde-f012-3456789abcde";
  const urlId: string = "blog/2024/06/fastcomments-typescript";
  const userId: string = "user_123456789";
  const ssoToken: string = "sso_token_abcdef123456";
  const responseWithSso: GetV2PageReactUsersResponse = await getV2PageReactUsers(tenantId, urlId, userId, ssoToken);
  const responseWithoutSso: GetV2PageReactUsersResponse = await getV2PageReactUsers(tenantId, urlId, userId);
}

addPage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createAPIPageData	CreateAPIPageData	Yes

Response

Returns: AddPageAPIResponse

Example

addPage Example

Copy

const tenantId: string = "tenant_9f8432b1-4c2e-4f9d-8a5d-7bc9e2f6d9a0";
const pageData: CreateAPIPageData = {
    url: "https://example.com/articles/fastcomments-intro",
    title: "FastComments Introduction",
    description: "An introductory guide to FastComments API usage.",
    tags: ["fastcomments", "api", "tutorial"],
    metadata: {
        author: "Jane Doe",
        publishedAt: "2024-03-15T08:00:00Z"
    }
};
const response: AddPageAPIResponse = await addPage(tenantId, pageData);

deletePage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeletePageAPIResponse

Example

deletePage Example

Copy

async function example() {
    const tenantId: string = "acme-corp-001";
    const pageId: string = "page-987654321";
    const result: DeletePageAPIResponse = await deletePage(tenantId, pageId);
    console.log(result);
}
example();

getOfflineUsers

Past commenters on the page who are NOT currently online. Sorted by displayName. Use this after exhausting /users/online to render a "Members" section. Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName} index from afterName forward via $gt, no $skip cost.

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
afterName	string	No
afterUserId	string	No

Response

Returns: PageUsersOfflineResponse

Example

getOfflineUsers Example

Copy

async function fetchOfflineUsers(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const urlId: string = "page_9876";
  const afterName: string = "John Doe";
  const afterUserId: string = "user_abc123";
  const offlineResponse: PageUsersOfflineResponse = await getOfflineUsers(
    tenantId,
    urlId,
    afterName,
    afterUserId
  );
  console.log(offlineResponse);
}

getOnlineUsers

Currently-online viewers of a page: people whose websocket session is subscribed to the page right now. Returns anonCount + totalCount (room-wide subscribers, including anon viewers we don't enumerate).

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
afterName	string	No
afterUserId	string	No

Response

Returns: PageUsersOnlineResponse

Example

getOnlineUsers Example

Copy

async function fetchOnlineUsers() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "article-9876";
  const afterName: string | undefined = "john_doe";
  const afterUserId: string | undefined = "user_456";
  const onlineUsers: PageUsersOnlineResponse = await getOnlineUsers(
    tenantId,
    urlId,
    afterName,
    afterUserId
  );
  console.log(onlineUsers);
}
fetchOnlineUsers();

getPageByURLId

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Response

Returns: GetPageByURLIdAPIResponse

Example

getPageByURLId Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const urlId: string = "url_9876";
  const response: GetPageByURLIdAPIResponse = await getPageByURLId(tenantId, urlId);
  const page: APIPage | undefined = response.page;
})();

getPages

Parameters

Name	Type	Required	Description
tenantId	string	Yes

Response

Returns: GetPagesAPIResponse

Example

getPages Example

Copy

const tenantId: string = "tenant_12345";
(async () => {
  const response: GetPagesAPIResponse = await getPages(tenantId);
  const firstPage: APIPage | undefined = response.pages?.[0];
  console.log(firstPage?.title);
})();

getPagesPublic

List pages for a tenant. Used by the FChat desktop client to populate its room list. Requires enableFChat to be true on the resolved custom config for each page. Pages that require SSO are filtered against the requesting user's group access.

Parameters

Name	Type	Required
tenantId	string	Yes
cursor	string	No
limit	number	No
q	string	No
sortBy	PagesSortBy	No
hasComments	boolean	No

Response

Returns: GetPublicPagesResponse

Example

getPagesPublic Example

Copy

async function fetchPublicPages() {
  const tenantId: string = "tenant_12345";
  const cursor: string = "page_5";
  const limit: number = 20;
  const query: string = "support";
  const hasComments: boolean = true;
  const response: GetPublicPagesResponse = await getPagesPublic(
    tenantId,
    cursor,
    limit,
    query,
    undefined,
    hasComments
  );
  console.log(response);
}

getUsersInfo

Bulk user info for a tenant. Given userIds, return display info from User / SSOUser. Used by the comment widget to enrich users that just appeared via a presence event. No page context: privacy is enforced uniformly (private profiles are masked).

Parameters

Name	Type	Required	Description
tenantId	string	Yes
ids	string	Yes

Response

Returns: PageUsersInfoResponse

Example

getUsersInfo Example

Copy

async function fetchUsersInfo(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const ids: string = "user_001,user_002";
  const response: PageUsersInfoResponse = await getUsersInfo(tenantId, ids);
  console.log(response);
}
fetchUsersInfo();

patchPage

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPIPageData	UpdateAPIPageData	Yes

Response

Returns: PatchPageAPIResponse

Example

patchPage Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const pageId: string = "page_98765";
  const updateData: UpdateAPIPageData = {
    title: "Updated FAQ Page"
    // description?: string can be omitted
  };
  const response: PatchPageAPIResponse = await patchPage(tenantId, pageId, updateData);
})();

deletePendingWebhookEvent

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptyResponse

Example

deletePendingWebhookEvent Example

Copy

async function runDeletion() {
  const tenantId: string = "tenant-42f7b9c2";
  const eventId: string = "webhook-event-8a7d6c5b";
  const result: APIEmptyResponse = await deletePendingWebhookEvent(tenantId, eventId);
  console.log(result);
}

getPendingWebhookEventCount

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	No
externalId	string	No
eventType	string	No
type	string	No
domain	string	No
attemptCountGT	number	No

Response

Returns: GetPendingWebhookEventCountResponse

Example

getPendingWebhookEventCount Example

Copy

async function runExample() {
  const tenantId: string = "tenant_42";
  const commentId: string = "comment_1001";
  const eventType: string = "comment.deleted";
  const domain: string = "myblog.com";
  const result: GetPendingWebhookEventCountResponse = await getPendingWebhookEventCount(
    tenantId,
    commentId,
    undefined,
    eventType,
    undefined,
    domain
  );
  console.log(result);
}
runExample();

getPendingWebhookEvents

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	No
externalId	string	No
eventType	string	No
type	string	No
domain	string	No
attemptCountGT	number	No
skip	number	No

Response

Returns: GetPendingWebhookEventsResponse

Example

getPendingWebhookEvents Example

Copy

const tenantId: string = "123e4567-e89b-12d3-a456-426614174000";
const commentId: string = "cmt_987654321";
const externalId: string = "ext_abc123";
const eventType: string = "comment_created";
const type: string = "outbound";
const domain: string = "myblog.com";
const attemptCountGT: number = 2;
const skip: number = 10;
const pendingEvents: GetPendingWebhookEventsResponse = await getPendingWebhookEvents(
  tenantId,
  commentId,
  externalId,
  eventType,
  type,
  domain,
  attemptCountGT,
  skip
);

createPollVote

Record a vote on a poll, or move an existing one to a different option. A voter has at most one vote per poll, so calling this again for the same voter moves their vote rather than adding one.

This obeys the site's poll settings: if voting is set to logged-in users only, a vote with just an anonUserId is rejected, and anonymous votes are rate limited per IP per poll.

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createPollVoteBody	CreatePollVoteBody	Yes

Response

Returns: CreatePollVoteResponse

Example

createPollVote Example

Copy

(async () => {
  const tenantId: string = "acme-corp-tenant";
  const vote: CreatePollVoteBody = {
    pollId: "poll-2024-09",
    optionId: "option-A"
    // userId is optional and omitted here
  };
  const result: CreatePollVoteResponse = await createPollVote(tenantId, vote);
  console.log(result);
})();

deletePollVote

Retract a vote. The option it was cast on gives its tally back.

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeletePollVoteResponse

Example

deletePollVote Example

Copy

async function runDeletePollVoteExample(): Promise<void> {
  const tenantId: string = "tenant_42abc";
  const pollId: string = "poll_7f9e2d";
  const result: DeletePollVoteResponse = await deletePollVote(tenantId, pollId);
  console.log(result);
}

getPollVote

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetPollVoteResponse

Example

getPollVote Example

Copy

async function fetchPollVote(): Promise<void> {
  const tenantId: string = "acme-corp-tenant";
  const pollId: string = "poll-2024-05";
  const result: GetPollVoteResponse = await getPollVote(tenantId, pollId);
  const status: APIStatus = result.status;
  const vote: PublicPollVote | undefined = result.vote;
}

getPollVotes

The individual votes behind one poll's tallies, oldest first.

A poll belongs to a comment, so votes are always read one poll at a time - commentId is required. That keeps every query on the indexes the collection already has.

Obeys the poll's privacy: an anonymous poll's votes cannot be read (poll-anonymous), here or by id.

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
voterId	string	No
optionId	string	No
skip	number	No

Response

Returns: GetPollVotesResponse

Example

getPollVotes Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_98765";
const voterId: string = "user_abc";
const optionId: string = "opt_1";
const skip: number = 20;
const pollResult: GetPollVotesResponse = await getPollVotes(
  tenantId,
  commentId,
  voterId,
  optionId,
  skip
);
console.log(pollResult);

deletePoll

Remove a poll from its comment, along with every vote cast on it. The comment itself is left alone.

Parameters

Name	Type	Required	Description
tenantId	string	Yes
commentId	string	Yes

Response

Returns: APIEmptyResponse

Example

deletePoll Example

Copy

async function runDeletePoll(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c6d";
  const commentId: string = "comment_a1b2c3d4";
  const result: APIEmptyResponse = await deletePoll(tenantId, commentId);
  console.log(result);
}

getPoll

Parameters

Name	Type	Required	Description
tenantId	string	Yes
commentId	string	Yes

Response

Returns: GetPollResponse

Example

getPoll Example

Copy

const tenantId: string = "c9f1e2b4-8a3d-4f6a-9d2e-7b5c1a2f3e4d";
const commentId: string = "a1b2c3d4e5f6g7h8i9j0";
const pollResponse: GetPollResponse = await getPoll(tenantId, commentId);
const poll: CommentPoll | undefined = pollResponse.poll;
const privacy: PollPrivacy | undefined = poll?.privacy;
const options: CommentPollOption[] | undefined = poll?.options;

patchPoll

Edit a poll in place, keeping its tallies: change the question, relabel an option, close or reopen it, or change who may see the voters. Options are addressed by id - to add, remove or reorder them, PUT the full list.

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
commentPollPatch	CommentPollPatch	Yes

Response

Returns: SavePollResponse

Example

patchPoll Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_9876543210";
  const pollPatch: CommentPollPatch = {
    question: "Which new feature would you like to see?",
    options: [
      { id: "opt-1", label: "Dark Mode" },
      { id: "opt-2", label: "Multi-language Support" }
    ]
  };
  const response: SavePollResponse = await patchPoll(tenantId, commentId, pollPatch);
  console.log(response);
})();

putPoll

Attach a poll to a comment, or set the full state of the poll it already has.

Options are matched by id: an option sent with the id of an existing option keeps its votes (and takes the new label and position), an option sent without an id is added, and existing options left out of the list are removed along with the votes cast on them.

Keeping no existing option ids on a poll that has votes deletes all of them, so that needs replaceVotes=true.

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
commentPollPutInput	CommentPollPutInput	Yes
replaceVotes	boolean	No

Response

Returns: SavePollResponse

Example

putPoll Example

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const commentId: string = "9876543210";
const optionA: CommentPollOptionInput = { text: "Dark mode" };
const optionB: CommentPollOptionInput = { text: "Light mode" };
const pollInput: CommentPollPutInput = {
  question: "Which UI theme do you prefer?",
  options: [optionA, optionB],
};
const replaceVotes: boolean = true;
const result: SavePollResponse = await putPoll(tenantId, commentId, pollInput, replaceVotes);

createQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createQuestionConfigBody	CreateQuestionConfigBody	Yes

Response

Returns: CreateQuestionConfigResponse

Example

createQuestionConfig Example

Copy

async function runExample() {
  const tenantId: string = "acme-corp-123";
  const customOption: QuestionConfigCustomOptionsInner = {
    key: "maxLength",
    value: 500,
  };
  const createQuestionConfigBody: CreateQuestionConfigBody = {
    name: "User Feedback",
    description: "Collect user feedback after purchase",
    enabled: true,
    customOptions: [customOption],
    // optional field
    tags: ["feedback", "post-purchase"],
  };
  const response: CreateQuestionConfigResponse = await createQuestionConfig(
    tenantId,
    createQuestionConfigBody
  );
  console.log(response);
}

deleteQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptyResponse

Example

deleteQuestionConfig Example

Copy

async function executeDeletion() {
  const tenantId: string = "tenant_12345";
  const configId: string = "config_9876";
  const result: APIEmptyResponse = await deleteQuestionConfig(tenantId, configId);
  console.log(result);
}
executeDeletion();

getQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetQuestionConfigResponse

Example

getQuestionConfig Example

Copy

const tenantId: string = "acme-corp-tenant";
const questionId: string = "q-987654321";
const configResponse: GetQuestionConfigResponse = await getQuestionConfig(tenantId, questionId);
const status: APIStatus = configResponse.status;
const questionConfig?: QuestionConfig = configResponse.question;
const firstOption?: QuestionConfigCustomOptionsInner = questionConfig?.customOptions?.[0];

getQuestionConfigs

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetQuestionConfigsResponse

Example

getQuestionConfigs Example

Copy

async function fetchConfigs() {
  const tenantId: string = "tenant_12345";
  const firstPage: GetQuestionConfigsResponse = await getQuestionConfigs(tenantId);
  const secondPage: GetQuestionConfigsResponse = await getQuestionConfigs(tenantId, 20);
}

updateQuestionConfig

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateQuestionConfigBody	UpdateQuestionConfigBody	Yes

Response

Returns: APIEmptyResponse

Example

updateQuestionConfig Example

Copy

(async () => {
  const tenantId: string = "acme-corp-tenant";
  const questionId: string = "question-42";
  const updateBody: UpdateQuestionConfigBody = {
    title: "Revised FAQ Question"
    // isActive, customOptions, etc. are optional and omitted
  };
  const response: APIEmptyResponse = await updateQuestionConfig(tenantId, questionId, updateBody);
  console.log(response);
})();

createQuestionResult

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createQuestionResultBody	CreateQuestionResultBody	Yes

Response

Returns: CreateQuestionResultResponse

Example

createQuestionResult Example

Copy

const tenantId: string = "tenant_12345";
const createQuestionResultBody: CreateQuestionResultBody = {
  questionId: "q_9876",
  answer: "Yes",
  score: 5,
  meta: [
    { key: "source", value: "survey" }
  ]
};
const result: CreateQuestionResultResponse = await createQuestionResult(tenantId, createQuestionResultBody);

deleteQuestionResult

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptyResponse

Example

deleteQuestionResult Example

Copy

async function runDelete() {
  const tenantId: string = "tenant_12345";
  const resultId: string = "qr_98765";
  const response: APIEmptyResponse = await deleteQuestionResult(tenantId, resultId);
  console.log(response);
}

getQuestionResult

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetQuestionResultResponse

Example

getQuestionResult Example

Copy

const tenantId: string = "tenant_12345";
const questionId: string = "question_98765";
const response: GetQuestionResultResponse = await getQuestionResult(tenantId, questionId);
const status: APIStatus | undefined = response.status;
const firstResult: QuestionResult | undefined = response.results?.[0];
const firstMeta: MetaItem | undefined = response.meta?.[0];
console.log(response);

getQuestionResults

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	No
userId	string	No
startDate	string	No
questionId	string	No
questionIds	string	No
skip	number	No

Response

Returns: GetQuestionResultsResponse

Example

getQuestionResults Example

Copy

async function fetchResults() {
  const tenantId: string = 'c1a2b3d4-5678-90ab-cdef-1234567890ab';
  const urlId: string = 'blog-post-789';
  const startDate: string = '2023-01-01T00:00:00Z';
  const questionIds: string = 'q-abc123,q-def456';
  const response: GetQuestionResultsResponse = await getQuestionResults(
    tenantId,
    urlId,
    undefined,
    startDate,
    undefined,
    questionIds
  );
  console.log(response);
}

updateQuestionResult

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateQuestionResultBody	UpdateQuestionResultBody	Yes

Response

Returns: APIEmptyResponse

Example

updateQuestionResult Example

Copy

const tenantId: string = "c1f5e8b2-9a4d-4f3a-8d2e-6b7c9d0e1f2a";
const questionId: string = "qstn_1234567890";
const updateBody: UpdateQuestionResultBody = {
  score: 85,
  comment: "Adjusted based on new criteria",
  meta: [
    { key: "reviewer", value: "john.doe@example.com" },
    { key: "timestamp", value: new Date().toISOString() }
  ]
};
const response: APIEmptyResponse = await updateQuestionResult(tenantId, questionId, updateBody);

aggregateQuestionResults

Parameters

Name	Type	Required
tenantId	string	Yes
questionId	string	No
questionIds	Array	No
urlId	string	No
timeBucket	AggregateTimeBucket	No
startDate	Date	No
forceRecalculate	boolean	No

Response

Returns: AggregateQuestionResultsResponse

Example

aggregateQuestionResults Example

Copy

async function runAggregation() {
  const tenantId: string = '123e4567-e89b-12d3-a456-426614174000';
  const questionId: string = 'question-9f8e7d6c5b4a3';
  const questionIds: string[] = ['question-1a2b3c', 'question-4d5e6f'];
  const urlId: string = 'blog-post-2023-08-15';
  const startDate: Date = new Date('2023-01-01T00:00:00Z');
  const forceRecalculate: boolean = true;
  const result: AggregateQuestionResultsResponse = await aggregateQuestionResults(
    tenantId,
    questionId,
    questionIds,
    urlId,
    undefined,
    startDate,
    forceRecalculate
  );
}

bulkAggregateQuestionResults

Parameters

Name	Type	Required
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	boolean	No

Response

Returns: BulkAggregateQuestionResultsResponse

Example

bulkAggregateQuestionResults Example

Copy

const tenantId: string = "tenant_12345";
const request: BulkAggregateQuestionResultsRequest = {
  items: [
    {
      questionId: "q_9876",
      startDate: "2023-01-01T00:00:00Z",
      endDate: "2023-01-31T23:59:59Z",
      timeBucket: "day"
    }
  ]
};
const response: BulkAggregateQuestionResultsResponse = await bulkAggregateQuestionResults(tenantId, request, true);

combineCommentsWithQuestionResults

Parameters

Name	Type	Required
tenantId	string	Yes
questionId	string	No
questionIds	Array	No
urlId	string	No
startDate	Date	No
forceRecalculate	boolean	No
minValue	number	No
maxValue	number	No
limit	number	No

Response

Returns: CombineQuestionResultsWithCommentsResponse

Example

combineCommentsWithQuestionResults Example

Copy

async function runExample() {
  const tenantId: string = "tenant_12345";
  const questionId: string | undefined = "q_987";
  const questionIds: string[] = ["q_001", "q_002"];
  const urlId: string | undefined = "url_abc";
  const startDate: Date = new Date("2023-01-01T00:00:00Z");
  const forceRecalculate: boolean = true;
  const minValue: number = 0;
  const maxValue: number = 100;
  const limit: number = 50;
  const result: CombineQuestionResultsWithCommentsResponse = await combineCommentsWithQuestionResults(
    tenantId,
    questionId,
    questionIds,
    urlId,
    startDate,
    forceRecalculate,
    minValue,
    maxValue,
    limit
  );
  console.log(result);
}
runExample();

addSSOUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

Response

Returns: AddSSOUserAPIResponse

Example

addSSOUser Example

Copy

const tenantId: string = "tenant_12345";
const newUser: CreateAPISSOUserData = {
  userId: "sso_user_987",
  name: "Jane Doe",
  email: "jane.doe@example.com",
  // optional field
  avatarUrl: "https://example.com/avatars/jane.jpg",
};
const result: AddSSOUserAPIResponse = await addSSOUser(tenantId, newUser);

deleteSSOUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
deleteComments	boolean	No
commentDeleteMode	string	No

Response

Returns: DeleteSSOUserAPIResponse

Example

deleteSSOUser Example

Copy

const tenantId: string = "acme-corp-tenant";
const userId: string = "sso-user-42";
const deleteComments: boolean = true;
const commentDeleteMode: string = "hard";
const detailedResult: DeleteSSOUserAPIResponse = await deleteSSOUser(
  tenantId,
  userId,
  deleteComments,
  commentDeleteMode
);
const simpleResult: DeleteSSOUserAPIResponse = await deleteSSOUser(
  tenantId,
  userId
);

getSSOUserByEmail

Parameters

Name	Type	Required	Description
tenantId	string	Yes
email	string	Yes

Response

Returns: GetSSOUserByEmailAPIResponse

Example

getSSOUserByEmail Example

Copy

async function fetchSSOUser() {
  const tenantId: string = "tenant_12345";
  const email: string = "john.doe@example.com";
  const result: GetSSOUserByEmailAPIResponse = await getSSOUserByEmail(tenantId, email);
  const user: APISSOUser | undefined = result?.user;
}

getSSOUserById

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetSSOUserByIdAPIResponse

Example

getSSOUserById Example

Copy

async function fetchUser() {
  const tenantId: string = "tenant-987654321";
  const userId: string = "sso-user-abc123";
  const result: GetSSOUserByIdAPIResponse = await getSSOUserById(tenantId, userId);
  const ssoUser: APISSOUser = result.user;
}

getSSOUsers

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetSSOUsersResponse

Example

getSSOUsers Example

Copy

async function runExample(): Promise<void> {
    const tenantId: string = "tenant_12345";
    // Call without optional `skip`
    const firstPage: GetSSOUsersResponse = await getSSOUsers(tenantId);
    // Call with optional `skip`
    const secondPage: GetSSOUsersResponse = await getSSOUsers(tenantId, 100);
    console.log(firstPage, secondPage);
}
runExample();

patchSSOUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	boolean	No

Response

Returns: PatchSSOUserAPIResponse

Example

patchSSOUser Example

Copy

const tenantId: string = "c1f2a3b4-5678-90ab-cdef-1234567890ab";
const userId: string = "user-987654321";
const updateData: UpdateAPISSOUserData = {
  email: "jane.smith@enterprise.com",
  displayName: "Jane Smith",
  role: "editor"
};
const responseWithComments: PatchSSOUserAPIResponse = await patchSSOUser(
  tenantId,
  userId,
  updateData,
  true
);
const responseWithoutComments: PatchSSOUserAPIResponse = await patchSSOUser(
  tenantId,
  userId,
  updateData
);

putSSOUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPISSOUserData	UpdateAPISSOUserData	Yes
updateComments	boolean	No

Response

Returns: PutSSOUserAPIResponse

Example

putSSOUser Example

Copy

(async () => {
  const tenantId: string = "tenant_abc123";
  const userId: string = "user_456def";
  const updateData: UpdateAPISSOUserData = {
    email: "jane.doe@example.com",
    displayName: "Jane Doe",
    isActive: true,
  };
  const response: PutSSOUserAPIResponse = await putSSOUser(tenantId, userId, updateData, true);
})();

createSubscription

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Yes

Response

Returns: CreateSubscriptionAPIResponse

Example

createSubscription Example

Copy

(async () => {
    const tenantId: string = "acme-corp-123";
    const subscriptionData: CreateAPIUserSubscriptionData = {
        userId: "user-456",
        planId: "premium-monthly",
        startDate: new Date(),
        trialPeriodDays: 14 // optional field
    };
    const result: CreateSubscriptionAPIResponse = await createSubscription(tenantId, subscriptionData);
    console.log(result);
})();

deleteSubscription

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
userId	string	No

Response

Returns: DeleteSubscriptionAPIResponse

Example

deleteSubscription Example

Copy

(async () => {
  const tenantId: string = "tenant_9876";
  const subscriptionId: string = "sub_54321";
  const userId: string = "user_abc123";
  // With optional userId
  const responseWithUser: DeleteSubscriptionAPIResponse = await deleteSubscription(tenantId, subscriptionId, userId);
  // Without optional userId
  const responseWithoutUser: DeleteSubscriptionAPIResponse = await deleteSubscription(tenantId, subscriptionId);
})();

getSubscriptions

Parameters

Name	Type	Required	Description
tenantId	string	Yes
userId	string	No

Response

Returns: GetSubscriptionsAPIResponse

Example

getSubscriptions Example

Copy

(async () => {
    const tenantId: string = "acme-corp-123";
    const userId: string = "user-789";
    const responseWithUser: GetSubscriptionsAPIResponse = await getSubscriptions(tenantId, userId);
    const responseWithoutUser: GetSubscriptionsAPIResponse = await getSubscriptions(tenantId);
})();

updateSubscription

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Yes
userId	string	No

Response

Returns: UpdateSubscriptionAPIResponse

Example

updateSubscription Example

Copy

const tenantId: string = "tenant_12345";
const subscriptionId: string = "sub_98765";
const updateData: UpdateAPIUserSubscriptionData = {
  planId: "premium_plan",
  status: "active",
  renewalDate: "2024-12-31",
};
const userId: string = "user_abcde";
const response: UpdateSubscriptionAPIResponse = await updateSubscription(
  tenantId,
  subscriptionId,
  updateData,
  userId
);

getTenantDailyUsages

Parameters

Name	Type	Required
tenantId	string	Yes
yearNumber	number	No
monthNumber	number	No
dayNumber	number	No
skip	number	No

Response

Returns: GetTenantDailyUsagesResponse

Example

getTenantDailyUsages Example

Copy

async function demoGetTenantDailyUsages() {
  const tenantId: string = "tenant_9876";
  const yearNumber: number = 2024;
  const monthNumber: number = 2;
  const dayNumber: number = 28;
  const skip: number = 10;
  const fullResult: GetTenantDailyUsagesResponse = await getTenantDailyUsages(
    tenantId,
    yearNumber,
    monthNumber,
    dayNumber,
    skip
  );
  const partialResult: GetTenantDailyUsagesResponse = await getTenantDailyUsages(
    tenantId,
    yearNumber
  );
}

createTenantPackage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createTenantPackageBody	CreateTenantPackageBody	Yes

Response

Returns: CreateTenantPackageResponse

Example

createTenantPackage Example

Copy

async function runExample() {
  const tenantId: string = "tenant_9f8b7c6d";
  const createTenantPackageBody: CreateTenantPackageBody = {
    name: "Enterprise Package",
    priceCents: 49999,
    // optional field
    description: "Full suite of enterprise features"
  };
  const result: CreateTenantPackageResponse = await createTenantPackage(tenantId, createTenantPackageBody);
  console.log(result);
}
runExample();

deleteTenantPackage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptyResponse

Example

deleteTenantPackage Example

Copy

let tenantId: string = "tenant_12345";
let packageId: string = "pkg_98765";
const result: APIEmptyResponse = await deleteTenantPackage(tenantId, packageId);

getTenantPackage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetTenantPackageResponse

Example

getTenantPackage Example

Copy

function fetchPackage(tenantId?: string, id?: string): Promise<GetTenantPackageResponse> {
    const tid: string = tenantId ?? "acme-corp-001";
    const pid: string = id ?? "premium-plan-2024";
    return getTenantPackage(tid, pid);
}
async function runExample(): Promise<void> {
    const response: GetTenantPackageResponse = await fetchPackage();
    const status: APIStatus | undefined = response.status;
    const pkg: TenantPackage | undefined = response.package;
}

getTenantPackages

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetTenantPackagesResponse

Example

getTenantPackages Example

Copy

async function fetchPackages() {
  const tenantId: string = "acme-corp-001";
  const skip: number = 15;
  const resultWithSkip: GetTenantPackagesResponse = await getTenantPackages(tenantId, skip);
  const resultWithoutSkip: GetTenantPackagesResponse = await getTenantPackages(tenantId);
}

replaceTenantPackage

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
replaceTenantPackageBody	ReplaceTenantPackageBody	Yes

Response

Returns: APIEmptyResponse

Example

replaceTenantPackage Example

Copy

async function replacePackageDemo(): Promise<void> {
  const tenantId: string = "acme-corp-001";
  const packageId: string = "basic-plan-2023";
  const replaceBody: ReplaceTenantPackageBody = {
    newPackageId: "enterprise-plan-2024"
    // optional fields can be added here if needed
  };
  const response: APIEmptyResponse = await replaceTenantPackage(tenantId, packageId, replaceBody);
  console.log(response);
}

updateTenantPackage

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateTenantPackageBody	UpdateTenantPackageBody	Yes

Response

Returns: APIEmptyResponse

Example

updateTenantPackage Example

Copy

const tenantId: string = "tenant_9f8b7c6d";
const packageId: string = "pkg_3a2b1c";
const updateBody: UpdateTenantPackageBody = {
  // optional fields can be omitted or included as needed
  // newPackageName?: string;
  // renewalDate?: string;
};
const result: APIEmptyResponse = await updateTenantPackage(tenantId, packageId, updateBody);

createTenantUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createTenantUserBody	CreateTenantUserBody	Yes

Response

Returns: CreateTenantUserResponse

Example

createTenantUser Example

Copy

async function addTenantUser() {
  const tenantId: string = '123e4567-e89b-12d3-a456-426614174000';
  const digestFreq: DigestEmailFrequency = 'daily';
  const body: CreateTenantUserBody = {
    email: 'jane.doe@example.com',
    firstName: 'Jane',
    lastName: 'Doe',
    role: 'admin',
    digestEmailFrequency: digestFreq,
    phoneNumber: '+15551234567' // optional
  };
  const response: CreateTenantUserResponse = await createTenantUser(tenantId, body);
  console.log(response);
}
addTenantUser();

deleteTenantUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
deleteComments	string	No
commentDeleteMode	string	No

Response

Returns: APIEmptyResponse

Example

deleteTenantUser Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const userId: string = "u-112233";
  const result1: APIEmptyResponse = await deleteTenantUser(tenantId, userId);
  const result2: APIEmptyResponse = await deleteTenantUser(tenantId, userId, "true", "hard");
  console.log(result1, result2);
})();

getTenantUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetTenantUserResponse

Example

getTenantUser Example

Copy

(async () => {
    const tenantId: string = "acme-tenant-001";
    const userId: string = "user-12345";
    const response: GetTenantUserResponse = await getTenantUser(tenantId, userId);
    console.log(response);
})();

getTenantUsers

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetTenantUsersResponse

Example

getTenantUsers Example

Copy

const tenantId: string = "tenant_12345";
const skip: number = 20;
const firstPage: GetTenantUsersResponse = await getTenantUsers(tenantId);
const secondPage: GetTenantUsersResponse = await getTenantUsers(tenantId, skip);

replaceTenantUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Response

Returns: APIEmptyResponse

Example

replaceTenantUser Example

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const userId: string = "user-987654321";
const replaceBody: ReplaceTenantUserBody = {
  email: "newuser@example.com",
  name: "New User",
  role: "admin"
};
const response: APIEmptyResponse = await replaceTenantUser(
  tenantId,
  userId,
  replaceBody,
  "Migrated user to new tenant"
);

sendLoginLink

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

Response

Returns: APIEmptyResponse

Example

sendLoginLink Example

Copy

interface APIStatus {
  // status fields
}
interface APIEmptyResponse {
  status: APIStatus;
}
(async () => {
  const tenantId: string = "acme-corp";
  const userId: string = "user-98765";
  const redirectURL: string = "https://app.example.com/welcome";
  const responseWithRedirect: APIEmptyResponse = await sendLoginLink(tenantId, userId, redirectURL);
  const responseWithoutRedirect: APIEmptyResponse = await sendLoginLink(tenantId, userId);
})();

updateTenantUser

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateTenantUserBody	UpdateTenantUserBody	Yes
updateComments	string	No

Response

Returns: APIEmptyResponse

Example

updateTenantUser Example

Copy

async function runUpdate() {
  const tenantId: string = "tenant_12345";
  const userId: string = "user_987";
  const updateBody: UpdateTenantUserBody = {
    email: "new.email@example.com",
    role: "admin",
    isActive: true
  };
  const comment: string = "Promoted to admin role";
  const result: APIEmptyResponse = await updateTenantUser(tenantId, userId, updateBody, comment);
  console.log(result);
}
runUpdate();

createTenant

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

Response

Returns: CreateTenantResponse

Example

createTenant Example

Copy

async function run() {
  const tenantId: string = "acme-corp-2024";
  const createTenantBody: CreateTenantBody = {
    name: "Acme Corp",
    domainConfiguration: { domain: "comments.acme.com", sslEnabled: true },
    importedSite: { siteId: "site-123", source: "wordpress" },
    billingInfo: { plan: "enterprise", renewalDate: "2025-01-01" },
    description: "Tenant for Acme Corp's production environment", // optional
  };
  const response: CreateTenantResponse = await createTenant(tenantId, createTenantBody);
}
run();

deleteTenant

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
sure	string	No

Response

Returns: APIEmptyResponse

Example

deleteTenant Example

Copy

async function main(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const userId: string = "user_9876";
  const resultWithoutSure: APIEmptyResponse = await deleteTenant(tenantId, userId);
  const resultWithSure: APIEmptyResponse = await deleteTenant(tenantId, userId, "confirm");
}
main();

getTenant

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetTenantResponse

Example

getTenant Example

Copy

async function fetchTenant(): Promise<void> {
    const tenantId: string = "tenant_12345";
    const id: string = "tenant_12345";
    const tenantResponse: GetTenantResponse = await getTenant(tenantId, id);
    // Optional fields in the response
    const billing: BillingInfo | undefined = tenantResponse.billingInfo;
    const domainConfig: APIDomainConfiguration | undefined = tenantResponse.domainConfiguration;
}

getTenants

Parameters

Name	Type	Required
tenantId	string	Yes
meta	string	No
skip	number	No

Response

Returns: GetTenantsResponse

Example

getTenants Example

Copy

async function runExample() {
    const tenantId: string = "c3f5e9b2-4d1a-4f2b-9a6e-1234567890ab";
    const meta: string = "includeBilling";
    const skip: number = 10;
    const result: GetTenantsResponse = await getTenants(tenantId, meta, skip);
    console.log(result);
}
runExample();

updateTenant

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

Response

Returns: APIEmptyResponse

Example

updateTenant Example

Copy

async function runUpdateTenant() {
  const tenantId: string = "tenant-abc123";
  const id: string = "config-456def";
  const updateTenantBody: UpdateTenantBody = {
    // required field
    name: "Acme International",
    // optional fields can be omitted, e.g., billingInfo, domainConfiguration
  };
  const response: APIEmptyResponse = await updateTenant(tenantId, id, updateTenantBody);
  console.log(response);
}

changeTicketState

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	Yes
id	string	Yes
changeTicketStateBody	ChangeTicketStateBody	Yes

Response

Returns: ChangeTicketStateResponse

Example

changeTicketState Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const userId: string = "john.doe";
  const ticketId: string = "ticket-20230915-001";
  const changeTicketStateBody: ChangeTicketStateBody = {
    // optional field example
    note: "Resolved after investigation"
  };
  const response: ChangeTicketStateResponse = await changeTicketState(
    tenantId,
    userId,
    ticketId,
    changeTicketStateBody
  );
  console.log(response);
})();

createTicket

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	Yes
createTicketBody	CreateTicketBody	Yes

Response

Returns: CreateTicketResponse

Example

createTicket Example

Copy

async function submitTicket() {
  const tenantId: string = "acme-corp";
  const userId: string = "user-9876";
  const ticketBody: CreateTicketBody = {
    subject: "Login issues after password reset",
    description: "User reports being unable to log in despite using the new password.",
    priority: "medium",
    // optional field in CreateTicketBody
    tags: ["login", "password-reset"]
  };
  const response: CreateTicketResponse = await createTicket(tenantId, userId, ticketBody);
  console.log(response);
}
submitTicket();

getTicket

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
userId	string	No

Response

Returns: GetTicketResponse

Example

getTicket Example

Copy

async function fetchTickets() {
  const tenantId: string = "acme-corp";
  const ticketId: string = "ticket-12345";
  const userId: string = "user-9876";
  const ticketWithUser: GetTicketResponse = await getTicket(tenantId, ticketId, userId);
  const ticketWithoutUser: GetTicketResponse = await getTicket(tenantId, ticketId);
}

getTickets

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
state	number	No
skip	number	No
limit	number	No

Response

Returns: GetTicketsResponse

Example

getTickets Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const ticketsSimple: GetTicketsResponse = await getTickets(tenantId);
  const userId: string = "user_9876";
  const state: number = 1; // e.g., open
  const skip: number = 0;
  const limit: number = 20;
  const ticketsFull: GetTicketsResponse = await getTickets(
    tenantId,
    userId,
    state,
    skip,
    limit
  );
})();

getTranslations

Parameters

Name	Type	Required
namespace	string	Yes
component	string	Yes
locale	string	No
useFullTranslationIds	boolean	No

Response

Returns: GetTranslationsResponse

Example

getTranslations Example

Copy

async function fetchTranslations() {
  const adminDashboard: GetTranslationsResponse = await getTranslations('admin', 'dashboard');
  const userProfileFr: GetTranslationsResponse = await getTranslations('user', 'profile', 'fr-FR', true);
}

uploadImage

Upload and resize an image

Parameters

Name	Type	Required
tenantId	string	Yes
file	Blob	Yes
sizePreset	SizePreset	No
urlId	string	No

Response

Returns: UploadImageResponse

Example

uploadImage Example

Copy

const tenantId: string = "acme-tenant-01";
const imageBlob: Blob = new Blob([new Uint8Array([137,80,78,71])], { type: "image/png" });
const uploadResult1: UploadImageResponse = await uploadImage(tenantId, imageBlob);
const sizePreset: SizePreset = { presetName: "medium" };
const urlId: string = "article-9876";
const uploadResult2: UploadImageResponse = await uploadImage(tenantId, imageBlob, sizePreset, urlId);

getUserBadgeProgressById

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIGetUserBadgeProgressResponse

Example

getUserBadgeProgressById Example

Copy

const tenantId: string = "acme-corp-tenant";
const badgeId: string = "badge-2024-07";
const result: APIGetUserBadgeProgressResponse = await getUserBadgeProgressById(tenantId, badgeId);
const progress: UserBadgeProgress | undefined = result?.progress;
const status: APIStatus | undefined = result?.status;

getUserBadgeProgressByUserId

Parameters

Name	Type	Required	Description
tenantId	string	Yes
userId	string	Yes

Response

Returns: APIGetUserBadgeProgressResponse

Example

getUserBadgeProgressByUserId Example

Copy

const tenantId: string = "acme-corp";
const userId: string = "user-42";
const badgeProgress: APIGetUserBadgeProgressResponse = await getUserBadgeProgressByUserId(tenantId, userId);
if (badgeProgress.status?.code !== undefined) {
  const statusCode: number = badgeProgress.status.code;
}
if (badgeProgress.progress?.length) {
  const firstProgress: UserBadgeProgress = badgeProgress.progress[0];
}

getUserBadgeProgressList

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
limit	number	No
skip	number	No

Response

Returns: APIGetUserBadgeProgressListResponse

Example

getUserBadgeProgressList Example

Copy

(async () => {
  const tenantId: string = "tenant-9f8b7c6d";
  const userId: string = "user-123e4567-e89b-12d3-a456-426614174000";
  const limit: number = 10;
  const skip: number = 0;
  const response: APIGetUserBadgeProgressListResponse = await getUserBadgeProgressList(tenantId, userId, limit, skip);
  const status: APIStatus = response.status;
  const badges: UserBadgeProgress[] = response.badges;
})();

createUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createUserBadgeParams	CreateUserBadgeParams	Yes

Response

Returns: APICreateUserBadgeResponse

Example

createUserBadge Example

Copy

async function main(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c";
  const badgeParams: CreateUserBadgeParams = {
    name: "Community Helper",
    iconUrl: "https://cdn.example.com/badges/helper.png"
  };
  const response: APICreateUserBadgeResponse = await createUserBadge(tenantId, badgeParams);
}
main();

deleteUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptySuccessResponse

Example

deleteUserBadge Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const badgeId: string = "moderator-badge";
  const result: APIEmptySuccessResponse = await deleteUserBadge(tenantId, badgeId);
  console.log(result);
})();

getUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIGetUserBadgeResponse

Example

getUserBadge Example

Copy

async function demoGetUserBadge() {
    const tenantId: string = "tenant-9f8b7c6d";
    const userId: string = "user-123456";
    const badgeResponse: APIGetUserBadgeResponse = await getUserBadge(tenantId, userId);
}

getUserBadges

Parameters

Name	Type	Required
tenantId	string	Yes
userId	string	No
badgeId	string	No
type	number	No
displayedOnComments	boolean	No
limit	number	No
skip	number	No

Response

Returns: APIGetUserBadgesResponse

Example

getUserBadges Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  // All parameters supplied
  const fullResponse: APIGetUserBadgesResponse = await getUserBadges(
    tenantId,
    "user-42",
    "badge-premium",
    1,
    true,
    10,
    0
  );
  // Only required and one optional parameter (limit)
  const limitedResponse: APIGetUserBadgesResponse = await getUserBadges(
    tenantId,
    undefined,
    undefined,
    undefined,
    undefined,
    5
  );
  console.log(fullResponse, limitedResponse);
})();

updateUserBadge

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Response

Returns: APIEmptySuccessResponse

Example

updateUserBadge Example

Copy

const tenantId: string = "tenant-9f8b7c6d";
const id: string = "user-4a3b2c1d";
const updateParams: UpdateUserBadgeParams = {
  badgeId: "badge-premium",
  // optional field
  expiresAt: new Date("2025-12-31T23:59:59Z")
};
const result: APIEmptySuccessResponse = await updateUserBadge(tenantId, id, updateParams);

getUserNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: GetUserNotificationCountResponse

Example

getUserNotificationCount Example

Copy

async function demo(): Promise<void> {
  const tenantId: string = "acme-corp-001";
  const ssoToken: string = "sso-token-xyz789";
  const countWithoutSso: GetUserNotificationCountResponse = await getUserNotificationCount(tenantId);
  const countWithSso: GetUserNotificationCountResponse = await getUserNotificationCount(tenantId, ssoToken);
}
demo();

getUserNotifications

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	No
pageSize	number	No
afterId	string	No
includeContext	boolean	No
afterCreatedAt	number	No
unreadOnly	boolean	No
dmOnly	boolean	No
noDm	boolean	No
includeTranslations	boolean	No
includeTenantNotifications	boolean	No
sso	string	No

Response

Returns: GetMyNotificationsResponse

Example

getUserNotifications Example

Copy

async function fetchNotifications(): Promise<void> {
  const tenantId: string = "acme-corp";
  const urlId: string = "article-42";
  const pageSize: number = 20;
  const includeContext: boolean = true;
  const unreadOnly: boolean = true;
  const notifications: GetMyNotificationsResponse = await getUserNotifications(
    tenantId,
    urlId,
    pageSize,
    undefined,
    includeContext,
    undefined,
    unreadOnly
  );
  console.log(notifications);
}

resetUserNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: ResetUserNotificationsResponse

Example

resetUserNotificationCount Example

Copy

async function demoReset() {
  const tenantId: string = "tenant_12345";
  const ssoToken: string = "sso_abcdef123456";
  const resultWithSso: ResetUserNotificationsResponse = await resetUserNotificationCount(tenantId, ssoToken);
  const resultWithoutSso: ResetUserNotificationsResponse = await resetUserNotificationCount(tenantId);
}
demoReset();

resetUserNotifications

Parameters

Name	Type	Required
tenantId	string	Yes
afterId	string	No
afterCreatedAt	number	No
unreadOnly	boolean	No
dmOnly	boolean	No
noDm	boolean	No
sso	string	No

Response

Returns: ResetUserNotificationsResponse

Example

resetUserNotifications Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const afterId: string = "notif-2023-09-01";
  const afterCreatedAt: number = 1693526400; // Unix timestamp
  const unreadOnly: boolean = true;
  const dmOnly: boolean = false;
  const response: ResetUserNotificationsResponse = await resetUserNotifications(
    tenantId,
    afterId,
    afterCreatedAt,
    unreadOnly,
    dmOnly
  );
  console.log(response);
})();

updateUserNotificationCommentSubscriptionStatus

Enable or disable notifications for a specific comment.

Parameters

Name	Type	Required
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	UpdateUserNotificationCommentSubscriptionStatusOptedInOrOutEnum	Yes
commentId	string	Yes
sso	string	No

Response

Returns: UpdateUserNotificationCommentSubscriptionStatusResponse

Example

updateUserNotificationCommentSubscriptionStatus Example

Copy

async function runExample(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const notificationId: string = "notif_9876";
  const commentId: string = "comment_abc123";
  const optedInOrOut: UpdateUserNotificationCommentSubscriptionStatusOptedInOrOutEnum =
    UpdateUserNotificationCommentSubscriptionStatusOptedInOrOutEnum.OptIn;
  const sso: string = "sso_token_456";
  const resultWithSso: UpdateUserNotificationCommentSubscriptionStatusResponse = await updateUserNotificationCommentSubscriptionStatus(
    tenantId,
    notificationId,
    optedInOrOut,
    commentId,
    sso
  );
  const resultWithoutSso: UpdateUserNotificationCommentSubscriptionStatusResponse = await updateUserNotificationCommentSubscriptionStatus(
    tenantId,
    notificationId,
    optedInOrOut,
    commentId
  );
}

updateUserNotificationPageSubscriptionStatus

Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	UpdateUserNotificationPageSubscriptionStatusSubscribedOrUnsubscribedEnum	Yes
sso	string	No

Response

Returns: UpdateUserNotificationPageSubscriptionStatusResponse

Example

updateUserNotificationPageSubscriptionStatus Example

Copy

async function runExample() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "url_9876";
  const url: string = "https://example.com/articles/awesome-article";
  const pageTitle: string = "Awesome Article";
  const subscribedOrUnsubscribed: UpdateUserNotificationPageSubscriptionStatusSubscribedOrUnsubscribedEnum =
    UpdateUserNotificationPageSubscriptionStatusSubscribedOrUnsubscribedEnum.Subscribed;
  const sso: string = "sso_token_abc";
  const response: UpdateUserNotificationPageSubscriptionStatusResponse = await updateUserNotificationPageSubscriptionStatus(
    tenantId,
    urlId,
    url,
    pageTitle,
    subscribedOrUnsubscribed,
    sso
  );
  console.log(response);
}
runExample();

updateUserNotificationStatus

Parameters

Name	Type	Required
tenantId	string	Yes
notificationId	string	Yes
newStatus	UpdateUserNotificationStatusNewStatusEnum	Yes
sso	string	No

Response

Returns: UpdateUserNotificationStatusResponse

Example

updateUserNotificationStatus Example

Copy

const tenantId: string = "tenant_12345";
const notificationId: string = "notif_9876";
const newStatus: UpdateUserNotificationStatusNewStatusEnum = UpdateUserNotificationStatusNewStatusEnum.READ;
const ssoToken: string = "sso_token_abc";
const responseWithSso: UpdateUserNotificationStatusResponse = await updateUserNotificationStatus(
  tenantId,
  notificationId,
  newStatus,
  ssoToken
);
const responseWithoutSso: UpdateUserNotificationStatusResponse = await updateUserNotificationStatus(
  tenantId,
  notificationId,
  newStatus
);

getUserPresenceStatuses

Parameters

Name	Type	Required
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Response

Returns: GetUserPresenceStatusesResponse

Example

getUserPresenceStatuses Example

Copy

(async () => {
  const tenantId: string = "my-tenant-42";
  const urlIdWS: string = "post-9876";
  const userIds: string = "alice,bob,carol";
  const presence: GetUserPresenceStatusesResponse = await getUserPresenceStatuses(tenantId, urlIdWS, userIds);
  console.log(presence);
})();

searchUsers

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
usernameStartsWith	string	No
mentionGroupIds	Array	No
sso	string	No
searchSection	SearchUsersSearchSectionEnum	No

Response

Returns: SearchUsersResult

Example

searchUsers Example

Copy

async function example() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "article-9876";
  const usernameStartsWith: string = "john";
  const mentionGroupIds: string[] = ["group1", "group2"];
  const sso: string = "sso_token_abc";
  const searchSection: SearchUsersSearchSectionEnum = SearchUsersSearchSectionEnum.MENTIONS;
  const result: SearchUsersResult = await searchUsers(
    tenantId,
    urlId,
    usernameStartsWith,
    mentionGroupIds,
    sso,
    searchSection
  );
  console.log(result);
}

getUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetUserResponse

Example

getUser Example

Copy

async function main(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const id: string = "user_98765";
  const response: GetUserResponse = await getUser(tenantId, id);
  const { user }: { user?: User } = response;
}
main();

createVote

Parameters

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
direction	CreateVoteDirectionEnum	Yes
userId	string	No
anonUserId	string	No

Response

Returns: VoteResponse

Example

createVote Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "comment_67890";
const direction: CreateVoteDirectionEnum = CreateVoteDirectionEnum.UP;
const userId: string = "user_abcde";
const voteResult: VoteResponse = await createVote(tenantId, commentId, direction, userId);
const anonUserId: string = "anon_zyxwv";
const anonVoteResult: VoteResponse = await createVote(tenantId, commentId, direction, undefined, anonUserId);

deleteVote

Parameters

Name	Type	Required
tenantId	string	Yes
id	string	Yes
editKey	string	No

Response

Returns: VoteDeleteResponse

Example

deleteVote Example

Copy

async function run() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "comment_98765";
  const editKey: string = "edit_abcde";
  const responseWithKey: VoteDeleteResponse = await deleteVote(tenantId, commentId, editKey);
  const responseWithoutKey: VoteDeleteResponse = await deleteVote(tenantId, commentId);
}
run();

getVotes

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Response

Returns: GetVotesResponse

Example

getVotes Example

Copy

const tenantId: string = "tenant_12345";
const urlId: string = "article-67890";
(async () => {
  const votesResponse: GetVotesResponse = await getVotes(tenantId, urlId);
  // Example of accessing an optional property from the response
  const firstVote: PublicVote | undefined = votesResponse.votes?.[0];
})();

getVotesForUser

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
userId	string	No
anonUserId	string	No

Response

Returns: GetVotesForUserResponse

Example

getVotesForUser Example

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "post_9876";
  const userId: string = "user_abcde";
  const anonUserId: string = "anon_5678";
  const responseWithUser: GetVotesForUserResponse = await getVotesForUser(tenantId, urlId, userId);
  const responseWithAnon: GetVotesForUserResponse = await getVotesForUser(tenantId, urlId, undefined, anonUserId);
}
demo();

createWebhook

Subscribes a URL to a comment event (REST hook subscribe). Subscribing the same URL to the same event and domain again returns the existing subscription. Deliveries are HMAC signed, see the webhooks guide; the legacy token header is never sent to API subscriptions.

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createWebhookParams	CreateWebhookParams	Yes

Response

Returns: CreateWebhookResponse

Example

createWebhook Example

Copy

const tenantId: string = "tenant_9f8b7c6d";
const webhookParams: CreateWebhookParams = {
  event: "comment.created" as WebhookEventName,
  method: "POST" as WebhookHTTPMethod,
  url: "https://myapp.example.com/webhook",
  source: "comment" as WebhookSource,
  // optional secret for payload verification
  secret: "s3cr3tK3y123",
};
const result: CreateWebhookResponse = await createWebhook(tenantId, webhookParams);
const webhookId: string = result.webhook.id;

deleteWebhook

Unsubscribes (REST hook unsubscribe). Only subscriptions created through this API can be deleted here; dashboard-managed webhooks are edited in the dashboard.

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: APIEmptyResponse

Example

deleteWebhook Example

Copy

const tenantId: string = "tenant_12345";
const webhookId: string = "wh_98765";
const result: APIEmptyResponse = await deleteWebhook(tenantId, webhookId);

getWebhooks

Lists the webhooks configured for the tenant, both dashboard-managed rows and API subscriptions.

Parameters

Name	Type	Required
tenantId	string	Yes
event	WebhookEventName	No
domain	string	No
source	WebhookSource	No
skip	number	No

Response

Returns: GetWebhooksResponse

Example

getWebhooks Example

Copy

(async () => {
  const tenantId: string = 'tenant_42';
  const event: WebhookEventName = 'comment.created';
  const domain: string = 'forum.example.org';
  const source: WebhookSource = 'admin';
  const skip: number = 0;
  const fullResponse: GetWebhooksResponse = await getWebhooks(tenantId, event, domain, source, skip);
  const minimalResponse: GetWebhooksResponse = await getWebhooks(tenantId);
})();

getWebhookSamplePayloads

Recent comments in exactly the shape webhook deliveries use, for building integrations (for example Zapier sample data). Every event delivers the same comment object, so event only has to be valid.

Parameters

Name	Type	Required
tenantId	string	Yes
event	WebhookEventName	No
limit	number	No

Response

Returns: GetWebhookSamplePayloadsResponse

Example

getWebhookSamplePayloads Example

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const responseAll: GetWebhookSamplePayloadsResponse = await getWebhookSamplePayloads(
  tenantId,
  "comment.created",
  10
);
const responseWithEvent: GetWebhookSamplePayloadsResponse = await getWebhookSamplePayloads(
  tenantId,
  "comment.created"
);
const responseBasic: GetWebhookSamplePayloadsResponse = await getWebhookSamplePayloads(
  tenantId
);

Need Help?

If you encounter any issues or have questions about the JavaScript/TypeScript SDK, please:

Contributing

Contributions are welcome! Please visit the GitHub repository for contribution guidelines.

Language 🇺🇸 English

Documentation

Getting Started

API Reference

Usage

Agent Tenants

Aggregate

Audit Logs

Block From Comment

Check Blocked Comments

Comments

Comments For User

Domain Configs

Email Templates

Event Log

Feed Posts

Flag Comment

Gifs

Hash Tags

Me

Moderation

Moderators

Notification Count

Notifications

Page Reacts

Pages

Pending Webhook Events

Poll Votes

Polls

Question Configs

Question Results

Question Results Aggregation

SSO Users

Subscriptions

Tenant Daily Usage

Tenant Packages

Tenant Users

Tenants

Tickets

Translations

Upload Image

User Badge Progress

User Badges

User Notifications

User Presence Status

User Search

Users

Votes

Webhooks

FastComments JavaScript/TypeScript SDK

Repository

AI coding agents

Installation

API Documentation

Browser vs Server Compatibility

Usage

Browser Usage (Client-Side)

Server Usage (Node.js)

Types Only Import

Using Individual API Classes

Browser Environment

Server Environment

Public vs Secured APIs

Example: Using Public API (browser-safe)

Example: Using Default API (server-side only)

Example: Using Moderation API

SSO (Single Sign-On) Integration

Simple SSO (Server-Side Only)

Secure SSO (Server-Side, Recommended)

Using SSO from Browser (with Server-Generated Token)

SSO with Comment Creation

Common Use Cases

Getting Comments for a Page

Creating a Comment

Voting on a Comment

User Management (Requires API Key)

Live Events (Real-time Updates)

Page-Level Events

Subscribe to User Events

Getting userIdWS