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

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);
  }
}

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

Response

Returns: GetAuditLogsResponse1

Example

getAuditLogs Example

Copy

(async () => {
  const tenantId: string = "tenant_42";
  const limit: number = 100;
  const skip: number = 10;
  const order: SORTDIR = "desc";
  const after: number = Date.now() - 3 * 24 * 60 * 60 * 1000; // 3 days ago
  const auditResponse: GetAuditLogsResponse1 = await getAuditLogs(
    tenantId,
    limit,
    skip,
    order,
    after
  );
  console.log(auditResponse);
})();

blockFromCommentPublic

Parameters

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

Response

Returns: BlockFromCommentPublicResponse

Example

blockFromCommentPublic Example

Copy

async function demo() {
  const tenantId: string = "tenant_9f8b7c";
  const commentId: string = "cmt_1234567890";
  const blockParams: PublicBlockFromCommentParams = {
    reason: "spam",
    durationHours: 24,
  };
  const ssoToken: string = "sso_ABCDEF123456";
  const responseWithSso: BlockFromCommentPublicResponse = await blockFromCommentPublic(
    tenantId,
    commentId,
    blockParams,
    ssoToken
  );
  const responseWithoutSso: BlockFromCommentPublicResponse = await blockFromCommentPublic(
    tenantId,
    commentId,
    blockParams
  );
  console.log(responseWithSso, responseWithoutSso);
}
demo();

unBlockCommentPublic

Parameters

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

Response

Returns: UnBlockCommentPublicResponse

Example

unBlockCommentPublic Example

Copy

const tenantId: string = "acme-corp-tenant";
const commentId: string = "cmt-20230915-001";
const unblockParams: PublicBlockFromCommentParams = {
  reason: "User appealed and was cleared",
  unblockExpiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
};
const ssoToken: string = "sso-3d9f8a7b";
const result: UnBlockCommentPublicResponse = await unBlockCommentPublic(
  tenantId,
  commentId,
  unblockParams,
  ssoToken
);

checkedCommentsForBlocked

Parameters

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

Response

Returns: CheckedCommentsForBlockedResponse

Example

checkedCommentsForBlocked Example

Copy

(async () => {
  const tenantId: string = "acme-corp-123";
  const commentIds: string = "cmt_001,cmt_002";
  const ssoToken: string = "ssoTokenXYZ";
  const blockedCheck: CheckedCommentsForBlockedResponse = await checkedCommentsForBlocked(tenantId, commentIds);
  const blockedCheckWithSso: CheckedCommentsForBlockedResponse = await checkedCommentsForBlocked(tenantId, commentIds, ssoToken);
})();

blockUserFromComment

Parameters

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

Response

Returns: BlockUserFromCommentResponse

Example

blockUserFromComment Example

Copy

const tenantId: string = 'tenant_42';
const commentId: string = 'cmt_20231101';
const blockParams: BlockFromCommentParams = {
  reason: 'spam',
  blockDurationHours: 24,
};
const userId: string = 'user_123'; // optional parameter
const response: BlockUserFromCommentResponse = await blockUserFromComment(
  tenantId,
  commentId,
  blockParams,
  userId
);

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: CreateCommentPublicResponse

Example

createCommentPublic Example

Copy

(async () => {
  const tenantId: string = "tenant-abc123";
  const urlId: string = "post-987654";
  const broadcastId: string = "bcast-001";
  const commentData: CommentData = {
    content: "I really enjoyed this article!"
  };
  const sessionId: string = "session-xyz789";
  const sso: string = "sso-token-456def";
  const response: CreateCommentPublicResponse = await createCommentPublic(
    tenantId,
    urlId,
    broadcastId,
    commentData,
    sessionId,
    sso
  );
  console.log(response);
})();

deleteComment

Parameters

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

Response

Returns: DeleteCommentResponse

Example

deleteComment Example

Copy

(async () => {
  const tenantId: string = 'tenant_01';
  const commentId: string = 'comment_abc123';
  const contextUserId: string = 'user_42';
  const isLive: boolean = false;
  const deleteResult: DeleteCommentResponse = await deleteComment(tenantId, commentId, contextUserId, isLive);
  const simpleResult: DeleteCommentResponse = await deleteComment(tenantId, commentId);
})();

deleteCommentPublic

Parameters

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

Response

Returns: DeleteCommentPublicResponse

Example

deleteCommentPublic Example

Copy

(async () => {
  const tenantId: string = 'c6f9a2e3-9b1d-4f8a-b2d2-1a2b3c4d5e6f';
  const commentId: string = '7d9f0b1c-2e3f-4a5b-6c7d-8e9f0a1b2c3d';
  const broadcastId: string = 'live-2023-09-15';
  const editKey: string = 'ed1tK3y1234567890';
  const sso: string = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.abc123';
  const result: DeleteCommentPublicResponse = 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: DeleteCommentVoteResponse

Example

deleteCommentVote Example

Copy

async function removeVote() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const voteId: string = "vote_abcde";
  const urlId: string = "url_56789";
  const broadcastId: string = "brd_001";
  const editKey: string = "edit_456";
  // sso is optional and omitted
  const response: DeleteCommentVoteResponse = await deleteCommentVote(
    tenantId,
    commentId,
    voteId,
    urlId,
    broadcastId,
    editKey
  );
  console.log(response);
}
removeVote();

flagComment

Parameters

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

Response

Returns: FlagCommentResponse1

Example

flagComment Example

Copy

(async () => {
  const tenantId: string = "tenant_2023";
  const commentId: string = "comment_5678";
  const userId: string = "user_1234";
  const anonUserId: string = "anon_4321";
  const result: FlagCommentResponse1 = await flagComment(tenantId, commentId, userId);
  const anonResult: FlagCommentResponse1 = await flagComment(tenantId, commentId, undefined, anonUserId);
})();

getComment

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetCommentResponse

Example

getComment Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const commentId: string = "comment-987654";
  const result: GetCommentResponse = await getComment(tenantId, commentId);
  const badgeInfo: CommentUserBadgeInfo | undefined = result.comment?.user?.badgeInfo;
  console.log(badgeInfo?.label);
})();

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: GetCommentsResponse

Example

getComments Example

Copy

const tenantId: string = "tenant_12345";
const page: number = 2;
const limit: number = 50;
const asTree: boolean = true;
const urlId: string = "article_5678";
const direction: SortDirections = "desc";
const fromDate: number = Date.now() - 7 * 24 * 60 * 60 * 1000; // one week ago
const toDate: number = Date.now();
const commentsResponse: GetCommentsResponse = await getComments({
  tenantId,
  page,
  limit,
  asTree,
  urlId,
  direction,
  fromDate,
  toDate,
});

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: GetCommentsPublicResponse

Example

getCommentsPublic Example

Copy

async function fetchComments() {
  const tenantId: string = 'acme-corp';
  const urlId: string = 'blog/post-789';
  const page: number = 1;
  const direction: SortDirections = SortDirections.Desc;
  const limit: number = 25;
  const includeConfig: boolean = true;
  const locale: string = 'en-GB';
  const modules: string = 'reactions,attachments';
  const isCrawler: boolean = false;
  const includeNotificationCount: boolean = true;
  const asTree: boolean = true;
  const maxTreeDepth: number = 4;
  const searchText: string = 'TypeScript';
  const hashTags: string[] = ['typescript', 'api'];
  const response: GetCommentsPublicResponse = await getCommentsPublic(
    tenantId,
    urlId,
    page,
    direction,
    undefined,
    undefined,
    undefined,
    limit,
    undefined,
    undefined,
    undefined,
    includeConfig,
    undefined,
    undefined,
    locale,
    modules,
    isCrawler,
    includeNotificationCount,
    asTree,
    maxTreeDepth,
    undefined,
    undefined,
    searchText,
    hashTags,
    undefined,
    undefined,
    undefined,
    undefined
  );
}

getCommentText

Parameters

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

Response

Returns: GetCommentTextResponse1

Example

getCommentText Example

Copy

async function run() {
  const tenantId: string = "acme-corp-tenant";
  const commentId: string = "cmt-5f2e9a1b";
  const editKey: string = "edk-9b7c3";
  const ssoToken: string = "sso-xyz789";
  const commentOnly: GetCommentTextResponse1 = await getCommentText(tenantId, commentId);
  const commentWithEdit: GetCommentTextResponse1 = await getCommentText(tenantId, commentId, editKey);
  const commentFull: GetCommentTextResponse1 = await getCommentText(tenantId, commentId, editKey, ssoToken);
}
run();

getCommentVoteUserNames

Parameters

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

Response

Returns: GetCommentVoteUserNamesResponse

Example

getCommentVoteUserNames Example

Copy

async function demoGetCommentVoteUserNames() {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_5f2a1e3b";
  const dir: number = 1; // ascending
  const votesWithoutSSO: GetCommentVoteUserNamesResponse = await getCommentVoteUserNames(
    tenantId,
    commentId,
    dir
  );
  const ssoToken: string = "sso_abcdef123456";
  const votesWithSSO: GetCommentVoteUserNamesResponse = await getCommentVoteUserNames(
    tenantId,
    commentId,
    dir,
    ssoToken
  );
  console.log(votesWithoutSSO, votesWithSSO);
}

lockComment

Parameters

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

Response

Returns: LockCommentResponse

Example

lockComment Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const broadcastId: string = "brd_54321";
  // With optional SSO token
  const ssoToken: string = "user-abc123";
  const lockedWithSso: LockCommentResponse = await lockComment(tenantId, commentId, broadcastId, ssoToken);
  // Without SSO token
  const lockedWithoutSso: LockCommentResponse = await lockComment(tenantId, commentId, broadcastId);
})();

pinComment

Parameters

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

Response

Returns: PinCommentResponse

Example

pinComment Example

Copy

(async () => {
  const tenantId: string = 'tenant-001';
  const commentId: string = 'comment-5678';
  const broadcastId: string = 'broadcast-2023';
  const ssoToken: string = 'sso-xyz-789';
  const pinResult: PinCommentResponse = await pinComment(tenantId, commentId, broadcastId);
  const pinResultWithSso: PinCommentResponse = await pinComment(tenantId, commentId, broadcastId, ssoToken);
})();

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: SaveCommentResponse

Example

saveComment Example

Copy

async function submitComment() {
  const tenantId: string = "tenant_9f8e7d6c";
  const commentParams: CreateCommentParams = {
    text: "Great post, thanks for sharing!",
    authorId: "user_123abc",
    mentions: [] as CommentUserMentionInfo[],
    hashtags: [] as CommentUserHashTagInfo[]
  };
  const response: SaveCommentResponse = await saveComment(
    tenantId,
    commentParams,
    true,   // isLive
    false   // doSpamCheck
  );
  console.log(response);
}
submitComment();

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_9f8b7c6d";
const bulkComments: CreateCommentParams[] = [
  {
    content: "Welcome to the new forum thread!",
    authorId: "user_42",
    mentions: [{ userId: "user_84", username: "alice" }],
    hashtags: [{ tag: "intro" }]
  },
  {
    content: "Please review the updated guidelines.",
    authorId: "moderator_1",
    mentions: [],
    hashtags: [{ tag: "guidelines" }, { tag: "update" }]
  }
];
const results: SaveCommentsBulkResponse[] = await saveCommentsBulk(
  tenantId,
  bulkComments,
  true,      // isLive
  false,     // doSpamCheck
  true,      // sendEmails
  undefined  // populateNotifications (using default)
);

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: SetCommentTextResponse1

Example

setCommentText Example

Copy

(async () => {
  const tenantId: string = 'tenant_12345';
  const commentId: string = 'cmt_98765';
  const broadcastId: string = 'brd_112233';
  const commentTextUpdateRequest: CommentTextUpdateRequest = {
    text: 'Updated comment with @john.doe and #important',
    mentions: [{ userId: 'user_001', username: 'john.doe' }],
    hashtags: [{ tag: 'important' }],
  };
  const editKey: string = 'edit_abc123';
  const result: SetCommentTextResponse1 = await setCommentText(
    tenantId,
    commentId,
    broadcastId,
    commentTextUpdateRequest,
    editKey,
  );
  console.log(result);
})();

unBlockUserFromComment

Parameters

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

Response

Returns: UnBlockUserFromCommentResponse

Example

unBlockUserFromComment Example

Copy

async function demoUnblock() {
  const tenantId: string = "acme-corp-tenant";
  const commentId: string = "cmt_9f8b7a6d";
  const params: UnBlockFromCommentParams = {
    reason: "User resolved the issue",
    notifyUser: true
  };
  const userId: string = "usr_12345";
  const result: UnBlockUserFromCommentResponse = await unBlockUserFromComment(
    tenantId,
    commentId,
    params,
    userId
    // anonUserId omitted
  );
  console.log(result);
}
demoUnblock();

unFlagComment

Parameters

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

Response

Returns: UnFlagCommentResponse

Example

unFlagComment Example

Copy

const tenantId: string = "acme-corp";
const commentId: string = "cmt_123456";
const userId: string = "usr_98765";
const result: UnFlagCommentResponse = await unFlagComment(tenantId, commentId, userId);
const anonCommentId: string = "cmt_123457";
const anonUserId: string = "anon_abc123";
const anonResult: UnFlagCommentResponse = await unFlagComment(tenantId, anonCommentId, undefined, anonUserId);

unLockComment

Parameters

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

Response

Returns: UnLockCommentResponse

Example

unLockComment Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_9876";
const broadcastId: string = "brd_001";
const ssoToken: string | undefined = "sso_token_abc";
async function run() {
  const unlocked: UnLockCommentResponse = await unLockComment(tenantId, commentId, broadcastId, ssoToken);
  console.log(unlocked);
  // Call without the optional sso parameter
  const unlockedWithoutSso: UnLockCommentResponse = await unLockComment(tenantId, commentId, broadcastId);
  console.log(unlockedWithoutSso);
}
run();

unPinComment

Parameters

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

Response

Returns: UnPinCommentResponse

Example

unPinComment Example

Copy

(async () => {
  const tenantId: string = "tenant-001"
  const commentId: string = "comment-123"
  const broadcastId: string = "broadcast-456"
  const sso: string = "sso-token-xyz"
  const resultWithSso: UnPinCommentResponse = await unPinComment(tenantId, commentId, broadcastId, sso)
  const resultWithoutSso: UnPinCommentResponse = await unPinComment(tenantId, commentId, broadcastId)
  console.log(resultWithSso, resultWithoutSso)
})()

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: UpdateCommentResponse

Example

updateComment Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_98765";
const updatableCommentParams: UpdatableCommentParams = {
  // example fields; actual shape depends on the API definition
  // e.g., body: "Edited comment content",
};
const contextUserId: string = "user_abcde";
const doSpamCheck: boolean = true;
const isLive: boolean = false;
const result: UpdateCommentResponse = await updateComment(
  tenantId,
  commentId,
  updatableCommentParams,
  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: VoteCommentResponse

Example

voteComment Example

Copy

const tenantId: string = "acme-corp";
const commentId: string = "cmt_9f8e7d6c";
const urlId: string = "url_123456";
const broadcastId: string = "bcast_2024_01";
const voteBodyParams: VoteBodyParams = {
  vote: "up",               // e.g., "up" | "down"
  weight: 1,                // optional weighting of the vote
};
const sessionId: string = "sess_abc123def";
const sso: string = "sso_token_xyz";
const result: VoteCommentResponse = await voteComment(
  tenantId,
  commentId,
  urlId,
  broadcastId,
  voteBodyParams,
  sessionId,
  sso
);

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: GetCommentsForUserResponse1

Example

getCommentsForUser Example

Copy

async function demo() {
    const userId: string = "user-12345";
    const direction: SortDirections = "desc";
    const page: number = 1;
    const includei10n: boolean = true;
    const locale: string = "en-US";
    const isCrawler: boolean = false;
    const response: GetCommentsForUserResponse1 = await getCommentsForUser(
        userId,
        direction,
        undefined,
        page,
        includei10n,
        locale,
        isCrawler
    );
    console.log(response);
}

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: CreateEmailTemplateResponse1

Example

createEmailTemplate Example

Copy

const tenantId: string = "tenant_9f8e7d6c";
const emailTemplate: CreateEmailTemplateBody = {
  name: "Account Activation",
  subject: "Activate Your New Account",
  htmlContent: "<p>Welcome! Please click <a href=\"\{{activationLink}}\">here</a> to activate.</p>",
  // optional fields like textContent, isActive are omitted to demonstrate optional parameters
};
const result: CreateEmailTemplateResponse1 = await createEmailTemplate(
  tenantId,
  emailTemplate
);
console.log(result);

deleteEmailTemplate

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeleteEmailTemplateResponse

Example

deleteEmailTemplate Example

Copy

async () => {
  const tenantId: string = "tenant_12345";
  const templateId: string = "template_abcde";
  const response: DeleteEmailTemplateResponse = await deleteEmailTemplate(tenantId, templateId);
  // Example of accessing an optional property from the response
  const statusCode: number | undefined = response.status?.code;
}();

deleteEmailTemplateRenderError

Parameters

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

Response

Returns: DeleteEmailTemplateRenderErrorResponse

Example

deleteEmailTemplateRenderError Example

Copy

async function executeDelete() {
  const tenantId: string = "tenant_12345";
  const templateId: string = "email_tpl_001";
  const errorId: string = "render_err_2023";
  const result: DeleteEmailTemplateRenderErrorResponse = await deleteEmailTemplateRenderError(
    tenantId,
    templateId,
    errorId
  );
  console.log(result);
}
executeDelete();

getEmailTemplate

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetEmailTemplateResponse1

Example

getEmailTemplate Example

Copy

async function fetchTemplate(): Promise<void> {
    const tenantId: string = "tenant-12345";
    const templateId: string = "order-confirmation";
    const response: GetEmailTemplateResponse1 = await getEmailTemplate(tenantId, templateId);
    const emailTemplate: CustomEmailTemplate | undefined = response.customEmailTemplate;
    const configParams: CustomConfigParameters | undefined = response.customConfigParameters;
}

getEmailTemplateDefinitions

Parameters

Name	Type	Required	Description
tenantId	string	Yes

Response

Returns: GetEmailTemplateDefinitionsResponse1

Example

getEmailTemplateDefinitions Example

Copy

(async () => {
  const tenantId: string = "acme-corp-123";
  const emailTemplateDefs: GetEmailTemplateDefinitionsResponse1 = await getEmailTemplateDefinitions(tenantId);
  console.log(emailTemplateDefs);
})();

getEmailTemplateRenderErrors

Parameters

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

Response

Returns: GetEmailTemplateRenderErrorsResponse1

Example

getEmailTemplateRenderErrors Example

Copy

const tenantId: string = "c2f5a8d9-4b3e-4f6a-9e1b-2d5c6f7a8b9c";
const templateId: string = "welcome-email-template";
const skip: number = 20;
const result: GetEmailTemplateRenderErrorsResponse1 = await getEmailTemplateRenderErrors(
  tenantId,
  templateId,
  skip
);

getEmailTemplates

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetEmailTemplatesResponse1

Example

getEmailTemplates Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  // Call without optional 'skip'
  const templates: GetEmailTemplatesResponse1 = await getEmailTemplates(tenantId);
  // Call with optional 'skip' parameter
  const pagedTemplates: GetEmailTemplatesResponse1 = await getEmailTemplates(tenantId, 20);
})();

renderEmailTemplate

Parameters

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

Response

Returns: RenderEmailTemplateResponse1

Example

renderEmailTemplate Example

Copy

(async () => {
  const tenantId: string = "acme-corp-01";
  const templateBody: RenderEmailTemplateBody = {
    templateId: "welcome-email",
    placeholders: {
      userName: "John Doe",
      signupDate: "2024-04-01"
    }
  };
  const locale: string = "en-US";
  const result: RenderEmailTemplateResponse1 = await renderEmailTemplate(tenantId, templateBody, locale);
  console.log(result);
})();

updateEmailTemplate

Parameters

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

Response

Returns: UpdateEmailTemplateResponse

Example

updateEmailTemplate Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const templateId: string = "email_tpl_67890";
  const updateBody: UpdateEmailTemplateBody = {
    subject: "Comment reply notification",
    htmlContent: "<p>Someone replied to your comment.</p>",
    plainTextContent: "Someone replied to your comment.",
    // optional field example
    isActive: true,
  };
  const result: UpdateEmailTemplateResponse = await updateEmailTemplate(
    tenantId,
    templateId,
    updateBody
  );
  console.log(result);
})();

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: GetEventLogResponse1

Example

getEventLog Example

Copy

(async () => {
    const tenantId: string = "tenant_9876";
    const urlId: string = "page_54321";
    const userIdWS: string = "ws_user_1122";
    const startTime: number = Date.now() - 7 * 24 * 60 * 60 * 1000; // one week ago
    const endTime: number = Date.now();
    const log: GetEventLogResponse1 = await getEventLog(tenantId, urlId, userIdWS, startTime, endTime);
    const recentLog: GetEventLogResponse1 = 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: GetGlobalEventLogResponse

Example

getGlobalEventLog Example

Copy

(async () => {
  const tenantId: string = '123e4567-e89b-12d3-a456-426614174000';
  const urlId: string = 'article-2023-09-15';
  const userIdWS: string = 'ws_987654321';
  const startTime: number = Date.now() - 86400000;
  const endTime: number = Date.now();
  const fullLog: GetGlobalEventLogResponse = await getGlobalEventLog(tenantId, urlId, userIdWS, startTime, endTime);
  const recentLog: GetGlobalEventLogResponse = await getGlobalEventLog(tenantId, urlId, userIdWS, startTime);
  console.log(fullLog, recentLog);
})();

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: CreateFeedPostResponse1

Example

createFeedPost Example

Copy

async function run() {
  const tenantId = "tenant-12345";
  const feedParams: CreateFeedPostParams = {
    text: "New product launch!",
    mediaItems: [{ type: "image", asset: { url: "https://cdn.example.com/img.jpg", width: 800, height: 600 } as FeedPostMediaItemAsset } as FeedPostMediaItem],
    link: { url: "https://example.com/product", title: "Product" } as FeedPostLink
  };
  const result: CreateFeedPostResponse1 = await createFeedPost(tenantId, feedParams, "broadcast-987", true, false, true);
  console.log(result);
}
run();

createFeedPostPublic

Parameters

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

Response

Returns: CreateFeedPostPublicResponse

Example

createFeedPostPublic Example

Copy

async function submitPost() {
  const tenantId: string = "tenant_12345";
  const mediaItem: FeedPostMediaItem = {
    asset: {
      url: "https://cdn.example.com/image.jpg",
      mimeType: "image/jpeg",
      size: 104857,
    },
    type: "image",
  };
  const link: FeedPostLink = {
    url: "https://example.com/blog/new-feature",
    title: "New Feature Release",
    description: "Details about our latest product update.",
  };
  const createFeedPostParams: CreateFeedPostParams = {
    content: "Check out our new feature!",
    media: [mediaItem],
    link: link,
  };
  const broadcastId: string = "broadcast_9876";
  const sso: string = "sso_token_abc123";
  const response: CreateFeedPostPublicResponse = 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 = "acme-corp";
  const postId: string = "post_987654321";
  const broadcastId: string = "broadcast_2024Q1";
  const sso: string = "sso_4fa3b9c2";
  const response1: DeleteFeedPostPublicResponse = await deleteFeedPostPublic(tenantId, postId);
  const response2: DeleteFeedPostPublicResponse = await deleteFeedPostPublic(tenantId, postId, broadcastId);
  const response3: DeleteFeedPostPublicResponse = await deleteFeedPostPublic(tenantId, postId, broadcastId, sso);
})();

getFeedPosts

req tenantId afterId

Parameters

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

Response

Returns: GetFeedPostsResponse1

Example

getFeedPosts Example

Copy

(async () => {
  const tenantId: string = 'tenant_12345';
  const afterId: string = 'post_9876';
  const limit: number = 20;
  const tags: string[] = ['news', 'sports'];
  const feedResult: GetFeedPostsResponse1 = await getFeedPosts(tenantId, afterId, limit, tags);
})();

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: GetFeedPostsPublicResponse

Example

getFeedPostsPublic Example

Copy

async function example() {
  const tenantId: string = "tenant_12345";
  const afterId: string = "post_9876";
  const limit: number = 20;
  const tags: string[] = ["news", "tech"];
  const sso: string = "userToken123";
  const isCrawler: boolean = false;
  const includeUserInfo: boolean = true;
  const response: GetFeedPostsPublicResponse = await getFeedPostsPublic(
    tenantId,
    afterId,
    limit,
    tags,
    sso,
    isCrawler,
    includeUserInfo
  );
}
example();

getFeedPostsStats

Parameters

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

Response

Returns: GetFeedPostsStatsResponse

Example

getFeedPostsStats Example

Copy

async function runExample(): Promise<void> {
    const tenantId: string = "tenant_12345";
    const postIds: string[] = ["post_a1b2c3", "post_d4e5f6"];
    const ssoToken: string = "sso_abcdef123456";
    const statsWithoutSso: GetFeedPostsStatsResponse = await getFeedPostsStats(tenantId, postIds);
    const statsWithSso: GetFeedPostsStatsResponse = await getFeedPostsStats(tenantId, postIds, ssoToken);
}
runExample();

getUserReactsPublic

Parameters

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

Response

Returns: GetUserReactsPublicResponse

Example

getUserReactsPublic Example

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const postIds: string[] = ["post_1a2b3c", "post_4d5e6f"];
  const ssoToken: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...";
  const fullResponse: GetUserReactsPublicResponse = await getUserReactsPublic(tenantId, postIds, ssoToken);
  const minimalResponse: GetUserReactsPublicResponse = await getUserReactsPublic(tenantId);
}
demo();

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: ReactFeedPostPublicResponse

Example

reactFeedPostPublic Example

Copy

(async () => {
  const tenantId: string = 'tenant_12345';
  const postId: string = 'post_98765';
  const reactBodyParams: ReactBodyParams = { reaction: 'thumbs_up' };
  const isUndo: boolean = false;
  const broadcastId: string = 'broadcast_abcde';
  const sso: string = 'sso_token_xyz';
  const response: ReactFeedPostPublicResponse = await reactFeedPostPublic(
    tenantId,
    postId,
    reactBodyParams,
    isUndo,
    broadcastId,
    sso
  );
  console.log(response);
})();

updateFeedPost

Parameters

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

Response

Returns: UpdateFeedPostResponse

Example

updateFeedPost Example

Copy

const tenantId: string = "tenant_3421";
const postId: string = "feedpost_a9b8c7";
const feedPost: FeedPost = {
  content: "We've refreshed the announcement with the latest project milestones.",
  media: [
    {
      type: "image",
      url: "https://assets.example.com/images/milestone.png",
      caption: "Project Milestones"
    } as FeedPostMediaItem
  ],
  link: {
    url: "https://example.com/project-updates",
    title: "Project Updates",
    description: "Read about the recent progress and upcoming goals."
  } as FeedPostLink
};
const result: UpdateFeedPostResponse = await updateFeedPost(tenantId, postId, feedPost);

updateFeedPostPublic

Parameters

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

Response

Returns: UpdateFeedPostPublicResponse

Example

updateFeedPostPublic Example

Copy

async function updatePostExample() {
  const tenantId: string = 'tenant-9f8b7c';
  const postId: string = 'post-3a4d5e';
  const updateParams: UpdateFeedPostParams = {
    title: 'New Announcement',
    content: 'We have updated our terms of service.',
    media: [
      {
        url: 'https://cdn.example.com/assets/image.png',
        type: 'image',
        asset: {
          width: 800,
          height: 600,
          size: 124000
        } as FeedPostMediaItemAsset
      } as FeedPostMediaItem
    ],
    link: {
      url: 'https://example.com/terms',
      title: 'Read the new TOS'
    } as FeedPostLink
  };
  const broadcastId: string = 'broadcast-2023-09';
  const sso: string = 'sso-abc123xyz';
  const result: UpdateFeedPostPublicResponse = 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: FlagCommentPublicResponse

Example

flagCommentPublic Example

Copy

async function demoFlagComment() {
    const tenantId: string = "acme-tenant-123";
    const commentId: string = "comment-987654";
    const isFlagged: boolean = true;
    const sso: string = "sso-token-abc123";
    const result: FlagCommentPublicResponse = await flagCommentPublic(
        tenantId,
        commentId,
        isFlagged,
        sso
    );
    console.log(result);
}
demoFlagComment();

getGifLarge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Response

Returns: GetGifLargeResponse

Example

getGifLarge Example

Copy

(async () => {
  const tenantId: string = 'c9f4a1b2-3d5e-4f6a-8b9c-0d1e2f3a4b5c';
  const largeInternalURLSanitized: string = 'https://cdn.fastcomments.com/gifs/awesome-cat-large.gif';
  const result: GetGifLargeResponse = await getGifLarge(tenantId, largeInternalURLSanitized);
  console.log(result);
})();

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 demo() {
  const tenantId: string = "tenant_9f8b7c";
  const search: string = "funny cats";
  const locale: string = "en-US";
  const rating: string = "pg";
  const page: number = 1;
  const result: GetGifsSearchResponse = await getGifsSearch(
    tenantId,
    search,
    locale,
    rating,
    page
  );
  console.log(result);
}
demo();

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	No
createHashTagBody	CreateHashTagBody	No

Response

Returns: AddHashTagResponse

Example

addHashTag Example

Copy

const tenantId: string = "tenant_9876";
const newHashTag: CreateHashTagBody = {
  tag: "typescript",
  description: "Discussions about TypeScript"
};
const responseWithTenant: AddHashTagResponse = await addHashTag(tenantId, newHashTag);
const responseWithoutTenant: AddHashTagResponse = await addHashTag(undefined, newHashTag);

addHashTagsBulk

Parameters

Name	Type	Required	Description
tenantId	string	No
bulkCreateHashTagsBody	BulkCreateHashTagsBody	No

Response

Returns: AddHashTagsBulkResponse

Example

addHashTagsBulk Example

Copy

async () => {
    const tenantId: string | undefined = "tenant_9f8b7c6d";
    const bulkCreateHashTagsBody: BulkCreateHashTagsBody = {
        tags: [
            {
                name: "typescript",
                description: "Discussions about TypeScript",
                color: "#3178c6"
            },
            {
                name: "fastcomments",
                description: "Tags for FastComments integration",
                color: "#00aaff"
            }
        ]
    };
    const result: AddHashTagsBulkResponse = await addHashTagsBulk(tenantId, bulkCreateHashTagsBody);
    console.log(result);
}();

deleteHashTag

Parameters

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

Response

Returns: DeleteHashTagResponse

Example

deleteHashTag Example

Copy

(async () => {
  const tag: string = "announcement";
  const tenantId: string = "tenant_9876";
  const requestBody: DeleteHashTagRequestBody = {
    confirmDeletion: true
  };
  const response: DeleteHashTagResponse = await deleteHashTag(tag, tenantId, requestBody);
  console.log(response);
})();

getHashTags

Parameters

Name	Type	Required	Description
tenantId	string	Yes
page	number	No

Response

Returns: GetHashTagsResponse1

Example

getHashTags Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const responseWithPage: GetHashTagsResponse1 = await getHashTags(tenantId, 1);
  const responseDefault: GetHashTagsResponse1 = await getHashTags(tenantId);
  console.log(responseWithPage, responseDefault);
})();

patchHashTag

Parameters

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

Response

Returns: PatchHashTagResponse

Example

patchHashTag Example

Copy

const response1: PatchHashTagResponse = await patchHashTag("new-feature");
const response2: PatchHashTagResponse = await patchHashTag(
  "beta-release",
  "tenant-9f8b7c"
);
const updateBody: UpdateHashTagBody = {
  description: "Mark comments related to the upcoming beta release",
  color: "#1e90ff"
};
const response3: PatchHashTagResponse = await patchHashTag(
  "beta-release",
  "tenant-9f8b7c",
  updateBody
);

deleteModerationVote

Parameters

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

Response

Returns: DeleteModerationVoteResponse

Example

deleteModerationVote Example

Copy

const commentId: string = "cmt_12345";
const voteId: string = "vote_9876";
const broadcastId: string = "brd_001";
const tenantId: string = "tenant_42";
const sso: string = "sso_token_abc";
const result: DeleteModerationVoteResponse = await deleteModerationVote(
  commentId,
  voteId,
  broadcastId,
  tenantId,
  sso
);

getApiComments

Parameters

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

Response

Returns: GetApiCommentsResponse

Example

getApiComments Example

Copy

async function loadComments() {
  const fullResult: GetApiCommentsResponse = await getApiComments(
    2,                     // page
    25,                    // count
    "feedback",           // textSearch
    "192.168.1.100",      // byIPFromComment
    "approved",           // filters
    "hasReplies",         // searchFilters
    "dateDesc",           // sorts
    false,                // demo
    "tenant-abc123",      // tenantId
    "sso-token-xyz"       // sso
  );
  const minimalResult: GetApiCommentsResponse = await getApiComments(undefined, 5);
}

getApiExportStatus

Parameters

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

Response

Returns: GetApiExportStatusResponse

Example

getApiExportStatus Example

Copy

async function demoExportStatus() {
    const batchJobId: string = "exportBatch-20231101-001";
    const tenantId: string = "tenant-abc123";
    const ssoToken: string = "sso-xyz789";
    const fullStatus: GetApiExportStatusResponse = await getApiExportStatus(batchJobId, tenantId, ssoToken);
    const simpleStatus: GetApiExportStatusResponse = await getApiExportStatus(batchJobId);
    console.log(fullStatus, simpleStatus);
}

getApiIds

Parameters

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

Response

Returns: GetApiIdsResponse

Example

getApiIds Example

Copy

const textSearch: string = "urgent feedback";
const byIPFromComment: string = "203.0.113.42";
const filters: string = "status:approved";
const afterId: string = "comment-789";
const demo: boolean = true;
const tenantId: string = "tenant-001";
const apiIds: GetApiIdsResponse = await getApiIds({
  textSearch,
  byIPFromComment,
  filters,
  afterId,
  demo,
  tenantId,
});

getBanUsersFromComment

Parameters

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

Response

Returns: GetBanUsersFromCommentResponse

Example

getBanUsersFromComment Example

Copy

async function demoGetBanUsers() {
  const commentId: string = "cmt_5f8e3a9b2d";
  const tenantId: string = "tenant_42";
  const sso: string = "sso_token_abc123";
  // Call with all parameters
  const fullResult: GetBanUsersFromCommentResponse = await getBanUsersFromComment(commentId, tenantId, sso);
  console.log(fullResult);
  // Call with only the required parameter
  const minimalResult: GetBanUsersFromCommentResponse = await getBanUsersFromComment(commentId);
  console.log(minimalResult);
}
demoGetBanUsers();

getCommentBanStatus

Parameters

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

Response

Returns: GetCommentBanStatusResponse1

Example

getCommentBanStatus Example

Copy

async function checkCommentBanStatus() {
  const banStatus: GetCommentBanStatusResponse1 = await getCommentBanStatus('cmt_987654321', 'tenant_42', 'sso_token_abc123');
  const banStatusNoTenant: GetCommentBanStatusResponse1 = await getCommentBanStatus('cmt_987654322', undefined, 'sso_token_def456');
}

getCommentChildren

Parameters

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

Response

Returns: GetCommentChildrenResponse

Example

getCommentChildren Example

Copy

const commentId: string = "cmt_12345";
const tenantId: string = "tenant_xyz";
const sso: string = "sso_987654";
const fullResponse: GetCommentChildrenResponse = await getCommentChildren(commentId, tenantId, sso);
const minimalResponse: GetCommentChildrenResponse = await getCommentChildren(commentId);

getCount

Parameters

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

Response

Returns: GetCountResponse

Example

getCount Example

Copy

async function main(): Promise<void> {
  const count: GetCountResponse = await getCount({
    textSearch: "order issue",
    byIPFromComment: "198.51.100.23",
    filter: "pending",
    demo: true,
    tenantId: "acme_corp",
    sso: "sso_abcdef123456"
  });
  console.log(count);
}
main();

getCounts

Parameters

Name	Type	Required	Description
tenantId	string	No
sso	string	No

Response

Returns: GetCountsResponse

Example

getCounts Example

Copy

async function runExample() {
    const tenantId: string = "acme-corp";
    const ssoToken: string = "sso-token-2024";
    const withBoth: GetCountsResponse = await getCounts(tenantId, ssoToken);
    const withTenantOnly: GetCountsResponse = await getCounts(tenantId);
    const withoutParams: GetCountsResponse = await getCounts();
    console.log(withBoth, withTenantOnly, withoutParams);
}
runExample();

getLogs

Parameters

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

Response

Returns: GetLogsResponse

Example

getLogs Example

Copy

async function fetchLogs() {
    const commentId: string = "cmt_9a8b7c6d5e4f3a2b";
    const tenantId: string = "tenant_9876";
    const sso: string = "sso_abcdef123456";

    const fullResponse: GetLogsResponse = await getLogs(commentId, tenantId, sso);
    const minimalResponse: GetLogsResponse = await getLogs(commentId);
}

getManualBadges

Parameters

Name	Type	Required	Description
tenantId	string	No
sso	string	No

Response

Returns: GetManualBadgesResponse

Example

getManualBadges Example

Copy

async function fetchBadges() {
  const tenantId: string = "tenant_987654321";
  const ssoToken: string = "sso_ABCdef123456";
  // Call with both optional parameters
  const responseFull: GetManualBadgesResponse = await getManualBadges(tenantId, ssoToken);
  console.log(responseFull);
  // Call with only tenantId
  const responseTenantOnly: GetManualBadgesResponse = await getManualBadges(tenantId);
  console.log(responseTenantOnly);
}
fetchBadges();

getManualBadgesForUser

Parameters

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

Response

Returns: GetManualBadgesForUserResponse

Example

getManualBadgesForUser Example

Copy

(async () => {
  const userId: string = "user_42";
  const commentId: string = "comment_1001";
  const tenantId: string = "tenant_acme";
  const ssoToken: string = "sso_5f6g7h8i9j";
  const badges: GetManualBadgesForUserResponse = await getManualBadgesForUser(userId, commentId, tenantId, ssoToken);
  const limitedBadges: GetManualBadgesForUserResponse = await getManualBadgesForUser(userId);
})();

getModerationComment

Parameters

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

Response

Returns: GetModerationCommentResponse

Example

getModerationComment Example

Copy

async function fetchCommentDetails() {
  // Full parameter set
  const commentId: string = "cmt_12345abc";
  const includeEmail: boolean = true;
  const includeIP: boolean = false;
  const tenantId: string = "tenant_9876";
  const sso: string = "sso_token_xyz";
  const fullResult: GetModerationCommentResponse = await getModerationComment(
    commentId,
    includeEmail,
    includeIP,
    tenantId,
    sso
  );
  // Minimal call using only the required argument
  const minimalResult: GetModerationCommentResponse = await getModerationComment("cmt_67890def");
  // Use results as needed...
}

getModerationCommentText

Parameters

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

Response

Returns: GetModerationCommentTextResponse

Example

getModerationCommentText Example

Copy

async function exampleUsage(): Promise<void> {
  const commentId: string = "cmt_9f8e7d6c5b4a3b2c1d0e";
  const tenantId: string = "tenant_67890";
  const sso: string = "sso_token_abc123";
  // Call with only the required parameter
  const result1: GetModerationCommentTextResponse = await getModerationCommentText(commentId);
  // Call with optional parameters
  const result2: GetModerationCommentTextResponse = await getModerationCommentText(commentId, tenantId, sso);
}

getPreBanSummary

Parameters

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

Response

Returns: GetPreBanSummaryResponse

Example

getPreBanSummary Example

Copy

const commentId: string = "5f8d0c2e4b1a2c3d4e5f6a7b";
const includeByUserIdAndEmail: boolean = true;
const includeByIP: boolean = true;
const includeByEmailDomain: boolean = false;
const tenantId: string = "tenant-001";
const sso: string = "sso-xyz-123";
const preBanSummary: GetPreBanSummaryResponse = await getPreBanSummary(
  commentId,
  includeByUserIdAndEmail,
  includeByIP,
  includeByEmailDomain,
  tenantId,
  sso
);

getSearchCommentsSummary

Parameters

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

Response

Returns: GetSearchCommentsSummaryResponse

Example

getSearchCommentsSummary Example

Copy

async function runExample(): Promise<void> {
    const searchTerm: string = "fastcomments integration";
    const filterString: string = "status:approved";
    const searchFilterString: string = "author:jane";
    const tenantId: string = "123e4567-e89b-12d3-a456-426614174000";
    const ssoToken: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...";
    const summary: GetSearchCommentsSummaryResponse = await getSearchCommentsSummary(
        searchTerm,
        filterString,
        searchFilterString,
        tenantId,
        ssoToken
    );
    console.log(summary);
}
runExample();

getSearchPages

Parameters

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

Response

Returns: GetSearchPagesResponse

Example

getSearchPages Example

Copy

(async () => {
  const query: string = "network outage";
  const tenantId: string = "tenant-9876";
  const ssoToken: string = "sso-abc123def456";
  const searchResult: GetSearchPagesResponse = await getSearchPages(query, tenantId, ssoToken);
  const searchResultNoSso: GetSearchPagesResponse = await getSearchPages(query, tenantId);
})();

getSearchSites

Parameters

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

Response

Returns: GetSearchSitesResponse

Example

getSearchSites Example

Copy

async function fetchSites() {
  const value: string = "customer support"
  const tenantId: string = "tenant-9876"
  const sso: string = "sso-abc123"
  const sites: GetSearchSitesResponse = await getSearchSites(value, tenantId, sso)
  const sitesOnlyTenant: GetSearchSitesResponse = await getSearchSites(undefined, tenantId)
}

getSearchSuggest

Parameters

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

Response

Returns: GetSearchSuggestResponse

Example

getSearchSuggest Example

Copy

async function example(): Promise<void> {
    const term: string = "fastcomments api";
    const tenant: string = "tenant_001";
    const sso: string = "sso_9a8b7c";
    const fullResult: GetSearchSuggestResponse = await getSearchSuggest(term, tenant, sso);
    const partialResult: GetSearchSuggestResponse = await getSearchSuggest(term);
}
example();

getSearchUsers

Parameters

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

Response

Returns: GetSearchUsersResponse

Example

getSearchUsers Example

Copy

async function demoSearch() {
    const query: string = "john.doe@example.com";
    const tenantId: string = "tenant_12345";
    const ssoToken: string = "sso_token_abc";
    const resultWithSso: GetSearchUsersResponse = await getSearchUsers(query, tenantId, ssoToken);
    const resultWithoutSso: GetSearchUsersResponse = await getSearchUsers(query, tenantId);
}

getTrustFactor

Parameters

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

Response

Returns: GetTrustFactorResponse

Example

getTrustFactor Example

Copy

async function runDemo(): Promise<void> {
    const trustFull: GetTrustFactorResponse = await getTrustFactor("user_12345", "tenant_abc", "sso_token_987");
    const trustUserOnly: GetTrustFactorResponse = await getTrustFactor("user_12345");
    console.log(trustFull, trustUserOnly);
}
runDemo();

getUserBanPreference

Parameters

Name	Type	Required	Description
tenantId	string	No
sso	string	No

Response

Returns: GetUserBanPreferenceResponse

Example

getUserBanPreference Example

Copy

async function demoGetUserBanPreference(): Promise<void> {
  const tenantId: string = "acme-corp-tenant-2024";
  const sso: string = "sso-token-9f8b7a6c";
  const result: GetUserBanPreferenceResponse = await getUserBanPreference(tenantId, sso);
  console.log(result);
}
demoGetUserBanPreference();

getUserInternalProfile

Parameters

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

Response

Returns: GetUserInternalProfileResponse1

Example

getUserInternalProfile Example

Copy

(async () => {
  const fullProfile: GetUserInternalProfileResponse1 = await getUserInternalProfile({
    commentId: "cmt_12345",
    tenantId: "tenant_67890",
    sso: "sso_token_abcdef"
  });
  const partialProfile: GetUserInternalProfileResponse1 = await getUserInternalProfile({
    commentId: "cmt_98765"
  });
})();

postAdjustCommentVotes

Parameters

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

Response

Returns: PostAdjustCommentVotesResponse

Example

postAdjustCommentVotes Example

Copy

const commentId: string = "cmt_9f8b7a6d";
const adjustParams: AdjustCommentVotesParams = {
  voteDelta: 1,
  // additional fields as required by AdjustCommentVotesParams
};
const broadcastId: string = "brd_20230915";
const tenantId: string = "tenant_42";
const sso: string = "sso-token-abc123";
const result: PostAdjustCommentVotesResponse = await postAdjustCommentVotes(
  commentId,
  adjustParams,
  broadcastId,
  tenantId,
  sso
);

postApiExport

Parameters

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

Response

Returns: PostApiExportResponse

Example

postApiExport Example

Copy

(async () => {
  const textSearch: string = "keyword:feedback"
  const byIPFromComment: string = "203.0.113.45"
  const filters: string = "status:pending,category:support"
  const searchFilters: string = "createdAt>2023-01-01"
  const sorts: string = "createdAt:desc"
  const tenantId: string = "tenant_9876"
  const sso: string = "sso_7e2a9b"
  const exportResult: PostApiExportResponse = await postApiExport(
    textSearch,
    byIPFromComment,
    filters,
    searchFilters,
    sorts,
    tenantId,
    sso
  )
  console.log(exportResult)
})()

postBanUserFromComment

Parameters

Name	Type	Required
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
tenantId	string	No
sso	string	No

Response

Returns: PostBanUserFromCommentResponse

Example

postBanUserFromComment Example

Copy

async function runBan() {
  const commentId: string = "cmt_5f8a2b3c";
  const banEmail: boolean = true;
  const banIP: boolean = false;
  const deleteAllUsersComments: boolean = true;
  const bannedUntil: string = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString();
  const isShadowBan: boolean = false;
  const banReason: string = "Repeated spam posting";
  const tenantId: string = "tenant_12345";
  const response: PostBanUserFromCommentResponse = await postBanUserFromComment(
    commentId,
    banEmail,
    undefined,
    banIP,
    deleteAllUsersComments,
    bannedUntil,
    isShadowBan,
    undefined,
    banReason,
    tenantId
  );
  console.log(response);
}
runBan();

postBanUserUndo

Parameters

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

Response

Returns: PostBanUserUndoResponse

Example

postBanUserUndo Example

Copy

const undoParams: BanUserUndoParams = {
  userId: "user-8421",
  commentId: "comment-6702",
  reason: "Accidental ban"
};
const tenantId: string = "tenant-7f9e";
const ssoToken: string = "sso-4b2c1d";
async function runUndo() {
  const resultAll: PostBanUserUndoResponse = await postBanUserUndo(undoParams, tenantId, ssoToken);
  console.log(resultAll);
  const resultMinimal: PostBanUserUndoResponse = await postBanUserUndo(undoParams);
  console.log(resultMinimal);
}
runUndo();

postBulkPreBanSummary

Parameters

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

Response

Returns: PostBulkPreBanSummaryResponse

Example

postBulkPreBanSummary Example

Copy

async function runExample() {
  const bulkPreBanParams: BulkPreBanParams = {
    userIds: [10234, 56789],
    emails: ["spam_user@example.com", "abuse@badsite.org"],
    ips: ["203.0.113.45", "198.51.100.22"],
    emailDomains: ["maliciousdomain.com"]
  };
  const includeByUserIdAndEmail: boolean = true;
  const includeByIP: boolean = false;
  const includeByEmailDomain: boolean = true;
  const tenantId: string = "tenant_8f4b2c1a";
  const sso: string = "sso-3948abf0";
  const summary: PostBulkPreBanSummaryResponse = await postBulkPreBanSummary(
    bulkPreBanParams,
    includeByUserIdAndEmail,
    includeByIP,
    includeByEmailDomain,
    tenantId,
    sso
  );
  console.log(summary);
}
runExample();

postCommentsByIds

Parameters

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

Response

Returns: PostCommentsByIdsResponse

Example

postCommentsByIds Example

Copy

const commentsByIdsParams: CommentsByIdsParams = {
  commentIds: ['cmt001', 'cmt002'],
  includeUserInfo: true,
  includeThreadInfo: false,
} as CommentsByIdsParams;
const fullResponse: PostCommentsByIdsResponse = await postCommentsByIds(
  commentsByIdsParams,
  'tenant-12345',
  'sso-token-xyz'
);
const minimalResponse: PostCommentsByIdsResponse = await postCommentsByIds(
  commentsByIdsParams
);

postFlagComment

Parameters

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

Response

Returns: PostFlagCommentResponse

Example

postFlagComment Example

Copy

const commentId: string = "cmt_20230915_001";
const broadcastId: string = "brd_20230915_live";
const tenantId: string = "tenant_42";
const sso: string = "sso_token_abc123";
const flaggedResponse: PostFlagCommentResponse = await postFlagComment(
  commentId,
  broadcastId,
  tenantId,
  sso
);

postRemoveComment

Parameters

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

Response

Returns: PostRemoveCommentResponse

Example

postRemoveComment Example

Copy

async function removeCommentExample(): Promise<void> {
  const commentId: string = "cmt_7f9a3e2b";
  const result1: PostRemoveCommentResponse = await postRemoveComment(commentId);
  const broadcastId: string = "brd_12ab34cd";
  const tenantId: string = "tenant_5678efgh";
  const sso: string = "sso_XYZ12345";
  const result2: PostRemoveCommentResponse = await postRemoveComment(commentId, broadcastId, tenantId, sso);
  console.log(result1, result2);
}

postRestoreDeletedComment

Parameters

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

Response

Returns: PostRestoreDeletedCommentResponse

Example

postRestoreDeletedComment Example

Copy

async function restoreCommentDemo(): Promise<void> {
    const commentId: string = "cmt_5f2a9b7e1234567890abcd";
    const broadcastId: string | undefined = "brd_2023_09";
    const tenantId: string | undefined = "tenant_42";
    const sso: string | undefined = "sso_token_abcdef123456";
    const response: PostRestoreDeletedCommentResponse = await postRestoreDeletedComment(
        commentId,
        broadcastId,
        tenantId,
        sso
    );
    console.log(response);
}
restoreCommentDemo();

postSetCommentApprovalStatus

Parameters

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

Response

Returns: PostSetCommentApprovalStatusResponse

Example

postSetCommentApprovalStatus Example

Copy

async function main() {
  const commentIdOnly: string = "cmt_1001";
  const resultOnly: PostSetCommentApprovalStatusResponse = await postSetCommentApprovalStatus(commentIdOnly);
  const commentIdFull: string = "cmt_2002";
  const approvedFull: boolean = true;
  const broadcastIdFull: string = "brd_3003";
  const tenantIdFull: string = "tenant_abc";
  const ssoFull: string = "sso_token_xyz";
  const resultFull: PostSetCommentApprovalStatusResponse = await postSetCommentApprovalStatus(
    commentIdFull,
    approvedFull,
    broadcastIdFull,
    tenantIdFull,
    ssoFull
  );
  console.log(resultOnly, resultFull);
}
main();

postSetCommentReviewStatus

Parameters

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

Response

Returns: PostSetCommentReviewStatusResponse

Example

postSetCommentReviewStatus Example

Copy

async function updateCommentReviewStatus(): Promise<void> {
  const commentId: string = "cmt_9f8a7b6c5d4e3f2a1b0c";
  const reviewed: boolean = true;
  const broadcastId: string = "broadcast_2024Q1";
  const tenantId: string = "tenant_1001";
  const sso: string = "alice@example.com";
  const response: PostSetCommentReviewStatusResponse = await postSetCommentReviewStatus(
    commentId,
    reviewed,
    broadcastId,
    tenantId,
    sso
  );
  console.log(response);
}

postSetCommentSpamStatus

Parameters

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

Response

Returns: PostSetCommentSpamStatusResponse

Example

postSetCommentSpamStatus Example

Copy

async function demoSpamStatus(): Promise<void> {
  const commentId: string = "cmt_5f2a1b3c4d6e7f8g9h0i";
  // Only required parameter
  const resultSimple: PostSetCommentSpamStatusResponse = await postSetCommentSpamStatus(commentId, true);
  // All optional parameters provided
  const resultFull: PostSetCommentSpamStatusResponse = await postSetCommentSpamStatus(
    commentId,
    false,
    true,
    "brd_1234abcd",
    "tenant_42",
    "sso_9876xyz"
  );
  console.log(resultSimple, resultFull);
}

postSetCommentText

Parameters

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

Response

Returns: PostSetCommentTextResponse

Example

postSetCommentText Example

Copy

(async () => {
  const commentId: string = "cmt_9f8b7a6d5e4c3b2a1";
  const setParams: SetCommentTextParams = {
    text: "Edited comment to correct a typo and add clarification."
  };
  const broadcastId: string = "brd_1a2b3c4d5e6f7g8h9";
  const tenantId: string = "tenant_xyz123";
  const sso: string = "sso_user_456def";
  const fullResult: PostSetCommentTextResponse = await postSetCommentText(
    commentId,
    setParams,
    broadcastId,
    tenantId,
    sso
  );
  const minimalResult: PostSetCommentTextResponse = await postSetCommentText(
    commentId,
    setParams
  );
  console.log(fullResult, minimalResult);
})();

postUnFlagComment

Parameters

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

Response

Returns: PostUnFlagCommentResponse

Example

postUnFlagComment Example

Copy

async () => {
  const response: PostUnFlagCommentResponse = await postUnFlagComment(
    "cmt_12345",          // commentId
    "brd_67890",          // broadcastId (optional)
    "tenant_abc",         // tenantId (optional)
    "sso_user_token_789"  // sso (optional)
  );
};

postVote

Parameters

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

Response

Returns: PostVoteResponse

Example

postVote Example

Copy

let commentId: string = 'cmt_12345';
let direction: string = 'up';
let broadcastId: string = 'brd_67890';
let tenantId: string = 'tenant_abc';
let sso: string = 'sso_token_xyz';
const fullVote: PostVoteResponse = await postVote(
  commentId,
  direction,
  broadcastId,
  tenantId,
  sso
);
const simpleVote: PostVoteResponse = await postVote('cmt_67890');

putAwardBadge

Parameters

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

Response

Returns: PutAwardBadgeResponse

Example

putAwardBadge Example

Copy

(async () => {
    const badgeId: string = "badge-superstar"
    const userId: string = "user-42"
    const commentId: string = "comment-7f9c3"
    const broadcastId: string = "broadcast-2023-09"
    const result: PutAwardBadgeResponse = await putAwardBadge(badgeId, userId, commentId, broadcastId)
    console.log(result)
})()

putCloseThread

Parameters

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

Response

Returns: PutCloseThreadResponse

Example

putCloseThread Example

Copy

async function closeThreadDemo(): Promise<void> {
  const urlId: string = "article-2023-09-15";
  const tenantId: string = "tenant-42";
  const sso: string = "sso-token-xyz";
  const response: PutCloseThreadResponse = await putCloseThread(urlId, tenantId, sso);
  console.log(response);
}
closeThreadDemo();

putRemoveBadge

Parameters

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

Response

Returns: PutRemoveBadgeResponse

Example

putRemoveBadge Example

Copy

const badgeId: string = "badge-12345";
const userId: string = "user-9876";
const commentId: string = "comment-5555";
const broadcastId: string = "broadcast-001";
const result: PutRemoveBadgeResponse = await putRemoveBadge(
  badgeId,
  userId,
  commentId,
  broadcastId
);

putReopenThread

Parameters

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

Response

Returns: PutReopenThreadResponse

Example

putReopenThread Example

Copy

async function exampleUsage() {
  const urlId: string = "thread-9f8b7c6a";
  const tenantId: string = "tenant-001";
  const sso: string = "sso-3f9d2e1a";
  const resultAll: PutReopenThreadResponse = await putReopenThread(urlId, tenantId, sso);
  console.log(resultAll);
  const resultMinimal: PutReopenThreadResponse = await putReopenThread(urlId);
  console.log(resultMinimal);
}

setTrustFactor

Parameters

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

Response

Returns: SetTrustFactorResponse

Example

setTrustFactor Example

Copy

(async () => {
  const userId: string = "user_8421";
  const trustFactor: string = "high";
  const tenantId: string = "tenant_33";
  const ssoToken: string = "sso_7d9f";
  const fullResult: SetTrustFactorResponse = await setTrustFactor(userId, trustFactor, tenantId, ssoToken);
  const minimalResult: SetTrustFactorResponse = await setTrustFactor(userId, trustFactor);
})();

createModerator

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createModeratorBody	CreateModeratorBody	Yes

Response

Returns: CreateModeratorResponse1

Example

createModerator Example

Copy

async function runExample() {
  const tenantId: string = "tenant_9876";
  const moderatorPayload: CreateModeratorBody = {
    name: "Alice Johnson",
    email: "alice.johnson@example.com"
    // optional fields like description are omitted
  };
  const result: CreateModeratorResponse1 = await createModerator(tenantId, moderatorPayload);
  console.log(result);
}
runExample();

deleteModerator

Parameters

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

Response

Returns: DeleteModeratorResponse

Example

deleteModerator Example

Copy

async function runDeleteModeratorExample() {
  const tenantId: string = "tenant_2023";
  const moderatorId: string = "mod_001";
  const notificationEmail: string = "admin@mycompany.com";
  const resultWithEmail: DeleteModeratorResponse = await deleteModerator(tenantId, moderatorId, notificationEmail);
  const resultWithoutEmail: DeleteModeratorResponse = await deleteModerator(tenantId, moderatorId);
}

getModerator

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetModeratorResponse1

Example

getModerator Example

Copy

(async () => {
  const tenantId: string = "acme-corp-001";
  const id: string = "mod-12345";
  const result: GetModeratorResponse1 = await getModerator(tenantId, id);
  const moderatorName: string | undefined = result.moderator?.name;
  console.log(moderatorName);
})();

getModerators

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetModeratorsResponse1

Example

getModerators Example

Copy

async function fetchModerators(): Promise<void> {
  const tenantId: string = "tenant-9876";
  const skip: number = 30; // optional pagination offset
  const moderators: GetModeratorsResponse1 = await getModerators(tenantId, skip);
  // Example without pagination:
  // const allModerators: GetModeratorsResponse1 = await getModerators(tenantId);
}

sendInvite

Parameters

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

Response

Returns: SendInviteResponse

Example

sendInvite Example

Copy

const tenantId: string = "acme-corp-tenant";
const inviteId: string = "invite-12345";
const fromName: string = "John Doe";
const inviteResult: SendInviteResponse = await sendInvite(tenantId, inviteId, fromName);

updateModerator

Parameters

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

Response

Returns: UpdateModeratorResponse

Example

updateModerator Example

Copy

async function demoUpdateModerator(): Promise<void> {
    const tenantId: string = "tenant_42abc";
    const moderatorId: string = "moderator_8f9e";
    const updateBody: UpdateModeratorBody = {
        isActive: true,
        role: "admin",
        // optional field
        notes: "Promoted to senior moderator"
    };
    const result: UpdateModeratorResponse = await updateModerator(tenantId, moderatorId, updateBody);
    console.log(result);
}
demoUpdateModerator();

deleteNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeleteNotificationCountResponse

Example

deleteNotificationCount Example

Copy

async function run() {
  const tenantId: string = "tenant_12345";
  const notificationId: string = "notif_98765";
  const result: DeleteNotificationCountResponse = await deleteNotificationCount(tenantId, notificationId);
  console.log(result);
}
run();

getCachedNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetCachedNotificationCountResponse1

Example

getCachedNotificationCount Example

Copy

const tenantId: string = "e3f1a9b2-4c5d-6e7f-8a9b-0c1d2e3f4a5b";
const userId: string = "u-20231101-001";
const notificationResult: GetCachedNotificationCountResponse1 = await getCachedNotificationCount(tenantId, userId);
console.log(notificationResult);

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: GetNotificationCountResponse1

Example

getNotificationCount Example

Copy

async function demoNotificationCount() {
    const tenantId: string = "tenant_001";
    const userId: string = "user_42";
    const urlId: string = "url_9f8e7d";
    const fromCommentId: string = "comment_12345";
    const viewed: boolean = false;
    const type: string = "mention";
    const result: GetNotificationCountResponse1 = await getNotificationCount(
        tenantId,
        userId,
        urlId,
        fromCommentId,
        viewed,
        type
    );
    console.log(result);
}
demoNotificationCount();

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: GetNotificationsResponse1

Example

getNotifications Example

Copy

async function demo() {
  const tenantId: string = "acme-corp";
  const userId: string = "john.doe";
  const notifications: GetNotificationsResponse1 = await getNotifications(tenantId, userId);
  console.log(notifications);
  const more: GetNotificationsResponse1 = await getNotifications(
    tenantId,
    undefined,
    "article-5678",
    undefined,
    true,
    "reply",
    10
  );
  console.log(more);
}
demo();

updateNotification

Parameters

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

Response

Returns: UpdateNotificationResponse

Example

updateNotification Example

Copy

const tenantId: string = "tenant_5f4d2c";
const notificationId: string = "notif_9b8a7c";
const updateBody: UpdateNotificationBody = {
  enabled: false,
  sendEmail: true,
  schedule: "2023-12-01T08:00:00Z"
};
const userId: string = "user_123e4567";
const responseWithUser: UpdateNotificationResponse = await updateNotification(
  tenantId,
  notificationId,
  updateBody,
  userId
);
const responseWithoutUser: UpdateNotificationResponse = await updateNotification(
  tenantId,
  notificationId,
  updateBody
);

createV1PageReact

Parameters

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

Response

Returns: CreateV1PageReactResponse

Example

createV1PageReact Example

Copy

const tenantId: string = "tenant_12345";
const urlId: string = "article-2024-06-improvements";
const title: string = "FastComments API Integration Guide";
const responseWithTitle: CreateV1PageReactResponse = await createV1PageReact(tenantId, urlId, title);
const responseWithoutTitle: CreateV1PageReactResponse = await createV1PageReact(tenantId, urlId);

createV2PageReact

Parameters

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

Response

Returns: CreateV2PageReactResponse

Example

createV2PageReact Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const urlId: string = "blog/posts/fastcomments-integration";
  const pageId: string = "page-12345";
  const title: string = "FastComments API Integration Guide";
  const responseWithoutTitle: CreateV2PageReactResponse = await createV2PageReact(tenantId, urlId, pageId);
  const responseWithTitle: CreateV2PageReactResponse = await createV2PageReact(tenantId, urlId, pageId, title);
  console.log(responseWithoutTitle, responseWithTitle);
})();

deleteV1PageReact

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Response

Returns: DeleteV1PageReactResponse

Example

deleteV1PageReact Example

Copy

const tenantId: string = "acme-corp";
const urlId: string = "article-2024-06-01";
const response: DeleteV1PageReactResponse = await deleteV1PageReact(tenantId, urlId);
console.log(response);

deleteV2PageReact

Parameters

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

Response

Returns: DeleteV2PageReactResponse

Example

deleteV2PageReact Example

Copy

const tenantId: string = "tenant_12345";
const urlId: string = "page_98765";
const reactionId: string = "react_abcde";
const deleteResult: DeleteV2PageReactResponse = await deleteV2PageReact(tenantId, urlId, reactionId);

getV1PageLikes

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Response

Returns: GetV1PageLikesResponse

Example

getV1PageLikes Example

Copy

async function fetchPageLikes() {
  const tenantId: string = "acme-corp-tenant-42";
  const urlId: string = "blog-post-2024-06-typescript-best-practices";
  const likes: GetV1PageLikesResponse = await getV1PageLikes(tenantId, urlId);
  console.log(likes);
}

getV2PageReacts

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Response

Returns: GetV2PageReactsResponse

Example

getV2PageReacts Example

Copy

async function demoGetPageReacts(): Promise<void> {
    const tenantId: string = "acme-corp-tenant";
    const urlId: string = "article-2024-06-01";
    const reacts: GetV2PageReactsResponse = await getV2PageReacts(tenantId, urlId);
    // optional property access example
    const customConfig: CustomConfigParameters | undefined = reacts.customConfig;
    console.log(reacts);
}
demoGetPageReacts();

getV2PageReactUsers

Parameters

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

Response

Returns: GetV2PageReactUsersResponse1

Example

getV2PageReactUsers Example

Copy

async function fetchReactUsers() {
  const tenantId: string = 'tenant_12345';
  const urlId: string = 'article-9876';
  const id: string = 'user_abcde';
  const response: GetV2PageReactUsersResponse1 = await getV2PageReactUsers(tenantId, urlId, id);
  console.log(response);
}
fetchReactUsers();

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: GetOfflineUsersResponse

Example

getOfflineUsers Example

Copy

async function fetchOfflineUsers(): Promise<void> {
    const tenantId: string = "tenant_12345";
    const urlId: string = "thread_9876";
    const afterName: string = "Jane Smith";
    const afterUserId: string = "user_7f9b3c";
    const offlineUsers: GetOfflineUsersResponse = await getOfflineUsers(
        tenantId,
        urlId,
        afterName,
        afterUserId
    );
    console.log(offlineUsers);
}

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: GetOnlineUsersResponse

Example

getOnlineUsers Example

Copy

async function demoOnlineUsers() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "url_98765";
  // With optional pagination parameters
  const pagedResult: GetOnlineUsersResponse = await getOnlineUsers(
    tenantId,
    urlId,
    "alice_smith",
    "user_9"
  );
  // Without optional pagination parameters
  const fullResult: GetOnlineUsersResponse = await getOnlineUsers(tenantId, urlId);
}

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: GetPagesPublicResponse

Example

getPagesPublic Example

Copy

async function fetchPages() {
  const tenantId: string = "tenant_12345";
  const cursor: string = "nextPageToken";
  const limit: number = 20;
  const q: string = "blog";
  const sortBy: PagesSortBy = "createdAt";
  const hasComments: boolean = true;
  const response: GetPagesPublicResponse = await getPagesPublic(
    tenantId,
    cursor,
    limit,
    q,
    sortBy,
    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: GetUsersInfoResponse

Example

getUsersInfo Example

Copy

const tenantId: string = "acme-corp-tenant";
const ids: string = "user-1001,user-1002";
const usersInfo: GetUsersInfoResponse = await getUsersInfo(tenantId, ids);
// Optional fields in the response may be undefined
const firstUser: PageUserEntry | undefined = usersInfo?.users?.[0];

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: DeletePendingWebhookEventResponse

Example

deletePendingWebhookEvent Example

Copy

async function runDemo() {
  const tenantId: string = 'c3f5e9d2-1a2b-4c3d-9e7f-1234567890ab';
  const eventId: string = 'event_987654321';
  const response: DeletePendingWebhookEventResponse = await deletePendingWebhookEvent(tenantId, eventId);
  console.log(response);
}
runDemo();

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: GetPendingWebhookEventCountResponse1

Example

getPendingWebhookEventCount Example

Copy

(async () => {
  const tenantId: string = "tenant_001";
  const responseAll: GetPendingWebhookEventCountResponse1 = await getPendingWebhookEventCount(
    tenantId,
    "comment_456",
    "ext_789",
    "comment.updated",
    "webhook",
    "mydomain.com",
    3
  );
  const responseMinimal: GetPendingWebhookEventCountResponse1 = await getPendingWebhookEventCount(tenantId);
  console.log(responseAll, responseMinimal);
})();

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: GetPendingWebhookEventsResponse1

Example

getPendingWebhookEvents Example

Copy

async function fetchPendingEvents(): Promise<void> {
    const tenantId: string = "123e4567-e89b-12d3-a456-426614174000";
    const commentId: string = "cmt-987654321";
    const externalId: string = "ext-abc-123";
    const eventType: string = "comment_created";
    const type: string = "outbound";
    const domain: string = "myblog.com";
    const attemptCountGT: number = 3;
    const skip: number = 0;
    const pending: GetPendingWebhookEventsResponse1 = await getPendingWebhookEvents(
        tenantId,
        commentId,
        externalId,
        eventType,
        type,
        domain,
        attemptCountGT,
        skip
    );
    console.log(pending);
}
fetchPendingEvents();

createQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createQuestionConfigBody	CreateQuestionConfigBody	Yes

Response

Returns: CreateQuestionConfigResponse1

Example

createQuestionConfig Example

Copy

const tenantId: string = "tenant_12345";
const customOption: QuestionConfigCustomOptionsInner = {
  label: "Option A",
  value: "a",
};
const createQuestionConfigBody: CreateQuestionConfigBody = {
  questionText: "What is your favorite color?",
  isActive: true,
  // optional fields can be omitted
  customOptions: [customOption],
};
const response: CreateQuestionConfigResponse1 = await createQuestionConfig(
  tenantId,
  createQuestionConfigBody
);

deleteQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeleteQuestionConfigResponse

Example

deleteQuestionConfig Example

Copy

async function runDeletion(): Promise<void> {
  const tenantId: string = "tenant_8f5a2c9d";
  const configId: string = "questionConfig_4b7e1f";
  const deleteResult: DeleteQuestionConfigResponse = await deleteQuestionConfig(tenantId, configId);
  console.log(deleteResult);
}
void runDeletion();

getQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetQuestionConfigResponse1

Example

getQuestionConfig Example

Copy

const tenantId: string = "acme-corp-tenant-42";
const questionId: string = "question-7f9b3e";
const response: GetQuestionConfigResponse1 = await getQuestionConfig(tenantId, questionId);

getQuestionConfigs

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetQuestionConfigsResponse1

Example

getQuestionConfigs Example

Copy

async function fetchQuestionConfigs() {
    const tenantId: string = "tenant-9876";
    // Call without the optional 'skip' parameter
    const configsWithoutSkip: GetQuestionConfigsResponse1 = await getQuestionConfigs(tenantId);
    // Call with the optional 'skip' parameter
    const skip: number = 10;
    const configsWithSkip: GetQuestionConfigsResponse1 = await getQuestionConfigs(tenantId, skip);
    console.log(configsWithoutSkip, configsWithSkip);
}

updateQuestionConfig

Parameters

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

Response

Returns: UpdateQuestionConfigResponse

Example

updateQuestionConfig Example

Copy

const tenantId: string = "acme-corp-tenant";
const questionId: string = "qstn-2023-04";
const updateBody: UpdateQuestionConfigBody = {
  // optional fields demonstrated
  customOptions: [
    {
      id: "opt-001",
      label: "Extra Details",
      required: true,
    },
  ],
  renderingType: "markdown",
};
const response: UpdateQuestionConfigResponse = await updateQuestionConfig(
  tenantId,
  questionId,
  updateBody
);

createQuestionResult

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createQuestionResultBody	CreateQuestionResultBody	Yes

Response

Returns: CreateQuestionResultResponse1

Example

createQuestionResult Example

Copy

const tenantId: string = "acme-corp-tenant";
const metaItem: MetaItem = {
  key: "campaign",
  value: "spring-launch"
};
const questionResultBody: CreateQuestionResultBody = {
  questionId: "question-42",
  answer: "Positive",
  metadata: [metaItem]
  // optional fields such as notes are omitted
};
const result: CreateQuestionResultResponse1 = await createQuestionResult(tenantId, questionResultBody);

deleteQuestionResult

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeleteQuestionResultResponse

Example

deleteQuestionResult Example

Copy

async function runDeletion(): Promise<void> {
    const tenantId: string = "tenant-001";
    const resultId: string = "c9f2a5b3-7e6d-4c9a-8b1f-2d3e4f5a6b7c";
    const result: DeleteQuestionResultResponse = await deleteQuestionResult(tenantId, resultId);
    console.log(result);
}
runDeletion();

getQuestionResult

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetQuestionResultResponse1

Example

getQuestionResult Example

Copy

async function fetchQuestionResult(): Promise<void> {
    const tenantId: string = "acme-corp-001";
    const questionId: string = "question-7a9b8c";
    const result: GetQuestionResultResponse1 = await getQuestionResult(tenantId, questionId);
    const question: QuestionResult | undefined = result.questionResult;
    const firstMeta: MetaItem | undefined = result.meta?.[0];
    console.log(question?.id, firstMeta?.key);
}

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: GetQuestionResultsResponse1

Example

getQuestionResults Example

Copy

(async () => {
  const tenantId: string = "acme-corp-123";
  const urlId: string = "post-456";
  const userId: string = "user-789";
  const startDate: string = "2023-09-01T00:00:00Z";
  const questionId: string = "q-101";
  const questionIds: string = "q-102,q-103";
  const skip: number = 20;
  const results: GetQuestionResultsResponse1 = await getQuestionResults(
    tenantId,
    urlId,
    userId,
    startDate,
    questionId,
    questionIds,
    skip
  );
  console.log(results);
})();

updateQuestionResult

Parameters

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

Response

Returns: UpdateQuestionResultResponse

Example

updateQuestionResult Example

Copy

async function runUpdate() {
    const tenantId: string = "acme-corp-01";
    const id: string = "qr-20230915-001";
    const updateQuestionResultBody: UpdateQuestionResultBody = {
        // required fields
        answer: "No",
        // optional fields
        comment: "User clarified their response",
        // anotherOptionalField?: value,
    };
    const result: UpdateQuestionResultResponse = await updateQuestionResult(
        tenantId,
        id,
        updateQuestionResultBody
    );
    console.log(result);
}
runUpdate();

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: AggregateQuestionResultsResponse1

Example

aggregateQuestionResults Example

Copy

(async () => {
  const tenantId: string = "acme-corp-123";
  const questionId: string = "feedback-rating";
  const questionIds: string[] = ["feedback-rating", "recommendation"];
  const urlId: string = "https://myblog.com/articles/42";
  const timeBucket: AggregateTimeBucket = "month";
  const startDate: Date = new Date("2023-01-01T00:00:00Z");
  const forceRecalculate: boolean = true;
  const result: AggregateQuestionResultsResponse1 = await aggregateQuestionResults(
    tenantId,
    questionId,
    questionIds,
    urlId,
    timeBucket,
    startDate,
    forceRecalculate
  );
  console.log(result);
})();

bulkAggregateQuestionResults

Parameters

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

Response

Returns: BulkAggregateQuestionResultsResponse1

Example

bulkAggregateQuestionResults Example

Copy

const tenantId: string = "acme-corp";
const request: BulkAggregateQuestionResultsRequest = {
  questionIds: ["product-satisfaction", "feature-usage"],
  startDate: "2024-01-01T00:00:00Z",
  endDate: "2024-01-31T23:59:59Z",
  timeBucket: "day"
};
const result: BulkAggregateQuestionResultsResponse1 = 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: CombineCommentsWithQuestionResultsResponse

Example

combineCommentsWithQuestionResults Example

Copy

const tenantId: string = "tenant_12345";
const questionIds: string[] = ["question_1", "question_2"];
const urlId: string = "article-9876";
const startDate: Date = new Date("2023-01-01T00:00:00Z");
const forceRecalculate: boolean = false;
const minValue: number = 1;
const maxValue: number = 5;
const limit: number = 50;
const result: CombineCommentsWithQuestionResultsResponse = await combineCommentsWithQuestionResults(
  tenantId,
  undefined,
  questionIds,
  urlId,
  startDate,
  forceRecalculate,
  minValue,
  maxValue,
  limit
);

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: GetTenantDailyUsagesResponse1

Example

getTenantDailyUsages Example

Copy

async function fetchDailyUsage() {
  const tenantId: string = "tenant-9876";
  const yearNumber: number = 2024;
  const monthNumber: number = 5; // May
  const dayNumber: number = 12;
  const skip: number = 0;
  const fullResult: GetTenantDailyUsagesResponse1 = await getTenantDailyUsages(
    tenantId,
    yearNumber,
    monthNumber,
    dayNumber,
    skip
  );
  // Using only required and one optional parameter
  const partialResult: GetTenantDailyUsagesResponse1 = await getTenantDailyUsages(
    tenantId,
    yearNumber
  );
  console.log(fullResult, partialResult);
}
fetchDailyUsage();

createTenantPackage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createTenantPackageBody	CreateTenantPackageBody	Yes

Response

Returns: CreateTenantPackageResponse1

Example

createTenantPackage Example

Copy

(async () => {
  const tenantId: string = "tenant-9876";
  const body: CreateTenantPackageBody = {
    packageName: "Standard",
    quota: 5000,
    // optional field
    description: "Standard package for medium traffic",
  };
  const result: CreateTenantPackageResponse1 = await createTenantPackage(tenantId, body);
  console.log(result);
})();

deleteTenantPackage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeleteTenantPackageResponse

Example

deleteTenantPackage Example

Copy

async function removeTenantPackage(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const packageId: string = "pkg_67890";
  const result: DeleteTenantPackageResponse = await deleteTenantPackage(tenantId, packageId);
  // use result as needed
}
removeTenantPackage();

getTenantPackage

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetTenantPackageResponse1

Example

getTenantPackage Example

Copy

async function fetchTenantPackage(): Promise<void> {
    const tenantId: string = "acme-tenant-2024";
    const packageId: string = "premium-package-01";
    const response: GetTenantPackageResponse1 = await getTenantPackage(tenantId, packageId);
    // Optional fields in the response
    const tenantPackage: TenantPackage | undefined = response.tenantPackage;
    const customConfig: CustomConfigParameters | undefined = response.customConfigParameters;
}

getTenantPackages

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetTenantPackagesResponse1

Example

getTenantPackages Example

Copy

(async () => {
  const tenantId: string = 'tenant_67890';
  const skip: number = 30;
  const packagesWithSkip: GetTenantPackagesResponse1 = await getTenantPackages(tenantId, skip);
  const packagesWithoutSkip: GetTenantPackagesResponse1 = await getTenantPackages(tenantId);
  console.log(packagesWithSkip, packagesWithoutSkip);
})();

replaceTenantPackage

Parameters

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

Response

Returns: ReplaceTenantPackageResponse

Example

replaceTenantPackage Example

Copy

(async () => {
    const tenantId: string = "acme-corp-tenant-01";
    const packageId: string = "pkg-2024-annual";
    const config: CustomConfigParameters = {
        // custom configuration fields here
    };
    const body: ReplaceTenantPackageBody = {
        name: "Enterprise Package",
        // optional custom configuration
        customConfig: config,
    };
    const response: ReplaceTenantPackageResponse = await replaceTenantPackage(tenantId, packageId, body);
    console.log(response);
})();

updateTenantPackage

Parameters

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

Response

Returns: UpdateTenantPackageResponse

Example

updateTenantPackage Example

Copy

const tenantId: string = "tenant-9876";
const packageId: string = "pkg-2023";
const customConfig: CustomConfigParameters = {
  enableSpamFilter: true,
  spamRatingThreshold: 4,
};
const updateBody: UpdateTenantPackageBody = {
  displayName: "Enterprise Pro",
  customConfig,
};
const response: UpdateTenantPackageResponse = await updateTenantPackage(
  tenantId,
  packageId,
  updateBody
);

createTenantUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createTenantUserBody	CreateTenantUserBody	Yes

Response

Returns: CreateTenantUserResponse1

Example

createTenantUser Example

Copy

const tenantId: string = "a1b2c3d4-5678-90ab-cdef-1234567890ab";
const newUser: CreateTenantUserBody = {
  email: "jane.doe@example.com",
  firstName: "Jane",
  lastName: "Doe",
  role: "admin",
  // optional parameters
  phoneNumber: "+15551234567",
  isActive: true,
};
const result: CreateTenantUserResponse1 = await createTenantUser(tenantId, newUser);

deleteTenantUser

Parameters

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

Response

Returns: DeleteTenantUserResponse

Example

deleteTenantUser Example

Copy

async function demoDeleteTenantUser() {
  const tenantId: string = "acme-corp-tenant";
  const userId: string = "user-9876";
  // Delete the user and all their comments, using hard delete mode
  const resultWithOptions: DeleteTenantUserResponse = await deleteTenantUser(
    tenantId,
    userId,
    "true",
    "hard"
  );
  // Delete the user without removing comments (default behavior)
  const resultBasic: DeleteTenantUserResponse = await deleteTenantUser(tenantId, userId);
}

getTenantUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetTenantUserResponse1

Example

getTenantUser Example

Copy

async function fetchUser(): Promise<void> {
  const tenantId: string = "tenant-01a2b3c";
  const userId: string = "user-7890";
  const result: GetTenantUserResponse1 = await getTenantUser(tenantId, userId);
  console.log(result);
}

getTenantUsers

Parameters

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Response

Returns: GetTenantUsersResponse1

Example

getTenantUsers Example

Copy

(async () => {
  const tenantId: string = "tenant_9f7a2c";
  const skip: number = 25;
  const usersPage: GetTenantUsersResponse1 = await getTenantUsers(tenantId, skip);
  const allUsers: GetTenantUsersResponse1 = await getTenantUsers(tenantId);
})();

replaceTenantUser

Parameters

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

Response

Returns: ReplaceTenantUserResponse

Example

replaceTenantUser Example

Copy

async function updateUser() {
  const tenantId: string = "c3d1f2e4-5b6a-4c7d-9f2e-1234567890ab";
  const userId: string = "u-654321";
  const replaceBody: ReplaceTenantUserBody = {
    email: "newuser@example.com",
    username: "newusername"
  };
  const response: ReplaceTenantUserResponse = await replaceTenantUser(
    tenantId,
    userId,
    replaceBody,
    "true"
  );
  console.log(response);
}
updateUser();

sendLoginLink

Parameters

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

Response

Returns: SendLoginLinkResponse

Example

sendLoginLink Example

Copy

async function demoSendLoginLink() {
  const tenantId: string = "acme-corp";
  const userId: string = "user-9876";
  const redirectURL: string = "https://app.acme-corp.com/auth/callback";
  const resultWithRedirect: SendLoginLinkResponse = await sendLoginLink(tenantId, userId, redirectURL);
  const resultWithoutRedirect: SendLoginLinkResponse = await sendLoginLink(tenantId, userId);
}

updateTenantUser

Parameters

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

Response

Returns: UpdateTenantUserResponse

Example

updateTenantUser Example

Copy

let tenantId: string = "5f8f8c1a2e9b3c001c2a9b2d";
let userId: string = "user_98765";
let updateBody: UpdateTenantUserBody = {
  email: "jane.smith@example.com",
  role: "moderator",
  isActive: false,
};
let updateComments: string = "Deactivated user due to policy violation.";
let result: UpdateTenantUserResponse = await updateTenantUser(tenantId, userId, updateBody, updateComments);

createTenant

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

Response

Returns: CreateTenantResponse1

Example

createTenant Example

Copy

async function example() {
  const tenantId: string = 'tenant-2024-01';
  const createTenantBody: CreateTenantBody = {
    // required fields
    name: 'Acme International',
    // optional fields can be added as needed, e.g.:
    // billingInfo: { address: '123 Main St', city: 'Metropolis' } as BillingInfo,
  };
  const response: CreateTenantResponse1 = await createTenant(tenantId, createTenantBody);
  console.log(response);
}

deleteTenant

Parameters

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

Response

Returns: DeleteTenantResponse

Example

deleteTenant Example

Copy

async function runExample() {
    const tenantId: string = "tenant_12345";
    const id: string = "resource_98765";
    const sure: string = "confirm";
    // Call with optional 'sure' parameter
    const responseWithSure: DeleteTenantResponse = await deleteTenant(tenantId, id, sure);
    console.log(responseWithSure);
    // Call without optional 'sure' parameter
    const responseWithoutSure: DeleteTenantResponse = await deleteTenant(tenantId, id);
    console.log(responseWithoutSure);
}
runExample();

getTenant

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetTenantResponse1

Example

getTenant Example

Copy

async function fetchTenant(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const id: string = "user_9876";
  const tenantInfo: GetTenantResponse1 = await getTenant(tenantId, id);
  console.log(tenantInfo);
}
fetchTenant();

getTenants

Parameters

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

Response

Returns: GetTenantsResponse1

Example

getTenants Example

Copy

(async () => {
  const tenantId: string = "tenant-9f8e7d6c";
  const resultOnlyId: GetTenantsResponse1 = await getTenants(tenantId);
  const resultWithMeta: GetTenantsResponse1 = await getTenants(tenantId, "full");
  const resultAllParams: GetTenantsResponse1 = await getTenants(tenantId, "full", 15);
  console.log(resultOnlyId, resultWithMeta, resultAllParams);
})();

updateTenant

Parameters

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

Response

Returns: UpdateTenantResponse

Example

updateTenant Example

Copy

const tenantId: string = "c8f9e3d2-4b6a-11ee-8c99-0242ac130003";
const id: string = "tenant-config-01";
const updateBody: UpdateTenantBody = {
  domain: "mytenant.fastcomments.io",
  branding: {
    logoUrl: "https://cdn.mytenant.com/assets/logo.png"
  },
  description: "Branding update for Q3"
};
const response: UpdateTenantResponse = await updateTenant(tenantId, id, updateBody);
console.log(response);

changeTicketState

Parameters

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

Response

Returns: ChangeTicketStateResponse1

Example

changeTicketState Example

Copy

const tenantId: string = "acme-corp";
const userId: string = "user-97123";
const ticketId: string = "ticket-45001";
const changeTicketStateBody: ChangeTicketStateBody = {
  state: "closed",
  // optional field in the body
  comment: "Issue resolved after code fix"
};
const response: ChangeTicketStateResponse1 = await changeTicketState(
  tenantId,
  userId,
  ticketId,
  changeTicketStateBody
);

createTicket

Parameters

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

Response

Returns: CreateTicketResponse1

Example

createTicket Example

Copy

const tenantId: string = "tenant_12345";
const userId: string = "user_98765";
const ticketBody: CreateTicketBody = {
  subject: "Issue with payment processing"
  // description?: string is optional and omitted
};
const response: CreateTicketResponse1 = await createTicket(tenantId, userId, ticketBody);
// Example of using an optional field from the response
// console.log(response.ticket?.id);

getTicket

Parameters

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

Response

Returns: GetTicketResponse1

Example

getTicket Example

Copy

const tenantId: string = "acme-inc";
const ticketId: string = "ticket-3421";
const userId: string = "alice.smith";
const ticketWithUser: GetTicketResponse1 = await getTicket(tenantId, ticketId, userId);
const ticketWithoutUser: GetTicketResponse1 = 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: GetTicketsResponse1

Example

getTickets Example

Copy

async function loadTickets() {
  const tenantId: string = "acme-corp";
  const userId: string = "john.doe";
  const state: number = 2; // e.g., closed
  const skip: number = 10;
  const limit: number = 5;
  const ticketsFull: GetTicketsResponse1 = await getTickets(tenantId, userId, state, skip, limit);
  const ticketsPartial: GetTicketsResponse1 = await getTickets(tenantId);
}
loadTickets();

getTranslations

Parameters

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

Response

Returns: GetTranslationsResponse1

Example

getTranslations Example

Copy

(async () => {
  const namespace: string = 'blog';
  const component: string = 'comment-editor';
  const locale: string = 'fr-FR';
  const useFullTranslationIds: boolean = true;
  const basicTranslations: GetTranslationsResponse1 = await getTranslations(namespace, component);
  const fullTranslations: GetTranslationsResponse1 = await getTranslations(namespace, component, locale, useFullTranslationIds);
})();

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: GetUserBadgeProgressByIdResponse

Example

getUserBadgeProgressById Example

Copy

async function demo(): Promise<void> {
    const tenantId: string = "acme-corp";
    const userId: string = "user-42";
    const result: GetUserBadgeProgressByIdResponse = await getUserBadgeProgressById(tenantId, userId);
    const progress: UserBadgeProgress | undefined = result.progress;
    const earnedAt: Date | undefined = progress?.earnedAt;
    console.log(`Badge earned at: ${earnedAt?.toISOString() ?? "not earned yet"}`);
}
demo();

getUserBadgeProgressByUserId

Parameters

Name	Type	Required	Description
tenantId	string	Yes
userId	string	Yes

Response

Returns: GetUserBadgeProgressByUserIdResponse

Example

getUserBadgeProgressByUserId Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const userId: string = "user-12345";
  const badgeProgress: GetUserBadgeProgressByUserIdResponse = await getUserBadgeProgressByUserId(tenantId, userId);
  console.log(badgeProgress);
})();

getUserBadgeProgressList

Parameters

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

Response

Returns: GetUserBadgeProgressListResponse

Example

getUserBadgeProgressList Example

Copy

async function fetchBadgeProgress() {
  const tenantId: string = "acme-corp";
  const userId: string = "john.doe@example.com";
  const limit: number = 10;
  const skip: number = 5;
  const fullList: GetUserBadgeProgressListResponse = await getUserBadgeProgressList(
    tenantId,
    userId,
    limit,
    skip
  );
  const simpleList: GetUserBadgeProgressListResponse = await getUserBadgeProgressList(tenantId);
}
fetchBadgeProgress();

createUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
createUserBadgeParams	CreateUserBadgeParams	Yes

Response

Returns: CreateUserBadgeResponse

Example

createUserBadge Example

Copy

const tenantId: string = "company-42";
const badgeParams: CreateUserBadgeParams = {
  name: "Community Champion",
  iconUrl: "https://assets.example.com/badges/champion.png",
  // description is optional and omitted here
};
const result: CreateUserBadgeResponse = await createUserBadge(tenantId, badgeParams);

deleteUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: DeleteUserBadgeResponse

Example

deleteUserBadge Example

Copy

async function exampleDeleteBadge(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c6a";
  const badgeId: string = "badge_4e3d2c1b";
  const result: DeleteUserBadgeResponse = await deleteUserBadge(tenantId, badgeId);
  console.log(result);
}
exampleDeleteBadge();

getUserBadge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetUserBadgeResponse

Example

getUserBadge Example

Copy

async function runExample(): Promise<void> {
  const tenantId: string = "acme-corp-tenant-001";
  const badgeId: string = "badge-5f9d3a2b";
  const badgeResponse: GetUserBadgeResponse = await getUserBadge(tenantId, badgeId);
  // Access optional fields safely
  const badgeName: string | undefined = badgeResponse.userBadge?.name;
  console.log(`Badge ID: ${badgeId}, Name: ${badgeName ?? "Unnamed"}`);
}
runExample();

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: GetUserBadgesResponse

Example

getUserBadges Example

Copy

async function example() {
  const tenantId: string = "tenant-01";
  const userId: string = "user-42";
  const badgeId: string = "badge-gold";
  const type: number = 1;
  const displayedOnComments: boolean = true;
  const limit: number = 10;
  const skip: number = 5;
  const fullResult: GetUserBadgesResponse = await getUserBadges(
    tenantId,
    userId,
    badgeId,
    type,
    displayedOnComments,
    limit,
    skip
  );
  const minimalResult: GetUserBadgesResponse = await getUserBadges(tenantId);
}
example();

updateUserBadge

Parameters

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

Response

Returns: UpdateUserBadgeResponse

Example

updateUserBadge Example

Copy

async function applyBadge() {
    const tenantId: string = "acme-corp-tenant";
    const userId: string = "user-98765";
    const params: UpdateUserBadgeParams = {
        badgeId: "gold-contributor",
        // optional field example
        expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
    };
    const result: UpdateUserBadgeResponse = await updateUserBadge(tenantId, userId, params);
    console.log(result);
}
applyBadge();

getUserNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: GetUserNotificationCountResponse1

Example

getUserNotificationCount Example

Copy

async function demoGetUserNotificationCount() {
    const tenantId: string = "acme-corp-01";
    // Call with optional SSO token
    const countWithSSO: GetUserNotificationCountResponse1 = await getUserNotificationCount(
        tenantId,
        "sso-token-abc123"
    );
    // Call without SSO token
    const countWithoutSSO: GetUserNotificationCountResponse1 = await getUserNotificationCount(
        tenantId
    );
    console.log(countWithSSO, countWithoutSSO);
}

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: GetUserNotificationsResponse

Example

getUserNotifications Example

Copy

async function fetchUserNotifications() {
    const tenantId: string = "tenant_9f4b2c";
    const urlId: string = "post_1234";
    const pageSize: number = 25;
    const afterId: string = "notif_5678";
    const includeContext: boolean = true;
    const unreadOnly: boolean = false;
    const dmOnly: boolean = false;
    const includeTranslations: boolean = true;
    const notifications: GetUserNotificationsResponse = await getUserNotifications(
        tenantId,
        urlId,
        pageSize,
        afterId,
        includeContext,
        undefined,
        unreadOnly,
        dmOnly,
        undefined,
        includeTranslations,
        undefined,
        undefined
    );
    console.log(notifications);
}

resetUserNotificationCount

Parameters

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Response

Returns: ResetUserNotificationCountResponse

Example

resetUserNotificationCount Example

Copy

async function demoResetCount() {
  const tenantId: string = "acme-corp-tenant";
  const sso: string = "sso-user-9876";
  // Call with optional sso parameter
  const resultWithSso: ResetUserNotificationCountResponse = await resetUserNotificationCount(tenantId, sso);
  // Call without optional sso parameter
  const resultWithoutSso: ResetUserNotificationCountResponse = await resetUserNotificationCount(tenantId);
  console.log(resultWithSso, resultWithoutSso);
}

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: ResetUserNotificationsResponse1

Example

resetUserNotifications Example

Copy

(async () => {
  const tenantId: string = "tenant-001";
  const afterId: string = "notif-123";
  const afterCreatedAt: number = 1697049600; // example UNIX timestamp
  const unreadOnly: boolean = true;
  const dmOnly: boolean = false;
  const noDm: boolean = false;
  const sso: string = "sso-token-xyz";
  const result: ResetUserNotificationsResponse1 = await resetUserNotifications(
    tenantId,
    afterId,
    afterCreatedAt,
    unreadOnly,
    dmOnly,
    noDm,
    sso
  );
  console.log(result);
})();

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

const tenantId: string = "tenant_12345";
const notificationId: string = "notif_9876";
const commentId: string = "comment_abc123";
const optedInOrOut: UpdateUserNotificationCommentSubscriptionStatusOptedInOrOutEnum =
  UpdateUserNotificationCommentSubscriptionStatusOptedInOrOutEnum.OptIn;
const sso: string = "ssoTokenXYZ";
const responseWithSso: UpdateUserNotificationCommentSubscriptionStatusResponse =
  await updateUserNotificationCommentSubscriptionStatus(
    tenantId,
    notificationId,
    optedInOrOut,
    commentId,
    sso
  );
const responseWithoutSso: 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 () => {
  const tenantId: string = "tenant-2024";
  const urlId: string = "page-5678";
  const url: string = "https://example.com/articles/typescript-tips";
  const pageTitle: string = "Top TypeScript Tips";
  const subscribedOrUnsubscribed: UpdateUserNotificationPageSubscriptionStatusSubscribedOrUnsubscribedEnum =
    UpdateUserNotificationPageSubscriptionStatusSubscribedOrUnsubscribedEnum.Subscribed;
  const sso: string = "sso-token-xyz";
  const resultWithSso: UpdateUserNotificationPageSubscriptionStatusResponse = await updateUserNotificationPageSubscriptionStatus(
    tenantId,
    urlId,
    url,
    pageTitle,
    subscribedOrUnsubscribed,
    sso
  );
  const resultWithoutSso: UpdateUserNotificationPageSubscriptionStatusResponse = await updateUserNotificationPageSubscriptionStatus(
    tenantId,
    urlId,
    url,
    pageTitle,
    subscribedOrUnsubscribed
  );
})();

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 = "acme-corp";
const notificationId: string = "notif-20231101-001";
const newStatus: UpdateUserNotificationStatusNewStatusEnum = UpdateUserNotificationStatusNewStatusEnum.Dismissed;
const ssoToken: string = "sso-9f8e7d6c5b4a";
const result: UpdateUserNotificationStatusResponse = await updateUserNotificationStatus(
  tenantId,
  notificationId,
  newStatus,
  ssoToken
);

getUserPresenceStatuses

Parameters

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

Response

Returns: GetUserPresenceStatusesResponse1

Example

getUserPresenceStatuses Example

Copy

async function fetchUserPresences() {
  const tenantId: string = "tenant_9f8e2d";
  const urlIdWS: string = "blog.mycompany.com/thread/12345";
  const userIds: string = "alice,bob,carol";
  const result: GetUserPresenceStatusesResponse1 = await getUserPresenceStatuses(
    tenantId,
    urlIdWS,
    userIds
  );
  console.log(result);
}

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: SearchUsersResponse1

Example

searchUsers Example

Copy

async function demoSearch(): Promise<void> {
    const tenantId: string = "tenant_12345";
    const urlId: string = "article-9876";
    const usernameStartsWith: string = "john";
    const mentionGroupIds: string[] = ["groupA", "groupB"];
    const sso: string = "sso_abc123";
    const searchSection: SearchUsersSearchSectionEnum = SearchUsersSearchSectionEnum.Users;
    const response: SearchUsersResponse1 = await searchUsers(
        tenantId,
        urlId,
        usernameStartsWith,
        mentionGroupIds,
        sso,
        searchSection
    );
    console.log(response);
}
demoSearch();

getUser

Parameters

Name	Type	Required	Description
tenantId	string	Yes
id	string	Yes

Response

Returns: GetUserResponse1

Example

getUser Example

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const userId: string = "user_98765";
  const result: GetUserResponse1 = await getUser(tenantId, userId);
})();

createVote

Parameters

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

Response

Returns: CreateVoteResponse

Example

createVote Example

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "comment_987654";
const direction: CreateVoteDirectionEnum = CreateVoteDirectionEnum.Upvote;
const userId: string = "user_7f9a2b";
const voteResult: CreateVoteResponse = await createVote(
  tenantId,
  commentId,
  direction,
  userId
);

deleteVote

Parameters

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

Response

Returns: DeleteVoteResponse

Example

deleteVote Example

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const commentId: string = "comment-9876";
  const editKey: string = "edit-key-123";
  const resultWithEdit: DeleteVoteResponse = await deleteVote(tenantId, commentId, editKey);
  const resultWithoutEdit: DeleteVoteResponse = await deleteVote(tenantId, commentId);
})();

getVotes

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Response

Returns: GetVotesResponse1

Example

getVotes Example

Copy

async function fetchVotes(): Promise<void> {
  const tenantId: string = "acme-corp-01";
  const urlId: string = "article-2024-05-15";
  const response: GetVotesResponse1 = await getVotes(tenantId, urlId);
  // Example of accessing an optional field in the response
  const firstVoteId: string | undefined = response?.votes?.[0]?.id;
}

getVotesForUser

Parameters

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

Response

Returns: GetVotesForUserResponse1

Example

getVotesForUser Example

Copy

async function demo() {
  const tenantId: string = "acme-corp";
  const urlId: string = "post-9f8b7c";
  const userId: string = "user-42";
  const anonUserId: string = "anon-123";
  const votesRequiredOnly: GetVotesForUserResponse1 = await getVotesForUser(tenantId, urlId);
  const votesWithUserId: GetVotesForUserResponse1 = await getVotesForUser(tenantId, urlId, userId);
  const votesWithAnonId: GetVotesForUserResponse1 = await getVotesForUser(tenantId, urlId, undefined, anonUserId);
}
demo();

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

Getting Started

API Reference

Documentation

Usage

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

Moderation

Moderators

Notification Count

Notifications

Page Reacts

Pages

Pending Webhook Events

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

FastComments JavaScript/TypeScript SDK

Repository

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

Broadcast IDs

Error Handling

aggregate

Parameters

Response

Example