面向实时讨论的评论 API 与 SDK

从任意技术栈调用 API

提供 cURL 以及面向 Node、Python、PHP、Ruby、Go、Java、Rust、Swift 和 C++ 的类型化 SDK。200 多个端点涵盖评论、投票、页面、SSO 用户、动态流帖子、审核和通知，全部由单个 API 密钥统一管理。

安装npm install fastcomments-sdk

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

const sdk = createFastCommentsSDK({
  apiKey: 'your-api-key',               // server-side only
  basePath: 'https://fastcomments.com'  // optional (default)
});

// Fetch comments for a page
const { comments } = await sdk.publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

// Post a comment
await sdk.publicApi.createCommentPublic({
  tenantId: 'your-tenant-id',
  broadcastId: crypto.randomUUID(),
  createComment: {
    urlId: 'page-url-id',
    url: 'https://example.com/post',
    comment: 'Hello from the API!',
    commenterName: 'Alice'
  }
});

# Fetch comments for a page
curl -s 'https://fastcomments.com/api/v1/comments?tenantId=your-tenant-id&urlId=page-url-id' \
  -H 'x-api-key: YOUR_API_KEY'

安装pip install fastcomments

import client
from client.api.public_api import GetCommentsPublicOptions

configuration = client.Configuration(host="https://fastcomments.com")
with client.ApiClient(configuration) as api_client:
    api = client.PublicApi(api_client)
    response = api.get_comments_public(
        "your-tenant-id",
        "page-url-id",
        GetCommentsPublicOptions(page=0, limit=30),
    )
    for comment in response.comments:
        print(comment.commenter_name, comment.comment)

安装composer require fastcomments/fastcomments-php

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api = new FastComments\Client\Api\PublicApi(new GuzzleHttp\Client());

$result = $api->getCommentsPublic('your-tenant-id', 'page-url-id', [
    'page'  => 0,
    'limit' => 30,
]);

foreach ($result->getComments() as $comment) {
    echo $comment->getCommenterName() . ': ' . $comment->getComment() . PHP_EOL;
}

安装gem install fastcomments

require 'fastcomments-client'

api = FastCommentsClient::PublicApi.new
result = api.get_comments_public('your-tenant-id', 'page-url-id', { page: 0, limit: 30 })

result.comments.each do |comment|
  puts "#{comment.commenter_name}: #{comment.comment}"
end

安装go get github.com/fastcomments/fastcomments-go

package main

import (
	"context"
	"fmt"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)

func main() {
	client := openapiclient.NewAPIClient(openapiclient.NewConfiguration())

	resp, _, err := client.PublicAPI.
		GetCommentsPublic(context.Background(), "your-tenant-id").
		UrlId("page-url-id").Page(0).Limit(30).Execute()
	if err != nil {
		panic(err)
	}
	for _, c := range resp.Comments {
		fmt.Printf("%s: %s\n", c.GetCommenterName(), c.GetComment())
	}
}

import com.fastcomments.invoker.ApiClient;
import com.fastcomments.invoker.Configuration;
import com.fastcomments.api.PublicApi;

ApiClient client = Configuration.getDefaultApiClient();
client.setBasePath("https://fastcomments.com");

PublicApi api = new PublicApi(client);
var result = api.getCommentsPublic("your-tenant-id", "page-url-id")
                .page(0)
                .limit(30)
                .execute();
System.out.println(result.getComments());

use fastcomments_sdk::client::apis::configuration::Configuration;
use fastcomments_sdk::client::apis::public_api::{get_comments_public, GetCommentsPublicParams};

let config = Configuration::new();
let params = GetCommentsPublicParams {
    tenant_id: "your-tenant-id".to_string(),
    url_id: "page-url-id".to_string(),
    page: Some(0),
    limit: Some(30),
    ..Default::default()
};
let result = get_comments_public(&config, params).await.unwrap();
for comment in result.comments {
    println!("{:?}: {:?}", comment.commenter_name, comment.comment);
}

import FastCommentsSwift

var options = PublicAPI.GetCommentsPublicOptions()
options.page = 0
options.limit = 30

let result = try await PublicAPI.getCommentsPublic(
    tenantId: "your-tenant-id",
    urlId: "page-url-id",
    options: options
)
print(result.comments ?? [])

#include "FastCommentsClient/api/PublicApi.h"
#include "FastCommentsClient/ApiClient.h"
#include "FastCommentsClient/ApiConfiguration.h"

using namespace org::openapitools::client::api;

auto config = std::make_shared<ApiConfiguration>();
config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

PublicApi publicApi(std::make_shared<ApiClient>(config));

auto resp = publicApi.getCommentsPublic(
    utility::conversions::to_string_t("your-tenant-id"),
    utility::conversions::to_string_t("page-url-id")
).get();

订阅实时动态流

建立一条连接，即可在每一条新评论、编辑、投票和在线状态更新发生的瞬间收到通知。不会遗漏任何事件：重新连接时会重新拉取 event log，回放客户端离线期间发送的所有内容。原生 WebSocket 订阅器适用于 Node、React Native、Java、Swift 和 C++。其他所有语言均可通过轮询 event log 保持实时。

安装npm install fastcomments-sdk

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

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

const subscription = subscribeToChanges(
  config,
  'your-tenant-id',   // tenantIdWS
  'page-url-id',      // urlIdWS
  'user-session-id',  // userIdWS (from the getComments response)
  (event) => {
    if (event.type === LiveEventType.new_comment) {
      console.log('New comment:', event.comment?.comment);
    }
    return true;      // event handled
  },
  (isConnected) => console.log(isConnected ? 'connected' : 'disconnected')
);

// later: subscription.close();

安装npm install fastcomments-react-native-sdk

import React, { useState } from 'react';
import { FastCommentsLiveCommenting } from 'fastcomments-react-native-sdk';
import { FastCommentsCommentWidgetConfig } from 'fastcomments-typescript';

export default function Comments() {
  // <FastCommentsLiveCommenting> subscribes to the live feed automatically.
  const [config] = useState<FastCommentsCommentWidgetConfig>({
    tenantId: 'your-tenant-id',
    urlId: 'page-url-id',
    showLiveRightAway: true,
    countAll: true,
  });

  return <FastCommentsLiveCommenting config={config} />;
}

import com.fastcomments.pubsub.LiveEventSubscriber;
import com.fastcomments.pubsub.SubscribeToChangesResult;
import com.fastcomments.core.CommentWidgetConfig;
import com.fastcomments.model.LiveEventType;

CommentWidgetConfig config = new CommentWidgetConfig();
config.tenant = "your-tenant-id";
config.urlId = "page-url-id";

LiveEventSubscriber subscriber = new LiveEventSubscriber();
SubscribeToChangesResult result = subscriber.subscribeToChanges(
    config,
    "your-tenant-id",   // tenantIdWS
    "page-url-id",      // urlId
    "page-url-id",      // urlIdWS
    "my-presence-id",   // userIdWS
    null,               // canSeeCommentsCallback (optional)
    (event) -> {
        if (event.getType() == LiveEventType.NEW_COMMENT) {
            System.out.println("New comment: " + event.getComment().getId());
        }
    }
);
// later: result.close();

import FastCommentsSwift

let config = LiveEventConfig(
    tenantId: "your-tenant-id",
    urlId: "page-url-id",
    urlIdWS: "page-url-id",   // URL-safe id for the WS server
    userIdWS: "my-presence-id"
)

let subscriber = LiveEventSubscriber()
let result = subscriber.subscribeToChanges(config: config) { event in
    if event.type == .newComment, let comment = event.comment {
        print("New comment: \(comment.id ?? "")")
    }
}
// later: result?.close()

#include <fastcomments/live/live_stream.hpp>
#include <iostream>

using namespace fastcomments::live;

LiveStreamConfig cfg;
cfg.wsBaseUrl = "wss://fastcomments.com";   // no trailing slash

LiveStream stream(cfg);
stream.onEvent([](const LiveEvent& ev) {
    if (ev.type == EventType::NewComment) {
        std::cout << "New comment at " << ev.timestamp << std::endl;
    }
});

stream.subscribe("your-tenant-id", "page-url-id", "my-presence-id").wait();
// later: stream.close().wait();

安装pip install fastcomments

import time
import client

configuration = client.Configuration(host="https://fastcomments.com")
with client.ApiClient(configuration) as api_client:
    api = client.PublicApi(api_client)
    start_time = int(time.time() * 1000)  # ms epoch
    while True:
        result = api.get_event_log(
            "your-tenant-id", "page-url-id", "my-user-id", start_time
        )
        for event in result.events:
            print("event:", event.data)
            start_time = int(event.created_at.timestamp() * 1000) + 1
        time.sleep(2)

# startTime = epoch millis to replay from; advance it past the last event you saw
curl -s 'https://fastcomments.com/api/v1/event-log/your-tenant-id?urlId=page-url-id&userIdWS=my-user-id&startTime=1720560000000' \
  -H 'x-api-key: YOUR_API_KEY'