Replyke gives developers a complete foundation for building social experiences - comments, votes, notifications, feeds, and more - without reinventing the wheel. Instead of wiring together a mix of libraries or building from scratch, Replyke offers drop-in APIs, SDKs, and components that are production-ready out of the box.

Built with a headless, TypeScript-first architecture, Replyke fits seamlessly into your stack. Whether you’re building a full social network or just need user comments on a blog post - Replyke has you covered.

• Key Features
• Why Replyke
• Approach and Structure
• Moderation
• Quick Start
• Comparison With Alternatives
• Documentation
• Contributing
• Community and Support
• License

• Comment system - threaded replies, mentions, votes, customizable UI-elements, built-in moderation
• Feeds - filter entities by tags, content, custom metadata, follow relationships, timeframe or geography and sort by hot, top or controversial.
• In‑app notifications - auto-generated in-app notification for pre-defined events such as votes, mentions, follows and more. Configurable webhooks for further action, such as sending push-notifications.
• Curated lists - user generated collections and nested sub-collections of entities.
• Follow graph - one‑way follow relationships ready for social graphs.
• Authentication - easy user authentication with Replyke, or integration with an external user system.
• Admin tools - reporting, content moderation and user management.

All features come with backend APIs, typed SDKs and ready to use React and React Native components.

• Save months of work - plug in battle‑tested social primitives instead of reinventing them
• Headless first - bring your own auth and UI or use the included components
• Full TypeScript stack - the same types flow from database to client hooks
• Self host (DIY) or cloud - open‑source core plus an optional managed service for zero ops

Replyke wasn’t built in a traditional API-first way, but it is definitely API-centric. From the beginning, it was designed so that everything is powered by a clean, consistent API. This approach has shaped the way developers use Replyke today, and it’s what makes the system flexible and extensible.

You can think of Replyke as having three core layers:

The base layer of Replyke is its API. Everything the system can do, you can do through the API-whether it’s posting a comment, reporting content, creating a new entity, or updating a user profile. As long as you’re authenticated for routes that require authentication, all functionality is accessible. The API is fully documented in Replyke’s docs and can be used directly if you prefer working closer to the metal.

On top of the API, Replyke provides official libraries to simplify development. Currently, there are React and React Native libraries (supporting both CLI and Expo), with Node.js and vanilla JS SDKs coming soon for both server and client environments.

These libraries handle communication with the API and offer helpful abstractions for things like authentication, request state, pagination, and cache. For example, hooks like useEntityList make it easy to fetch entities with filters, sorting, and pagination-without writing any boilerplate yourself.

At the highest level, Replyke also offers prebuilt components that are fully wired up and ready to drop into your app. Components like SocialCommentSection use the underlying libraries and hooks to provide a complete UI and logic layer for features like commenting, voting, replying, and more. These are ideal for developers who want to move fast and not reinvent the wheel.

Combined, these three layers give developers everything they need to integrate Replyke fully: from low-level API access to high-level components ready to ship.

One more critical part of the system is the Replyke Dashboard. While the three core layers handle the client experience, the dashboard is for product owners and moderators.

Through it, you can:

• Monitor all content created across your app
• Handle reports from users
• Remove inappropriate content
• Suspend or ban users

This separation ensures developers get the flexibility they want, while still giving teams the control and oversight they need to keep communities healthy and productive.

This is a minimal example for integrating comments using Replyke. It’s meant as a basic demonstration with dummy content. Replyke offers much more - but this is the simplest way to get started.

To use this example:

1. Create a new project in the Replyke dashboard and copy your project ID.
2. Go to Settings → Secrets, and generate a new JWT key. This is required for signing JWT tokens of your users data, when integrating Replyke with an external user system as we will mock in this example.
3. Install the required packages:

pnpm add @replyke/comments-social-react-js @replyke/react-js

⚠️ This example uses a helper function that signs a JWT with the user’s info using a your project's secret key. It is meant only for development and testing. Never expose private keys in production, and if using the function - rotate your keys before moving to production.

Here’s how your app might look in a Vite + Tailwind project:

import { SocialCommentSection } from "@replyke/comments-social-react-js";
import {
  EntityProvider,
  ReplykeProvider,
  useSignTestingJwt,
} from "@replyke/react-js";
import { useEffect, useState } from "react";

const PROJECT_ID = import.meta.env.VITE_PUBLIC_REPLYKE_PROJECT_ID;
const PRIVATE_KEY = import.meta.env.VITE_PUBLIC_REPLYKE_SECRET_KEY;

const DUMMY_USER = { id: "user1", username: "lionel_messi10" };
const DUMMY_POST = {
  id: "post_1234",
  title: "Replyke Demo",
  content: "Adding comment sections has never been so easy!",
};

function SingleItem({
  post,
}: {
  post: {
    id: string;
    title: string;
    content: string;
  };
}) {
  return (
    <div className="h-screen p-24">
      <div className="w-full max-w-4xl h-full rounded-2xl shadow-2xl overflow-hidden flex flex-col">
        <div className="p-6 border-b border-gray-200">
          <h3 className="font-semibold text-lg">{post.title}</h3>
          <p>{post.content}</p>
        </div>
        <div className="relative flex-1 flex flex-col pt-4">
          <SocialCommentSection />
        </div>
      </div>
    </div>
  );
}

function App() {
  const signTestingJwt = useSignTestingJwt();

  const [signedToken, setSignedToken] = useState<string>();

  useEffect(() => {
    const handleSignJwt = async () => {
      const token = await signTestingJwt({
        projectId: PROJECT_ID,
        privateKey: PRIVATE_KEY,
        payload: DUMMY_USER,
      });
      setSignedToken(token);
    };

    handleSignJwt();
  }, []);

  return (
    <ReplykeProvider projectId={PROJECT_ID} signedToken={signedToken}>
      <EntityProvider foreignId={DUMMY_POST.id} createIfNotFound>
        <SingleItem post={DUMMY_POST} />
      </EntityProvider>
    </ReplykeProvider>
  );
}

export default App;

Full API reference, guides and recipes live at https://docs.replyke.com.

Bug reports are welcome. contributing guide coming soon - Join Discord server for updates.

• Discord - https://discord.gg/REKxnCJzPz

• Blog - https://blog.replyke.com

• X/Twitter

  • Replyke - https://x.com/yantsab
  • Yanay (Developer) - https://x.com/yantsab

• LinkedIn

  • Replyke - https://www.linkedin.com/company/replyke
  • Yanay (Developer) - https://www.linkedin.com/in/yanay-zabary/

• Email - [email protected]

Replyke is released under the AGPL‑3.0‑only license. See LICENSE for details.