Skip to content

Convex Reference

Precis

Thinklio runs on Convex as its single reactive backend for all application logic and data. This document is the canonical reference for what Convex gives us and what's available in the Convex component ecosystem, consolidated from the April 2026 capability statement and the April 2026 component directory.

Convex is a reactive backend platform written primarily in Rust, with TypeScript as the developer-facing language for server functions. Its core innovation is a reactive database engine: queries track their data dependencies automatically, and when any dependency changes, every client subscription updates. This eliminates traditional caching, polling, and pub/sub patterns. For Thinklio, this replaces what would otherwise be a Redis Streams event bus for client-facing updates, a multi-tier caching strategy, and a dedicated response delivery pipeline for web and mobile channels.

The platform provides a document-relational database with ACID transactions (serializable isolation via optimistic MVCC), server-side functions (queries, mutations, actions, HTTP actions, and internal variants), file storage, scheduling (cron and one-off), full-text search, native vector search up to 4096 dimensions, HTTP endpoints, authentication integration via Clerk (first-class), Auth0, custom OIDC, or Convex Auth, and a rich component ecosystem. All server functions are written in TypeScript and deployed to Convex's managed infrastructure; the backend is also open source and self-hostable via Docker Compose for enterprise data-residency scenarios.

The component ecosystem is a major part of what makes Convex a good fit for Thinklio. Components are self-contained, installable packages with their own tables, functions, and logic. They run in isolation (their data stays in dedicated tables that don't pollute your application schema) but integrate with your application via typed APIs. The most relevant to Thinklio are the Agent component (thread and message management, LLM orchestration, tool calls, multi-agent workflows), the RAG component (semantic search with namespaces, importance weighting, chunk context), the Workflow component (durable long-running functions with step journalling), the Workpool component (parallelism control, priority queues, retries), the Rate Limiter component (token bucket and fixed window, transactional, sharded for high throughput), the Persistent Text Streaming component (for LLM output streaming while persisting to the database), the Migrations component (long-running data migrations on live data), the Aggregate component (denormalised sums and counts at scale), the Crons component (runtime-registered cron jobs), and the R2 component (Cloudflare R2 integration for file storage).

Beyond the platform and components, the convex-helpers npm package provides production-grade utilities that fill gaps: custom functions for middleware (how we implement assertAccountAccess for tenant isolation), row-level security helpers, relationship helpers, CRUD generators, Zod validation, Hono integration for HTTP endpoints, database triggers (for auto-embedding generation and cost event emission), sessions, presence, throttling, and TypeScript/OpenAPI generators.

Design patterns: use indexes aggressively (explicit withIndex() in every frequent query), keep queries deterministic (no Date.now() or Math.random() in queries, use boolean flags updated by scheduled mutations for time-based filtering), use .collect() only on small result sets, prefer mutations over actions for database work, use internal functions for server-internal logic, implement access control as custom-function wrappers, and use the component ecosystem rather than building what already exists. Anti-patterns to avoid: browser storage APIs in artifacts, large read sets in mutations (OCC conflict probability rises), external API calls from queries/mutations (actions only), and percentage-based table widths in generated document content.

Pricing (April 2026): Starter (free) covers 1M function calls per month, 0.5 GB database, 1 GB file storage, 16 query/mutation concurrency. Pro at $25/month covers 25M function calls, 50 GB database, 50 GB files, 128 query/mutation concurrency, plus log streaming, exception reporting, streaming export via Fivetran, and automatic backups. Overages priced per unit. Enterprise plan in development. Startup programme offers up to 1 year free Pro plus 30% off usage fees up to $30k.

Platform guarantees: 99.99% availability target for cloud, SOC 2 Type II compliant, HIPAA compliant, GDPR verified, Convex 1.0 API stability. Key limits: document size 1 MB, function execution 1s for queries/mutations and 10min for actions, 8 MB argument and return values, 32 indexes per table with 16 fields each, vector dimensions up to 4096, vector search results up to 256 per query.

This reference is the companion to the Architecture doc for Convex-specific detail. For the how-and-why of our service topology and migration path, see 02-system-architecture.md. For tenant isolation and data model patterns, see 04-data-model.md.

Table of contents

Part A: Platform capabilities

1. Platform overview

Convex is a reactive backend platform written primarily in Rust, with TypeScript as the developer-facing language for server functions. Its core innovation is a reactive database engine: queries track their data dependencies automatically, and when any dependency changes, the query re-runs and every client subscription updates. This eliminates traditional caching, polling, and pub/sub patterns.

The platform provides: a document-relational database with ACID transactions, server-side functions (queries, mutations, actions), file storage, scheduling (cron and one-off), full-text search, vector search, HTTP endpoints, authentication integration, and a component ecosystem.

All server functions are written in TypeScript and deployed to Convex's infrastructure. The backend is open source and self-hostable.

2. Core database

Data model

Convex uses a document-relational model. Documents are JSON-like nested objects stored in tables. Tables can have relations via typed document IDs. Schemas are defined in TypeScript and provide end-to-end type safety from database through to client.

// convex/schema.ts
import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";

export default defineSchema({
  messages: defineTable({
    channel: v.id("channels"),
    body: v.string(),
    user: v.id("users"),
  }).index("by_channel", ["channel"]),
});

Schema validation is opt-in. You can start without a schema and add one later. The Doc<"tableName"> type provides compile-time type safety for documents.

Transactions and consistency

Convex provides serializable isolation via optimistic multi-version concurrency control (OCC/MVCC). Every mutation runs as an atomic transaction. At commit time, the system checks that every record in the read set is still at the version that was read. If a concurrent transaction modified any of those records, the transaction retries automatically.

This gives the strongest ACID guarantees available: immediate consistency, serializable isolation, and automatic conflict resolution. There is no eventual consistency, no dirty reads, and no lost updates.

For Thinklio: This means thread message writes, knowledge fact updates, and step state changes are all atomic and consistent. No need for application-level locking or retry logic for data races.

Indexes

Indexes are defined in the schema. Up to 32 indexes per table, each containing up to 16 fields. Indexes must be used explicitly in queries via withIndex(), which eliminates query planner surprises. _creationTime is automatically appended to every index for stable ordering.

Staged indexes allow you to create indexes on large tables without blocking writes. The index backfills in the background, and you enable it once complete.

Queries and mutations

Queries are read-only functions that access the database. They are deterministic, cached, and reactive. When any data a query depends on changes, the query re-runs automatically for all subscribers. Queries run in a deterministic V8 runtime (no Date.now(), no Math.random(), no network access).

Mutations are read-write functions that modify the database. They run transactionally. All database changes are queued during execution and committed atomically when the function returns. Mutations also run in the deterministic V8 runtime.

Actions are functions that can have side effects: calling external APIs, using non-deterministic functions, accessing file storage. They run in either the optimised V8 runtime or a full Node.js runtime. Actions cannot directly read or write the database but can call queries and mutations via ctx.runQuery() and ctx.runMutation().

For Thinklio: Agent tool calls that access external APIs (HubSpot, Google Calendar, LLM providers) run as actions. Knowledge retrieval and thread management run as queries and mutations for full reactivity.

Pagination

Convex provides cursor-based pagination via paginate() on database queries. The client receives a cursor and page of results; subsequent pages use the cursor. Paginated queries are reactive: if data in the current page changes, the subscription updates.

3. Reactivity and real-time

How it works

Every Convex query function is tracked by the reactive engine. The engine knows exactly which database rows, index ranges, and other data a query touched. When any of those dependencies change (via a mutation), the query is scheduled for re-evaluation. If the result differs from the cached result, all subscribed clients receive the update via WebSocket.

Clients subscribe to queries using hooks like useQuery() in React. The subscription is maintained over a persistent WebSocket connection. Multiple subscriptions share the same connection.

Consistency guarantees

All client subscriptions on a single connection see a consistent snapshot. If two queries depend on related data, they both update atomically from the client's perspective. This prevents UI inconsistencies where one component shows stale data while another shows fresh data.

Performance characteristics

Reactivity is selective: only queries whose dependencies changed are re-evaluated. This is far more efficient than polling or blanket subscription models. The reactive engine is implemented in Rust for performance.

For Thinklio: This replaces the entire Redis Streams event bus for client-facing updates, the multi-tier caching strategy, and the Gateway's response delivery pipeline for web and mobile channels.

4. Server functions

Function types

Type Database access Side effects Runtime Reactive
Query Read-only None Deterministic V8 Yes
Mutation Read-write None (except db) Deterministic V8 No (triggers reactivity)
Action Via ctx.runQuery/runMutation Full (HTTP, file I/O, etc.) V8 or Node.js No
HTTP Action Via ctx.runQuery/runMutation Full V8 or Node.js No
Internal Function Same as above Same as above Same as above Same

Internal functions

Functions prefixed with internalQuery, internalMutation, internalAction can only be called by other Convex functions, not by clients. This is the mechanism for server-internal logic: scheduled jobs, workflow steps, background processing.

For Thinklio: Policy check callbacks, cost recording mutations, and agent workflow steps should all be internal functions.

HTTP actions

Convex supports defining HTTP endpoints directly, with full control over request and response handling. These can serve as webhook receivers, API endpoints, or integration points with external services.

import { httpRouter } from "convex/server";
const http = httpRouter();
http.route({
  path: "/webhook/telegram",
  method: "POST",
  handler: httpAction(async (ctx, request) => {
    const body = await request.json();
    await ctx.runMutation(internal.messages.handleInbound, { body });
    return new Response("OK", { status: 200 });
  }),
});

For Thinklio: HTTP actions receive webhook callbacks from external tools, accept inbound messages from legacy clients during migration, and expose endpoints for any external service that needs to query Convex state.

Error handling

Convex distinguishes between application errors (expected failures that should be reported to the user) and system errors (unexpected failures that should be retried). Application errors use ConvexError and are delivered to the client. System errors trigger automatic retries in workflows.

Full-text search

Convex provides built-in full-text search over document fields. Search indexes are defined in the schema:

messages: defineTable({
  body: v.string(),
  channel: v.id("channels"),
}).searchIndex("search_body", {
  searchField: "body",
  filterFields: ["channel"],
})

Search queries combine text relevance with filter conditions. Results are ordered by relevance score.

Native vector search for semantic similarity. Vector indexes are defined in the schema with configurable dimensions (up to 4096):

documents: defineTable({
  text: v.string(),
  embedding: v.array(v.float64()),
}).vectorIndex("by_embedding", {
  vectorField: "embedding",
  dimensions: 1536,
  filterFields: ["category"],
})

The vectorSearch API returns up to 256 results per query, ordered by cosine similarity. Filter expressions can restrict results by indexed fields.

Limits: 256 results per query. Vector dimensions up to 4096. Filter fields must be declared in the index definition.

For Thinklio: Replaces pgvector for knowledge retrieval. The RAG component builds on this with namespacing, importance weighting, and chunk context.

6. File storage

Convex includes built-in file storage for any file type. Files are uploaded via a two-step process: get an upload URL, upload the file, receive a storage ID. Files can also be stored from actions (for example, after generating an image or fetching from a third-party API).

Files are served via generated URLs with configurable access control. Storage IDs are typed and can be referenced from documents.

For Thinklio: Can be used for document uploads within the agent plane (conversation attachments, generated files). The existing Cloudflare R2 integration can coexist for bulk object storage.

7. Scheduling

Scheduled functions

Any function can be scheduled to run in the future:

await ctx.scheduler.runAfter(60000, internal.tasks.cleanup, { taskId });

Scheduling is transactional: if the mutation that schedules a function rolls back, the scheduled function is also cancelled.

Cron jobs

Static cron jobs are defined in convex/crons.ts:

const crons = cronJobs();
crons.interval("clear old sessions", { hours: 24 }, internal.sessions.cleanup);

The Crons component extends this with runtime-registered cron jobs, allowing agents to schedule their own recurring work dynamically.

8. Authentication

Supported providers

Convex integrates with external identity providers:

  • Clerk: first-class integration (Thinklio default)
  • Auth0: first-class integration
  • Custom OIDC: any provider supporting OpenID Connect (Keycloak, Okta, etc.)
  • Custom JWT: for providers that don't support full OIDC
  • Convex Auth: native auth library supporting OAuth, magic links, passwords

Clerk integration (Thinklio default)

Clerk is the chosen identity provider for Thinklio. Clerk organisations map to Thinklio accounts; roles and permissions are enforced in Convex middleware. See 12-developer-guide.md for the Convex + Clerk setup guide.

Custom OIDC integration

Configuration requires the OIDC issuer domain and application ID:

// convex/auth.config.ts
export default {
  providers: [{
    domain: "https://issuer.example.com/realms/thinklio",
    applicationID: "thinklio-convex",
  }],
} satisfies AuthConfig;

The JWT's iss must match the domain and aud must match the applicationID. In functions, ctx.auth.getUserIdentity() returns the authenticated user's identity from the token.

9. The convex-helpers library

The convex-helpers npm package provides production-grade utilities that fill gaps in the core platform. Key capabilities follow.

Custom functions (middleware)

Wrap query, mutation, or action with custom logic that runs before or after every function call. This is the mechanism for authentication checks, logging, tenant isolation, and other cross-cutting concerns.

import { customQuery } from "convex-helpers/server/customFunctions";

const authenticatedQuery = customQuery(query, {
  args: {},
  input: async (ctx) => {
    const identity = await ctx.auth.getUserIdentity();
    if (!identity) throw new Error("Unauthenticated");
    return { ctx: { userId: identity.subject }, args: {} };
  },
});

For Thinklio: This is how you implement the assertAccountAccess() middleware for tenant isolation. Every query and mutation wraps with a custom function that validates account context.

Row-level security

Application-level RLS that checks access rules on every document read or write:

import { wrapDatabaseReader } from "convex-helpers/server/rowLevelSecurity";

const rules = {
  messages: {
    read: async (ctx, doc) => doc.accountId === ctx.accountId,
    write: async (ctx, doc) => doc.accountId === ctx.accountId,
  },
};

For Thinklio: This partially compensates for the loss of Postgres RLS. Rules are defined in code and enforced at the application layer, with per-table read and write policies.

Relationship helpers

Utilities for traversing document relationships:

import { getOneFrom, getManyFrom } from "convex-helpers/server/relationships";

const team = await getOneFrom(ctx.db, "teams", "by_id", teamId);
const members = await getManyFrom(ctx.db, "team_members", "by_team", teamId);

CRUD helpers

Generate standard CRUD operations for a table:

import { crud } from "convex-helpers/server/crud";

const { create, read, update, destroy } = crud(schema, "tasks");

Zod validation

Use Zod schemas for argument validation with full TypeScript inference:

import { zQuery } from "convex-helpers/server/zod";

export const getUser = zQuery({
  args: { userId: z.string().uuid() },
  handler: async (ctx, { userId }) => { /* ... */ },
});

Hono for HTTP endpoints

Use the Hono web framework for building HTTP APIs in Convex, with middleware, routing, and OpenAPI spec generation:

import { Hono } from "hono";
import { HonoWithConvex } from "convex-helpers/server/hono";

const app: HonoWithConvex = new Hono();
app.get("/api/agents", async (c) => { /* ... */ });

For Thinklio: Useful for the Convex-side HTTP API that external callers interact with.

Triggers

Database triggers that fire when documents are inserted, updated, or deleted:

const triggers = new Triggers();
triggers.register("knowledge_facts", async (ctx, change) => {
  if (change.operation === "insert") {
    await generateEmbedding(ctx, change.newDoc);
  }
});

For Thinklio: Useful for automatically generating embeddings when knowledge facts are created, sending cost events to downstream systems when steps complete, and invalidating cached policy decisions.

Additional utilities

  • Manual pagination: for cases where Convex's built-in pagination doesn't fit
  • Filter: filter database query results with JavaScript expressions
  • Query caching: client-side ConvexQueryCacheProvider for reducing re-renders
  • Sessions: client-generated or server-backed session management
  • Presence: real-time user presence (who's online, typing indicators)
  • Throttling: single-flighting to prevent duplicate concurrent operations
  • TypeScript API Generator: generate typed client SDKs
  • OpenAPI Spec Generator: generate OpenAPI specs from Convex functions
  • CORS: CORS configuration for HTTP endpoints
  • Standard Schema support: integration with Standard Schema validators

10. Component ecosystem (summary)

Components are self-contained, installable packages with their own tables, functions, and logic. They run in isolation (their data is separate from your main database) but integrate with your application via typed APIs. The full directory with package-level detail is in Part B of this document.

First-party components (by get-convex)

AI and agent
Component Weekly downloads Purpose
Agent 34k Thread and message management, LLM orchestration, tool calls, vector+text search, streaming, multi-agent workflows
RAG 19k Semantic search with namespaces, importance weighting, chunk context, custom filtering, graceful migrations
Persistent Text Streaming 14k Stream text (LLM output) over WebSocket while persisting to database
Durable execution
Component Weekly downloads Purpose
Workpool 84k Parallelism control, priority queues, retries with backoff and jitter, onComplete callbacks, reactive job status
Workflow 44k Durable long-running functions with step journalling, pause and resume, branching, loops, configurable retries
Action Retrier 27k Retry external API calls with exponential backoff
Crons 11k Runtime-registered cron jobs (dynamic scheduling)
Infrastructure
Component Weekly downloads Purpose
Rate Limiter 58k Token bucket and fixed window, transactional, sharded for high throughput, capacity reservation
Migrations 45k Long-running data migrations on live data
Aggregate 26k Denormalised sums and counts at scale
Sharded Counter 11k High-throughput increment and decrement
Geospatial 2k Point-in-region queries

Notable community components

Component Purpose
Convex Audit Log Track user actions, API calls, system events
convex-mq Typed message queue with visibility timeouts and retries
Webhook Sender Managed webhook delivery with HMAC signing, retries, rate limiting
LLM Cache Request and response caching with tiered TTL
Convex Debouncer Debounce expensive operations (LLM calls, metrics)
Cloudflare R2 Store and serve files in R2
Collaborative Text Editor Real-time collaborative editing (BlockNote and Tiptap)
Expo Push Notifications Mobile push notifications
Twilio SMS Send and receive SMS
LaunchDarkly Feature flag sync
Polar Subscription billing

Integration components

From the integrations page:

Integration Type Purpose
Axiom Log stream Historical logs, querying, dashboards, alerting
Datadog Log stream Monitoring, APM, dashboards
PostHog Log stream Product analytics, session replay
Custom Webhook Log stream Any destination via HTTP
Sentry Exception reporting Error tracking and alerting

11. Data streaming and export

Log streams (Pro plan)

Stream function execution logs, console.log output, audit logs, and performance metrics to external destinations in real time. Supported destinations: Axiom, Datadog, PostHog, custom webhook.

Log event schema includes topics: verification, console, function_execution, audit_log, concurrency_stats, scheduler_stats, current_storage_usage, storage_api_bandwidth.

For Thinklio: Stream function execution events to Axiom or Datadog for operational monitoring. Stream to a custom webhook for feeding into a custom analytics pipeline.

Streaming export (Pro plan, via Fivetran)

CDC (change data capture) export from Convex to any Fivetran-supported destination. Supported destinations include Snowflake, BigQuery, Databricks, PostgreSQL, and hundreds more.

Use cases: BI reporting, analytics warehousing, regulatory compliance archives, cross-system data synchronisation.

For Thinklio: Stream agent interaction data from Convex to a data warehouse for usage analytics, plan scoring analysis, and business intelligence. Stream to self-hosted Postgres for any audit trail that needs to live outside the reactive tier.

Streaming import (all plans, via Airbyte)

Import data from any Airbyte-supported source into Convex. Enables adopting Convex alongside existing databases without custom migration tooling.

Use cases: mirror existing Postgres tables into Convex for real-time features, import data from third-party SaaS tools.

Backup and restore

Manual and automatic backups via the dashboard. Backups are downloadable as ZIP files. Automatic backups available on Pro plan.

Snapshot import/export

CLI-based import from CSV or JSON. Programmatic snapshot export for data portability.

12. Self-hosted deployment

What you get

The self-hosted Convex backend runs the same open-source code as the cloud service. It includes the full runtime (reactive engine, database, function execution, file storage, search), the dashboard UI, and CLI compatibility.

Setup

Docker Compose is the recommended approach:

docker compose up

The backend generates admin keys for CLI and dashboard access. By default, data is stored in SQLite. You can point it to Postgres or MySQL for production workloads. File storage can use S3-compatible storage (including Cloudflare R2).

What's supported

Self-hosted Convex supports all free-tier features:

  • All function types (queries, mutations, actions, HTTP actions)
  • Full reactive engine
  • File storage
  • Text and vector search
  • Scheduling (cron and one-off)
  • Authentication (including custom OIDC)
  • Components
  • Dashboard UI

What's not supported (or limited)

  • Scaling is single-node by default. The Docker image runs all services on one machine. The cloud service distributes across many services that scale independently. If you need horizontal scaling, you must modify the Rust codebase to separate services.
  • No managed upgrades. You handle version upgrades and database migrations yourself.
  • No support plan. Community support via Discord only (the #self-hosted channel).
  • No log streaming, exception reporting, or advanced telemetry (these are cloud-only Pro features).
  • No automatic backups (you manage your own backup strategy).
  • Performance tuning is manual. The cloud service has Convex's engineering team optimising for scale. Self-hosted requires you to monitor, tune, and scale the Rust backend yourself.

Licensing

FSL Apache 2.0 (Fair Source License). You can do almost anything Apache-2.0 allows, except create a competing hosted product. All code converts to full Apache-2.0 two years after creation.

Pros for Thinklio

  • Enterprise data residency. Customers who require on-premise data storage can run Convex on their own infrastructure.
  • No vendor lock-in. If Convex Cloud becomes unsuitable, you can run the same code yourself.
  • Full control. Configure database backend (Postgres, MySQL, SQLite), storage backend (S3, local), and networking.
  • Bundled with your stack. Ship a Docker Compose with Convex, Clerk, and any supporting services as a complete on-premise package.

Cons for Thinklio

  • Single-node scaling. Enterprise customers with high throughput may outgrow a single node. Modifying the Rust backend for horizontal scaling is a significant engineering effort.
  • Operational burden. You own monitoring, backups, upgrades, and incident response for the Convex backend.
  • No log streaming. Self-hosted doesn't have the cloud's log streaming integrations. You'd need to build your own observability pipeline.
  • Upgrade path. Each backend version upgrade requires running migrations. The process is documented but not automated.

Recommendation for Thinklio

Use Convex Cloud (Ireland) for the primary deployment. Offer self-hosted as an enterprise add-on for customers with strict data residency requirements, with the understanding that it's a single-node deployment suitable for moderate throughput. For high-throughput enterprise customers, work with Convex on their enterprise plan or invest in scaling the open-source backend.

13. Pricing

Plans (as of April 2026)

Resource Starter (Free) Pro ($25/month)
Developers 1 to 6 Unlimited
Deployments 40 Unlimited
Function calls 1M/month 25M/month
Action compute 20 GB-hours/month 250 GB-hours/month
Database storage 0.5 GB 50 GB
Database bandwidth 1 GB/month 50 GB/month
File storage 1 GB 50 GB
File bandwidth 1 GB/month 50 GB/month
Vector storage 0.5 GB 25 GB
Vector bandwidth 0.5 GB/month 25 GB/month
Query/Mutation concurrency 16 128
Action concurrency 64 512
Log streaming No Yes
Exception reporting No Yes
Streaming export (Fivetran) No Yes
Automatic backups No Yes

Overage pricing on Pro: function calls $2/1M, action compute $0.30/GB-hour, database storage $0.20/GB/month, database bandwidth $0.20/GB, vector storage $0.55/GB/month, vector bandwidth $0.11/GB.

Enterprise plan

In development. Expected to include: advanced telemetry, compliance certifications, SSO, auditing, SLAs, and dedicated support.

Startup programme

Up to 1 year free of Pro, including no seat fees and 30% off usage-based fees up to $30k.

For Thinklio: The Pro plan at $25/month is the starting point. The primary cost drivers will be function calls (each agent turn involves multiple function calls) and action compute (LLM calls, external API calls). The 128 query/mutation concurrency on Pro should handle significant traffic.

14. Platform guarantees and limits

Availability

Target: 99.99% (four nines) for cloud deployments. Data is encrypted at rest, replicated across multiple physical availability zones. Backups stored with 99.999999999% (eleven nines) durability.

Compliance

SOC 2 Type II compliant. HIPAA compliant. GDPR verified.

Stability

Convex 1.0 API is stable. Code developed on 1.0 or later will continue to operate as-is. Breaking changes (if any) come with substantial advance notice and direct contact.

Key limits

  • Document size: 1 MB
  • Function execution time: Queries and mutations: 1 second. Actions: 10 minutes (cloud), configurable (self-hosted).
  • Arguments and return values: 8 MB
  • Indexes per table: 32
  • Fields per index: 16
  • Vector dimensions: Up to 4096
  • Vector search results: Up to 256 per query
  • Scheduled functions: Thousands concurrently
  • Transaction read and write set: Subject to OCC conflict limits; large read sets increase retry probability

Future features (announced)

  • Authorisation framework: built-in access control beyond authentication (currently manual)
  • Advanced telemetry: enhanced observability tools
  • More streaming export and import connectors

15. Getting the best out of Convex

Design patterns

Use indexes aggressively. Unlike SQL databases, Convex requires explicit index usage. Design your schema with your query patterns in mind. Every frequent query should have a supporting index.

Keep queries deterministic. Don't use Date.now() in queries. If you need time-based filtering, use a boolean flag updated by a scheduled mutation (for example, isExpired: true). This preserves cache efficiency.

Use .collect() only on small result sets. All collected documents count towards database bandwidth. For large tables, use indexes to narrow results before collecting. Use pagination for unbounded result sets.

Prefer mutations over actions for database work. Mutations are transactional and fast. Actions should be reserved for side effects (external API calls, file operations). Use ctx.runMutation() from actions for database writes.

Use internal functions for server-internal logic. Scheduled jobs, workflow steps, and background processing should use internalMutation or internalAction to prevent client-side invocation.

Implement access control in custom functions. Use the custom functions pattern from convex-helpers to create authenticatedQuery, authenticatedMutation, and accountScopedQuery wrappers that run access checks before every function.

Use the component ecosystem. Don't build what already exists. Workflow, Workpool, Rate Limiter, and RAG are mature, well-tested components with significant production usage (tens of thousands of weekly downloads).

Anti-patterns to avoid

Don't store browser state. localStorage and sessionStorage are not available in Convex functions. Use React state or Convex documents.

Don't hold large read sets in mutations. Large read sets increase the probability of OCC conflicts and retries. Break large operations into smaller batches using the Migrations component or scheduled functions.

Don't call external APIs from queries or mutations. Only actions can make network calls. If a query needs external data, cache it in a Convex document that's updated by a scheduled action.

Don't use percentage-based table widths in documents. This applies to generated document content (not Convex itself), but it's a common gotcha.

Observability strategy

  • Development: Dashboard logs, CLI log viewer, browser console
  • Production (Cloud): Log streams to Axiom, Datadog, or PostHog for historical logs, querying, dashboards, and alerting. Exception reporting to Sentry.
  • Production (Self-hosted): Build custom log aggregation. The dashboard provides basic log viewing. For production monitoring, instrument your application code and stream logs via custom webhook or direct integration.

16. Client libraries

Convex provides official client libraries for:

  • JavaScript/TypeScript (primary)
  • React (hooks: useQuery, useMutation, useAction, with optimistic updates)
  • Next.js (App Router and Pages Router support)
  • React Native
  • TanStack (Start and Router integration)
  • Vue
  • Svelte
  • Python
  • Rust
  • Swift (iOS)
  • Android Kotlin
  • OpenAPI (for any HTTP client)

Flutter and Dart clients

Several community packages are available on pub.dev:

  • convex_flutter (v1.2.0): the most complete option. Uses a Rust FFI core for native performance, with a pure Dart fallback for web. Provides real-time WebSocket subscriptions, authentication, lifecycle management, queries, mutations, and actions.
  • convex_dart: type-safe integration with automatic code generation via a companion CLI tool (convex_dart_cli) that wraps convex dev and regenerates Dart client code when Convex functions change.
  • flutter_convex: real-time subscriptions with optimistic updates.

These are community-maintained, not official Convex packages, but convex_flutter in particular is actively maintained and feature-complete.

For Thinklio:

  • Web app (Next.js 15): Use the Next.js client with React hooks for reactive agent thread subscriptions.
  • Mobile app (Flutter): Use convex_flutter for full reactive subscriptions over WebSocket, matching the web app experience. The Rust FFI core provides native performance on iOS and Android; the pure Dart implementation covers Flutter web. Evaluate convex_dart as an alternative if type-safe code generation is preferred.
  • External integrations: Use the HTTP API to call Convex functions from any language that lacks a native client. The Deployment API provides programmatic access for admin operations.

17. Capability summary

Capability Status Notes
Reactive database with ACID transactions Production Serializable isolation, OCC, automatic conflict resolution
Native vector search Production Up to 4096 dimensions, 256 results per query, filter expressions
Full-text search Production Built-in, index-based
Durable workflows with step journalling Production Via Workflow component
Agent orchestration with message history Production Via Agent component
RAG with namespaces and importance weighting Production Via RAG component
Real-time streaming over WebSocket Production Via Persistent Text Streaming + reactive queries
Rate limiting (token bucket, fixed window) Production Via Rate Limiter component
Parallelism control with retry and backoff Production Via Workpool component
Runtime cron jobs Production Via Crons component
Denormalised counters and aggregates Production Via Aggregate + Sharded Counter
Custom OIDC auth (Keycloak, Okta, etc.) Production Via auth.config.ts
Clerk auth (Thinklio default) Production First-class integration
Row-level security (application-layer) Production Via convex-helpers
Database triggers Production Via convex-helpers
HTTP endpoints Production Via HTTP actions or Hono
File storage Production Built-in
Streaming export to data warehouse Beta Via Fivetran (Pro plan)
Streaming import from external sources Beta Via Airbyte
Log streaming to Axiom, Datadog Production Pro plan
Self-hosted deployment Production Open source, Docker, single-node
Flutter and Dart client Community convex_flutter (Rust FFI + pure Dart), convex_dart (codegen), flutter_convex (optimistic updates)
Built-in authorisation framework Future Currently manual; planned feature

Part B: Component directory

This directory catalogues every component listed on convex.dev/components as of 2026-04-03. Components are community and first-party packages that plug into a Convex deployment via convex/convex.config.ts. The summary table below is the fastest way to scan what is available; the per-category sections that follow give the detail: purpose, install command, use cases, and links.

The categories in this directory are: AI, Authentication, Backend, Collaboration, Database, Durable Functions, Integrations, and Payments. Nano Banana appears in both AI and Backend but is counted once in the total of 75 components.

What are Convex components?

Convex Components are pre-built, composable modules that extend Convex backends with common functionality like authentication, payments, file storage, AI integration, and collaboration features. They solve cross-cutting concerns without requiring developers to build from scratch.

How they work

Components are distributed as npm packages and installed into your Convex project:

npm install @convex-dev/stripe

Each component: - Defines sandboxed tables: all component data lives in dedicated tables that don't pollute your application schema - Exposes TypeScript functions: queries, mutations, and actions you call from your Convex functions or client - Configured via convex/convex.config.ts: use the component by calling app.use() before deploying - Self-contained: components manage their own migrations, schemas, and lifecycle without manual DDL

Installation and configuration

All components follow the same installation pattern:

// convex/convex.config.ts
import { defineApp } from "convex/server";
import stripe from "@convex-dev/stripe";
import rag from "@convex-dev/rag";

const app = defineApp();
app.use(stripe);
app.use(rag);

export default app;

Component data is accessible via standard Convex queries and mutations. Refer to each component's documentation on convex.dev/components and the machine-readable llms.txt endpoint at https://www.convex.dev/components/{slug}/llms.txt for detailed APIs.

  • Directory: https://www.convex.dev/components
  • Components registry: https://www.convex.dev/components/components.md (machine-readable list)
  • Convex documentation: https://docs.convex.dev
  • Component guidelines: convex/_generated/ai/guidelines.md (read first when working with Convex)

Component summary table

Name npm Package Category Author Weekly Downloads Directory URL
AI Agent @convex-dev/agent AI get-convex 33,929 /components/ai-agent
RAG @convex-dev/rag AI get-convex 18,868 /components/rag
Persistent Text Streaming @convex-dev/persistent-text-streaming AI get-convex 13,867 /components/persistent-text-streaming
Convex Stagehand @browserbasehq/convex-stagehand AI browserbase 846 /components/convex-stagehand
Nano Banana convex-nano-banana AI/Backend dperussina 700 /components/nano-banana
Neutral Cost neutral-cost AI neutralbase 310 /components/neutral-cost
Durable Agents convex-durable-agents AI ziegfried 574 /components/durable-agents
Firecrawl Scrape convex-firecrawl-scrape AI Gitmaxd 390 /components/firecrawl-scrape
Browser Use Convex Component browser-use-convex-component AI Cheggin 111 /components/browser-use-convex-component
DatabaseChat @dayhaysoos/convex-database-chat AI dayhaysoos 88 /components/database-chat
Convex ElevenLabs convex-elevenlabs AI wantpinow 3 /components/convex-elevenlabs
LLM Cache @mzedstudio/llm-cache AI raymond-UI 3 /components/llm-cache
Convex Jina convex-jina AI adhishthite 2 /components/convex-jina
Better Auth @convex-dev/better-auth Authentication get-convex 52,558 /components/better-auth
WorkOS AuthKit @convex-dev/workos-authkit Authentication get-convex 4,358 /components/workos-authkit
Convex AuthZ @djpanda/convex-authz Authentication dbjpanda 840 /components/convex-authz
API Tokens convex-api-tokens Authentication TimpiaAI 470 /components/api-tokens
Kinde Sync @sholajegede/kinde-sync Authentication sholajegede 389 /components/kinde-sync
Convex Passkey Auth convex-passkey-auth Authentication TimpiaAI 172 /components/convex-passkey-auth
OAuth Provider @codefox-inc/oauth-provider Authentication codefox-inc 109 /components/oauth-provider
Convex Invite Links convex-invite-links Authentication TimpiaAI 93 /components/convex-invite-links
Convex API Keys convex-api-keys Authentication gaganref 83 /components/convex-api-keys
Convex Tenants @djpanda/convex-tenants Authentication dbjpanda 21 /components/convex-tenants
Convex Cascading Delete (by akshatsinha0) Authentication akshatsinha0 small /components/convex-cascading-delete
Convex API Keys @00akshatsinha00/convex-api-keys Authentication akshatsinha0 3 /components/convex-api-keys-akshatsinha
Rate Limiter @convex-dev/rate-limiter Backend get-convex 57,537 /components/rate-limiter
Action Cache @convex-dev/action-cache Backend get-convex 20,199 /components/action-cache
Files Control @gilhrpenner/convex-files-control Backend gilhrpenner 885 /components/files-control
Timeline convex-timeline Backend MeshanKhosla 790 /components/timeline
ConvexFS convex-fs Backend jamwt 409 /components/convex-fs
Convex Debouncer @ikhrustalev/convex-debouncer Backend ikhrustalev 292 /components/convex-debouncer
Webhook Sender convex-webhook-sender Backend TimpiaAI 21 /components/webhook-sender
Convex MQ (by gergesh) Backend gergesh 5 /components/convex-mq
Link Shortener @the_shujaa/link-shortener Backend Shujaagideon 5 /components/link-shortener
Convex Tracer convex-tracer Backend Moumen-io 1 /components/convex-tracer
Presence @convex-dev/presence Collaboration get-convex 11,592 /components/presence
Collaborative Text Editor Sync @convex-dev/prosemirror-sync Collaboration get-convex 6,300 /components/prosemirror-sync
Mux @mux/convex Collaboration muxinc 309 /components/mux
Unread Tracking convex-unread-tracking Collaboration TimpiaAI 162 /components/unread-tracking
ClawdBot Message Hub (convex-clawdbot-hub) Collaboration TimpiaAI 76 /components/clawdbot-message-hub
Convex Comments @hamzasaleemorg/convex-comments Collaboration hamzasaleem2 5 /components/convex-comments
Migrations @convex-dev/migrations Database get-convex 44,692 /components/migrations
Aggregate @convex-dev/aggregate Database get-convex 26,208 /components/aggregate
Sharded Counter @convex-dev/sharded-counter Database get-convex 10,872 /components/sharded-counter
Geospatial @convex-dev/geospatial Database get-convex 2,314 /components/geospatial
Convex KV @hamzasaleemorg/convex-kv Database hamzasaleem2 531 /components/convex-kv
Cascading Deletes (by sholajegede) Database sholajegede 295 /components/cascading-deletes
Convex Audit Log convex-audit-log Database robertalv 7 /components/convex-audit-log
Smart Tags (by mdabdulmazidkhan) Database mdabdulmazidkhan 2 /components/smart-tags
Workpool @convex-dev/workpool Durable Functions get-convex 83,511 /components/workpool
Workflow @convex-dev/workflow Durable Functions get-convex 44,341 /components/workflow
Action Retrier @convex-dev/action-retrier Durable Functions get-convex 27,060 /components/action-retrier
Crons @convex-dev/crons Durable Functions get-convex 10,725 /components/crons
Convex Batch Processor convex-batch-processor Durable Functions blocknavi 15 /components/convex-batch-processor
Quick Convex @danthegoodman/quick-convex Durable Functions danthegoodman1 7 /components/quick-convex
Resend @convex-dev/resend Integrations get-convex 33,353 /components/resend
Cloudflare R2 @convex-dev/r2 Integrations get-convex 14,944 /components/r2
Expo Push Notifications @convex-dev/expo-push-notifications Integrations get-convex 5,910 /components/expo-push-notifications
Twilio SMS @convex-dev/twilio Integrations get-convex 2,042 /components/twilio
Loops @devwithbobby/loops Integrations robertalv 406 /components/loops
LaunchDarkly Feature Flags @convex-dev/launchdarkly Integrations get-convex 365 /components/launchdarkly
Bright Data Datasets (by sholajegede) Integrations sholajegede 342 /components/bright-data-datasets
Convex Bunny convex-bunny Integrations lipaonline 282 /components/convex-bunny
Bright Data (Cache) (by sholajegede) Integrations sholajegede 270 /components/bright-data-cache
Brevo (by pierre-H) Integrations pierre-H 226 /components/brevo
Static Hosting @convex-dev/static-hosting Integrations get-convex 214 /components/static-hosting
Convex YouTube Cache (by TimpiaAI) Integrations TimpiaAI 161 /components/convex-youtube-cache
Convex Inbound @hamzasaleemorg/convex-inbound Integrations hamzasaleem2 15 /components/convex-inbound
Stripe @convex-dev/stripe Payments get-convex 10,876 /components/stripe
Autumn @useautumn/convex Payments useautumn 5,038 /components/autumn
Polar @convex-dev/polar Payments erquhart 2,145 /components/polar
RevenueCat convex-revenuecat Payments ramonclaudio 463 /components/revenuecat
Dodo Payments @dodopayments/convex Payments dodopayments 355 /components/dodo-payments
Creem @mmailaender/convex-creem Payments mmailaender 130 /components/creem
Kinde Billing convex-kinde-billing Payments sholajegede 7 /components/kinde-billing

Total Components: 75 (Nano Banana appears in both AI and Backend categories but is counted once)

AI components

1. AI Agent

npm: @convex-dev/agent Version: 0.6.1 Weekly Downloads: 33,929 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/agent npm URL: https://www.npmjs.com/package/@convex-dev/agent Directory: https://www.convex.dev/components/ai-agent

Description: Build AI agents with message history, vector search, and long-running workflows that stay reactive to your Convex database changes. Separates long-running AI operations from your UI whilst maintaining real-time reactivity through Convex's websocket streaming. Handles thread management, message persistence, file storage integration, and includes built-in debugging tools and usage tracking.

How It Works: Centres around Agents, Threads, and Messages. Agents encapsulate LLM prompting logic, tools, and behaviour. Threads persist conversation history shared across multiple users and agents. Messages automatically include conversation context through built-in hybrid vector/text search. Streaming handled through Convex websockets.

Install Command: 

npm install @convex-dev/agent

Use Cases: - Conversational AI assistants with persistent memory - Multi-agent orchestration with shared threads - LLM-powered features needing context awareness - Real-time agent status monitoring in UI

2. RAG

npm: @convex-dev/rag Version: 0.7.1 Weekly Downloads: 18,868 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/rag npm URL: https://www.npmjs.com/package/@convex-dev/rag Directory: https://www.convex.dev/components/rag

Description: Retrieval-Augmented Generation component that automatically chunks text, generates embeddings using AI SDK models, and provides vector-based similarity search across namespaced content. Includes custom filtering, importance weighting, chunk context expansion, and graceful content migration.

How It Works: Integrates via the standard component pattern. Content added via add() which automatically chunks text and generates embeddings, organised into namespaces. Search via search() with vector similarity matching. generateText() combines search and LLM generation in one call.

Install Command: 

npm install @convex-dev/rag

Use Cases: - Semantic search over documentation - Context-aware LLM generation from knowledge base - FAQ systems with fuzzy matching - Multi-tenant vector storage

3. Persistent Text Streaming

npm: @convex-dev/persistent-text-streaming Version: 0.3.0 Weekly Downloads: 13,867 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/persistent-text-streaming npm URL: https://www.npmjs.com/package/@convex-dev/persistent-text-streaming Directory: https://www.convex.dev/components/persistent-text-streaming

Description: Combines HTTP streaming with database persistence to deliver real-time text updates whilst storing content permanently. Provides React hook that streams text from HTTP actions whilst simultaneously persisting chunks to the database at sentence boundaries.

How It Works: Uses HTTP actions for streaming endpoints with React hooks. Handles CORS headers and manages connection between ephemeral HTTP streams and durable database storage.

Install Command: 

npm install @convex-dev/persistent-text-streaming

Use Cases: - AI-generated content with streaming display and archival - Real-time transcription storage - Incremental report generation with preview - Cost-per-token LLM integration with replay capability

4. Convex Stagehand

npm: @browserbasehq/convex-stagehand Version: 0.1.0 Weekly Downloads: 846 Author: browserbase Licence: MIT GitHub: https://github.com/browserbasehq/convex-stagehand npm URL: https://www.npmjs.com/package/@browserbasehq/convex-stagehand Directory: https://www.convex.dev/components/convex-stagehand

Description: AI-powered browser automation with Stagehand for web scraping, testing, and UI interactions using natural language. No Playwright knowledge required. Manages browser sessions via Browserbase cloud infrastructure.

How It Works: Wraps Stagehand REST API in Convex actions. Methods like extract(), act(), or agent() accept natural language instructions and optional Zod schemas. Supports manual session control with startSession()/endSession() for multi-step workflows.

Install Command: 

npm install @browserbasehq/convex-stagehand

Use Cases: - Autonomous web testing workflows - Structured data extraction from dynamic sites - E-commerce price monitoring - Form automation and data migration

5. Nano Banana

npm: convex-nano-banana Version: varies Weekly Downloads: 700 Author: dperussina Licence: (varies) Directory: https://www.convex.dev/components/nano-banana

Description: Integrates Google Gemini's AI image generation directly into Convex with persistent file storage and real-time status tracking. Provides TypeScript API for text-to-image generation and image editing, handling complete lifecycle from generation through storage.

How It Works: Wraps Google Gemini image generation API. generate() for text-to-image, edit() for modifications. Creates database records with status tracking (pending, generating, complete, failed). Images auto-stored in Convex file storage.

Install Command: 

npm install convex-nano-banana

Use Cases: - Product image generation in e-commerce - AI-driven design tools - Content creation with visual assets - Dynamic illustration generation

6. Neutral Cost

npm: neutral-cost Version: varies Weekly Downloads: 310 Author: neutralbase Licence: (varies) Directory: https://www.convex.dev/components/neutral-cost

Description: Comprehensive cost tracking and billing management for AI applications. Tracks token usage from AI providers like OpenAI, tool costs from services like web search APIs, and applies configurable markup multipliers for customer billing. Includes rate limiting and credit-based billing.

How It Works: addAICost() and addToolCost() from actions. Pricing database maps model/tool IDs to costs with markup multipliers. Queries like getAICostsByThread() and getTotalAICostsByUser() for frontend displays.

Install Command: 

npm install neutral-cost

Use Cases: - SaaS cost allocation per user/feature - Usage-based billing for AI platforms - Cost analytics and profitability tracking - Credit-based systems with rate limiting

7. Durable Agents

npm: convex-durable-agents Version: 0.2.5 Weekly Downloads: 574 Author: ziegfried Licence: Apache-2.0 GitHub: https://github.com/ziegfried/convex-durable-agents npm URL: https://www.npmjs.com/package/convex-durable-agents Directory: https://www.convex.dev/components/durable-agents

Description: Build durable AI agents that survive failures, restarts, and execute tool calls asynchronously without time limits. Built on AI SDK v6, executes agent tool loops asynchronously to avoid Convex action time limits.

How It Works: Wraps AI SDK streamText with Convex durable execution. Define agents via streamHandlerAction, export via defineAgentApi. Tools via createActionTool (sync) or createAsyncTool (background). Routes through @convex-dev/workpool for parallelism control.

Install Command: 

npm install convex-durable-agents

Use Cases: - Long-running agentic workflows - Multi-step tool execution without timeout - Complex decision trees with external APIs - Research and analysis agents

8. Firecrawl Scrape

npm: convex-firecrawl-scrape Version: 0.1.3 Weekly Downloads: 390 Author: Gitmaxd Licence: (varies) GitHub: https://github.com/Gitmaxd/convex-firecrawl-scrape npm URL: https://www.npmjs.com/package/convex-firecrawl-scrape Directory: https://www.convex.dev/components/firecrawl-scrape

Description: Scrape any URL and get clean markdown, HTML, screenshots, or structured JSON with durable caching and reactive queries. Built on Firecrawl's scraping API with intelligent caching and SSRF protection.

How It Works: scrape() starts async job, returns job ID for reactive monitoring via useQuery(). Cached with configurable TTL (default 30 days) with superset matching. Supports structured JSON extraction via schema validation.

Install Command: 

npm install convex-firecrawl-scrape

Use Cases: - Content monitoring and archival - Competitive intelligence gathering - SEO analysis at scale - Structured data extraction with schema validation

9. Browser Use Convex Component

npm: browser-use-convex-component Version: 0.1.1 Weekly Downloads: 111 Author: Cheggin Licence: (varies) GitHub: https://github.com/Cheggin/browser-use-convex-component npm URL: https://www.npmjs.com/package/browser-use-convex-component Directory: https://www.convex.dev/components/browser-use-convex-component

Description: Integrates Browser Use Cloud's AI-powered browser automation API with Convex's reactive database. Provides persistent task tracking, session management, and browser profile storage with real-time queries on automation status.

How It Works: Wraps Browser Use Cloud API in Convex actions. createTask() starts automation jobs. Supports AI model selection, structured JSON output, domain restrictions. Provides both actions and queries for reactive UI updates.

Install Command: 

npm install browser-use-convex-component

Use Cases: - Autonomous RPA workflows - API testing and validation - UI regression detection - Data entry automation

10. DatabaseChat

npm: @dayhaysoos/convex-database-chat Version: 0.3.0-alpha.1 Weekly Downloads: 88 Author: dayhaysoos Licence: (varies) GitHub: https://github.com/dayhaysoos/convex-database-chat npm URL: https://www.npmjs.com/package/@dayhaysoos/convex-database-chat Directory: https://www.convex.dev/components/database-chat

Description: Lets users ask questions about your data in plain English. The LLM calls tools you define to query your database and returns helpful responses. Uses delta-based streaming for efficient real-time updates.

How It Works: Define tools with JSON Schema parameters mapped to Convex query functions. Uses OpenRouter API to process natural language and determine tool calls. Stores conversations in tables, implements delta-based streaming. React hooks provided.

Install Command: 

npm install @dayhaysoos/convex-database-chat

Use Cases: - Natural language analytics dashboards - Business intelligence chatbots - Data exploration interfaces - Self-service reporting

11. Convex ElevenLabs

npm: convex-elevenlabs Version: 0.1.0 Weekly Downloads: 3 Author: wantpinow Licence: (varies) GitHub: https://github.com/wantpinow/convex-elevenlabs npm URL: https://www.npmjs.com/package/convex-elevenlabs Directory: https://www.convex.dev/components/convex-elevenlabs

Description: Integrate ElevenLabs text-to-speech API with Convex backend functions for voice synthesis. Handles audio file storage and retrieval with built-in Convex integration.

How It Works: Wraps ElevenLabs REST API. synthesize() converts text to speech with voice selection and stability parameters. Audio stored in Convex file storage with metadata indexing.

Install Command: 

npm install convex-elevenlabs

Use Cases: - Voice-enabled assistants - Accessible audio content generation - Podcast generation from articles - Multilingual voice output

12. LLM Cache

npm: @mzedstudio/llm-cache Version: varies Weekly Downloads: 3 Author: raymond-UI (mzedstudio) Licence: (varies) Directory: https://www.convex.dev/components/llm-cache

Description: Cache LLM API requests/responses with tiered TTL, time travel debugging, and request normalisation. Provider-agnostic (OpenAI, Anthropic, Google). Reduces redundant API calls and costs.

How It Works: Wraps LLM API calls with request normalisation and response caching. Stores prompts and completions with metadata. Query builder for debugging and cache hit analysis.

Install Command: 

npm install @mzedstudio/llm-cache

Use Cases: - Cost reduction for high-volume LLM usage - A/B testing with cached responses - Deterministic testing and replay - Request/response debugging

13. Convex Jina

npm: convex-jina Version: 0.1.0 Weekly Downloads: 2 Author: adhishthite Licence: (varies) GitHub: https://github.com/adhishthite/convex-jina npm URL: https://www.npmjs.com/package/convex-jina Directory: https://www.convex.dev/components/convex-jina

Description: Wraps Jina AI Reader and Search APIs with durable caching and reactive queries. Convert any URL to clean markdown and search the web from Convex functions. All responses cached in Convex database with configurable TTL.

How It Works: readUrl() converts webpage to structured markdown via Jina Reader API. search() queries web via Jina Search. Results cached with TTL and superset matching for efficient retrieval.

Install Command: 

npm install convex-jina

Use Cases: - Knowledge base enrichment from web content - Web search integration in agents - URL-to-markdown document conversion - Content curation and monitoring

Authentication components

1. Better Auth

npm: @convex-dev/better-auth Version: 0.10.13 Weekly Downloads: 52,558 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/better-auth npm URL: https://www.npmjs.com/package/@convex-dev/better-auth Directory: https://www.convex.dev/components/better-auth

Description: Framework-agnostic authentication across React, Vue, Svelte, Next.js. Handles email/password, OAuth providers (GitHub, Google, Discord, Twitter), and MFA whilst managing sessions through Convex database.

How It Works: Bridge between Better Auth and Convex. Better Auth handles authentication logic, sessions, OAuth. Component ensures all data stored through Convex backend for durability and reactivity.

Install Command: 

npm install @convex-dev/better-auth

Use Cases: - Multi-provider authentication (OAuth + email) - Session management across frameworks - MFA enforcement for security - User profile and credential management

2. WorkOS AuthKit

npm: @convex-dev/workos-authkit Version: 0.1.6 Weekly Downloads: 4,358 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/workos-authkit npm URL: https://www.npmjs.com/package/@convex-dev/workos-authkit Directory: https://www.convex.dev/components/workos-authkit

Description: Sync WorkOS AuthKit authentication events and user data into Convex via webhooks. Handles user creation, deletion, authentication/registration control via WorkOS actions with automatic webhook signature verification.

How It Works: Webhook handlers for user.created, user.updated, user.deleted events. Automatic signature verification using Svix. Syncs user data into Convex tables with idempotency guarantees.

Install Command: 

npm install @convex-dev/workos-authkit

Use Cases: - Enterprise SSO with WorkOS - User lifecycle synchronisation - Authentication event auditing - Centralised identity management

3. Convex AuthZ

npm: @djpanda/convex-authz Version: 0.1.7 Weekly Downloads: 840 Author: dbjpanda Licence: MIT GitHub: https://github.com/djpanda/convex-authz npm URL: https://www.npmjs.com/package/@djpanda/convex-authz Directory: https://www.convex.dev/components/convex-authz

Description: Zanzibar-inspired authorisation with RBAC, ABAC, and ReBAC using O(1) indexed permission lookups. Pre-computes permissions into indexed tables for instant checks. Supports scoped permissions, expiring grants, real-time updates. React integration with useCanUser() hooks and PermissionGate components.

How It Works: Permission matrix pre-computed and indexed by subject, action, resource. Supports role inheritance and attribute-based rules. React hooks evaluate permissions client-side without round trips. Real-time subscriptions for permission changes.

Install Command: 

npm install @djpanda/convex-authz

Use Cases: - Fine-grained access control (RBAC/ABAC) - Document-level permissions - Resource-based policies (ReBAC) - Real-time permission UI feedback

4. API Tokens

npm: convex-api-tokens Version: 0.3.2 Weekly Downloads: 470 Author: TimpiaAI Licence: (varies) GitHub: https://github.com/TimpiaAI/convex-api-tokens npm URL: https://www.npmjs.com/package/convex-api-tokens Directory: https://www.convex.dev/components/api-tokens

Description: Complete API token lifecycle management for SaaS. Issue sk_-prefixed tokens with namespaces, expiration, metadata. SHA-256 hashing, token rotation, bulk revocation, AES-256-GCM encrypted third-party key storage. HTTP/mutation middleware for endpoint protection.

How It Works: generateToken() creates hashed, expirable tokens. verifyToken() checks validity. Supports namespace scoping (e.g., workspace_123). Encrypted storage for third-party keys. Middleware for HTTP action and mutation protection.

Install Command: 

npm install convex-api-tokens

Use Cases: - API key management for integrations - Third-party credential encryption - Token expiration and rotation - Namespace-scoped access control

5. Kinde Sync

npm: @sholajegede/kinde-sync Version: 0.1.3 Weekly Downloads: 389 Author: sholajegede Licence: (varies) GitHub: https://github.com/sholajegede/kinde-sync npm URL: https://www.npmjs.com/package/@sholajegede/kinde-sync Directory: https://www.convex.dev/components/kinde-sync

Description: Automatically sync Kinde authentication events into Convex via webhook handlers with JWT verification. Handles user.created, user.updated, user.deleted events automatically. Provides reactive query functions.

How It Works: Webhook handler with JWT signature verification. Creates/updates user records on Kinde events. Reactive queries for current users and user lookups.

Install Command: 

npm install @sholajegede/kinde-sync

Use Cases: - Kinde integration with Convex backend - User data synchronisation - Authentication event tracking - User lifecycle management

6. Convex Passkey Auth

npm: convex-passkey-auth Version: 1.0.1 Weekly Downloads: 172 Author: TimpiaAI Licence: (varies) GitHub: https://github.com/TimpiaAI/convex-passkey-auth npm URL: https://www.npmjs.com/package/convex-passkey-auth Directory: https://www.convex.dev/components/convex-passkey-auth

Description: WebAuthn passkey authentication for Convex with self-minted HMAC-SHA256 JWTs. Multi-device support, session management, React hooks for registration/login. No external auth providers needed.

How It Works: WebAuthn credential registration and verification. Self-minted JWTs using Convex secrets. Multi-device support with credential management. React hooks handle registration ceremony and login.

Install Command: 

npm install convex-passkey-auth

Use Cases: - Passwordless authentication - Phishing-resistant user verification - Multi-device credential management - Zero-dependency auth infrastructure

7. OAuth Provider

npm: @codefox-inc/oauth-provider Version: 0.3.0 Weekly Downloads: 109 Author: codefox-inc Licence: Apache-2.0 GitHub: https://github.com/codefox-inc/oauth-provider npm URL: https://www.npmjs.com/package/@codefox-inc/oauth-provider Directory: https://www.convex.dev/components/oauth-provider

Description: Turn your Convex backend into an OAuth 2.1/OpenID Connect provider. Enforces PKCE with S256, RS256 JWT access tokens. Supports Dynamic Client Registration.

How It Works: OAuth 2.1 flows with PKCE enforcement. Authorisation code and token endpoints. RS256-signed JWTs. Dynamic client registration for external integrations.

Install Command: 

npm install @codefox-inc/oauth-provider

Use Cases: - Making Convex app an OAuth provider - Federated identity for third-party apps - OIDC-compliant authentication - OpenID Connect integration

npm: convex-invite-links Version: 1.0.0 Weekly Downloads: 93 Author: TimpiaAI Licence: (varies) GitHub: https://github.com/TimpiaAI/convex-invite-links npm URL: https://www.npmjs.com/package/convex-invite-links Directory: https://www.convex.dev/components/convex-invite-links

Description: Membership tracking and invite-based access control through shareable links. Group-level and resource-level permissions, invite lifecycle with expiration and email locking. HTTP endpoints for social preview generation.

How It Works: createInvite() generates shareable links with expiration. acceptInvite() registers user in group/resource. Tracks invite usage and sender. HTTP endpoints generate Open Graph metadata for sharing.

Install Command: 

npm install convex-invite-links

Use Cases: - Team/workspace invitations - Resource sharing with permissions - Invite expiration and tracking - Referral systems with attribution

9. Convex API Keys (gaganref)

npm: convex-api-keys Version: 0.2.1 Weekly Downloads: 83 Author: gaganref Licence: (varies) GitHub: https://github.com/gaganref/convex-api-keys npm URL: https://www.npmjs.com/package/convex-api-keys Directory: https://www.convex.dev/components/convex-api-keys-gaganref

Description: API key management with rotation, expiry, idle timeouts, typed permissions, and audit logs.

How It Works: generateKey() creates hashed keys with TTL and permissions. validateKey() checks validity and freshness. Audit log tracks creation, rotation, and invalidation. Idle timeout enforcement.

Install Command: 

npm install convex-api-keys

Use Cases: - API key lifecycle management - Rotating keys for security - Permission-scoped API access - Audit trail for compliance

10. Convex Tenants

npm: @djpanda/convex-tenants Version: 0.1.6 Weekly Downloads: 21 Author: dbjpanda Licence: MIT GitHub: https://github.com/djpanda/convex-tenants npm URL: https://www.npmjs.com/package/@djpanda/convex-tenants Directory: https://www.convex.dev/components/convex-tenants

Description: Multi-tenant organisation and team management with built-in authorisation via @djpanda/convex-authz. CRUD operations for organisations with unique slugs, role-based member management, team creation, flexible invitation system. React hooks and UI components included.

How It Works: Organisations with unique slugs as business identifiers. Team management within orgs. Role-based member permissions integrated with convex-authz. Invite system with role assignment. React hooks for UI.

Install Command: 

npm install @djpanda/convex-tenants

Use Cases: - Multi-tenant SaaS applications - Organisation management - Team and role hierarchies - Member and permission administration

11. Convex Cascading Delete

npm: (by akshatsinha0) Version: varies Weekly Downloads: small Author: akshatsinha0 Licence: (varies) GitHub: https://github.com/akshatsinha0/convex-cascading-delete Directory: https://www.convex.dev/components/convex-cascading-delete

Description: Manage cascading deletes across related documents with atomic and batched deletion modes.

How It Works: Configure deletion rules via index relationships. Atomic mode deletes all related records in one transaction. Batched mode processes large deletions incrementally. Progress tracking and failure recovery.

Install Command: 

npm install convex-cascading-delete

Use Cases: - Referential integrity enforcement - Cleaning up dependent records - Large-scale data cleanup - Compliance and data retention

12. Convex API Keys (akshatsinha0)

npm: @00akshatsinha00/convex-api-keys Version: 0.1.0 Weekly Downloads: 3 Author: akshatsinha0 Licence: (varies) GitHub: https://github.com/akshatsinha0/convex-api-keys npm URL: https://www.npmjs.com/package/@00akshatsinha00/convex-api-keys Directory: https://www.convex.dev/components/convex-api-keys-akshatsinha

Description: Zero-dependency API key management with SHA-256 hashing, rate limiting, RBAC, usage credits, audit logging within Convex transactions.

How It Works: Hashed key storage with rate limiting per key. RBAC via role definitions. Credit-based usage tracking. Transactional audit logs with before/after state.

Install Command: 

npm install @00akshatsinha00/convex-api-keys

Use Cases: - Lightweight API key management - Rate limiting enforcement - Role-based API access - Usage tracking and quotas

Backend components

1. Rate Limiter

npm: @convex-dev/rate-limiter Version: 0.3.2 Weekly Downloads: 57,537 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/rate-limiter npm URL: https://www.npmjs.com/package/@convex-dev/rate-limiter Directory: https://www.convex.dev/components/rate-limiter

Description: Type-safe, transactional rate limiting with fixed window and token bucket algorithms, configurable sharding for high-throughput. React hooks for client-side checking. Capacity reservation to prevent starvation, fairness guarantees.

How It Works: Fixed window: counts resets per time period. Token bucket: replenishes tokens at rate. Sharding distributes load across multiple records to prevent write contention. Capacity reservation prevents starvation. React hook checks before mutations.

Install Command: 

npm install @convex-dev/rate-limiter

Use Cases: - API rate limiting per user/IP - Fair queue systems - Cost control for expensive operations - DDoS prevention

2. Action Cache

npm: @convex-dev/action-cache Version: 0.3.0 Weekly Downloads: 20,199 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/action-cache npm URL: https://www.npmjs.com/package/@convex-dev/action-cache Directory: https://www.convex.dev/components/action-cache

Description: Cache expensive action results like AI API calls with configurable TTL. Automatic cleanup via daily cron. Uses action name + args as cache key. Supports force refresh for cache warming.

How It Works: cachedAction() wrapper computes cache key from action name and arguments. Returns cached result if fresh. Automatic TTL-based expiration. Force refresh option for cache invalidation. Cleanup cron removes stale entries.

Install Command: 

npm install @convex-dev/action-cache

Use Cases: - AI API response caching (LLM, embeddings) - Expensive external API call memoisation - Cost reduction for high-volume requests - Deterministic testing with cached responses

3. Files Control

npm: @gilhrpenner/convex-files-control Version: varies Weekly Downloads: 885 Author: gilhrpenner Licence: Apache-2.0 GitHub: https://github.com/gilhrpenner/convex-files-control npm URL: https://www.npmjs.com/package/@gilhrpenner/convex-files-control Directory: https://www.convex.dev/components/files-control

Description: Secure file uploads, access control, download grants, and lifecycle cleanup. Two-step uploads with presigned URLs, download grants with usage limits and expiration. Works with both Convex storage and Cloudflare R2.

How It Works: Presigned upload URLs for direct client-to-storage uploads. Download grants with time/usage limits for fine-grained sharing. Support for Convex files and R2 buckets. Automatic cleanup of expired content.

Install Command: 

npm install @gilhrpenner/convex-files-control

Use Cases: - Secure user file uploads - Temporary download links with expiration - Access-controlled file sharing - Storage cleanup and retention policies

4. Timeline

npm: convex-timeline Version: 0.1.2 Weekly Downloads: 790 Author: MeshanKhosla Licence: (varies) GitHub: https://github.com/MeshanKhosla/convex-timeline npm URL: https://www.npmjs.com/package/convex-timeline Directory: https://www.convex.dev/components/timeline

Description: Undo/redo state management with named checkpoints. Linear history of state snapshots organised by scope with configurable capacity limits and automatic pruning.

How It Works: checkpoint() saves named snapshot at current state. undo() and redo() navigate history. Scoped timelines (e.g., per-document) isolate histories. Capacity limits and pruning prevent unbounded growth. Compression for older snapshots.

Install Command: 

npm install convex-timeline

Use Cases: - Document editor undo/redo - Form history and recovery - Audit trail with rollback capability - Version control without git

5. ConvexFS

npm: convex-fs Version: 0.2.1 Weekly Downloads: 409 Author: jamwt Licence: Apache-2.0 GitHub: https://github.com/jamwt/convex-fs npm URL: https://www.npmjs.com/package/convex-fs Directory: https://www.convex.dev/components/convex-fs

Description: Globally distributed file storage via Bunny.net Edge Storage and CDN. Filesystem-like path-based operations, atomic operations, reference-counted blob deduplication, signed CDN URLs, configurable soft deletes.

How It Works: Organises files into hierarchical paths. write(), read(), delete() operations. Blob deduplication via reference counting. CDN URLs with optional signing. Soft deletes for recovery.

Install Command: 

npm install convex-fs

Use Cases: - Global file distribution via CDN - Filesystem-like file hierarchies - Cost-effective blob storage - Signed/expiring download URLs

6. Convex Debouncer

npm: @ikhrustalev/convex-debouncer Version: 0.1.0 Weekly Downloads: 292 Author: ikhrustalev Licence: (varies) GitHub: https://github.com/ikhrustalev/convex-debouncer npm URL: https://www.npmjs.com/package/@ikhrustalev/convex-debouncer Directory: https://www.convex.dev/components/convex-debouncer

Description: Server-side debouncing with three modes: sliding (resets timer), fixed (maintains timer, updates args), eager (executes immediately then queues trailing). For LLM calls, metrics computation, batch processing.

How It Works: Sliding: cancels previous pending execution. Fixed: keeps original execution time, updates arguments. Eager: executes immediately, then debounces subsequent calls. Configurable delay and execution window.

Install Command: 

npm install @ikhrustalev/convex-debouncer

Use Cases: - Debouncing rapid form updates to database - LLM calls from user input - Metrics aggregation - Batch processing optimisation

7. Webhook Sender

npm: convex-webhook-sender Version: 1.1.0 Weekly Downloads: 21 Author: TimpiaAI Licence: (varies) GitHub: https://github.com/TimpiaAI/convex-webhook-sender npm URL: https://www.npmjs.com/package/convex-webhook-sender Directory: https://www.convex.dev/components/webhook-sender

Description: Reliable outbound webhook delivery with HMAC-SHA256 signing, automatic retries with exponential backoff, comprehensive delivery tracking. Standard Webhooks-compatible headers.

How It Works: sendWebhook() posts payload with HMAC-SHA256 signature. Automatic retries with exponential backoff and jitter. Delivery tracking with attempt history. Svix-compatible header format.

Install Command: 

npm install convex-webhook-sender

Use Cases: - Outbound event webhooks to integrations - Reliable delivery to external systems - Signature verification for security - Delivery auditing and debugging

8. Convex MQ

npm: (by gergesh) Version: varies Weekly Downloads: 5 Author: gergesh Licence: (varies) Directory: https://www.convex.dev/components/convex-mq

Description: Typed message queue with reactive consumers, visibility timeouts, automatic retries. Two modes: component mode (isolated tables) or library mode (custom schemas). Claim-ack pattern with lease tokens.

How It Works: Enqueue typed messages. Consumers claim messages with visibility timeout. Acknowledge on success, retry on failure. Reactive queries on queue status. Supports custom table schemas.

Install Command: 

npm install convex-mq

Use Cases: - Durable job queuing - Consumer group patterns - Message deduplication - Visibility timeout for processing windows

npm: @the_shujaa/link-shortener Version: 0.1.1 Weekly Downloads: 5 Author: Shujaagideon Licence: (varies) GitHub: https://github.com/Shujaagideon/link-shortener npm URL: https://www.npmjs.com/package/@the_shujaa/link-shortener Directory: https://www.convex.dev/components/link-shortener

Description: Self-hosted link shortener with custom domains, click analytics, UTM tracking, configurable rate limiting. All data in Convex database.

How It Works: shortenLink() generates unique slug or custom alias. Click tracking with geolocation and referrer. UTM parameter preservation. Custom domain routing. Rate limiting per user.

Install Command: 

npm install @the_shujaa/link-shortener

Use Cases: - URL shortening service - Click analytics for campaigns - UTM tracking for marketing - Custom domain routing

10. Convex Tracer

npm: convex-tracer Version: 0.1.3 Weekly Downloads: 1 Author: Moumen-io Licence: (varies) GitHub: https://github.com/Moumen-io/convex-tracer npm URL: https://www.npmjs.com/package/convex-tracer Directory: https://www.convex.dev/components/convex-tracer

Description: Function execution observability with nested spans, error tracing, configurable sampling. Wrapper functions for queries, mutations, actions.

How It Works: Decorator pattern wraps Convex functions. Records execution time, arguments, errors. Nested spans for function calls within functions. Configurable sampling for high-volume functions. Export to tracing backend.

Install Command: 

npm install convex-tracer

Use Cases: - Function performance monitoring - Distributed tracing - Error diagnosis - Latency analysis

Collaboration components

1. Presence

npm: @convex-dev/presence Version: 0.3.0 Weekly Downloads: 11,592 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/presence npm URL: https://www.npmjs.com/package/@convex-dev/presence Directory: https://www.convex.dev/components/presence

Description: Real-time user presence tracking for rooms/spaces. Manages who's online, last active times, join/leave events without polling. React hooks (usePresence) with automatic heartbeats. React Native support.

How It Works: Subscribe to rooms with automatic heartbeat. Websocket connection sends presence updates. Real-time queries show online users. Join/leave events trigger reactivity. Configurable timeout for stale presence.

Install Command: 

npm install @convex-dev/presence

Use Cases: - Collaborative editing presence indicators - Chat application user status - Real-time multiplayer game presence - Office space occupancy tracking

2. Collaborative Text Editor Sync

npm: @convex-dev/prosemirror-sync Version: 0.2.3 Weekly Downloads: 6,300 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/prosemirror-sync npm URL: https://www.npmjs.com/package/@convex-dev/prosemirror-sync Directory: https://www.convex.dev/components/prosemirror-sync

Description: Collaborative document editing using ProseMirror operational transformation. React hooks for Tiptap and BlockNote editors. Handles conflict resolution, debounced snapshots, server-side document transformations for AI integration.

How It Works: Operational transformation for conflict-free document sync. ProseMirror steps streamed between clients. Server maintains canonical document state. Snapshots at regular intervals for new client catchup. Supports server-side AI transformations (summarise, format, etc.).

Install Command: 

npm install @convex-dev/prosemirror-sync

Use Cases: - Real-time collaborative documents (Google Docs-like) - Multi-user code editors - Tiptap/BlockNote editor synchronisation - Server-side AI document enhancement

3. Mux

npm: @mux/convex Version: 0.3.0 Weekly Downloads: 309 Author: muxinc Licence: (varies) GitHub: https://github.com/muxinc/mux-convex npm URL: https://www.npmjs.com/package/@mux/convex Directory: https://www.convex.dev/components/mux

Description: Sync Mux video data with Convex using tables, webhooks, and reactive queries. Creates tables for assets, uploads, live streams, events, video metadata. CLI init command, backfill migration, webhook sync.

How It Works: CLI scaffolds tables and webhook handlers. Webhooks from Mux sync asset data (duration, playback IDs, etc.). Reactive queries on video metadata. Backfill via Mux API for historical data.

Install Command: 

npm install @mux/convex

Use Cases: - Video platform integration - Video metadata synchronisation - Live streaming status tracking - Video analytics from Mux

4. Unread Tracking

npm: convex-unread-tracking Version: 1.1.0 Weekly Downloads: 162 Author: TimpiaAI Licence: (varies) GitHub: https://github.com/TimpiaAI/convex-unread-tracking npm URL: https://www.npmjs.com/package/convex-unread-tracking Directory: https://www.convex.dev/components/unread-tracking

Description: Real-time unread message counter and read receipt tracker with watermark-based read positions. Per-user per-channel tracking, subscription management, React hooks with optimistic updates. Supports bulk operations via groups.

How It Works: Watermark-based read positions: track highest-seen message ID per user/channel. Unread count = messages above watermark. Subscription returns real-time unread count. React hook optimistically updates on message send. Bulk operations for marking channels read.

Install Command: 

npm install convex-unread-tracking

Use Cases: - Chat application unread badges - Notification count tracking - Read receipt indicators - Bulk mark-as-read operations

5. ClawdBot Message Hub

npm: (convex-clawdbot-hub) Version: varies Weekly Downloads: 76 Author: TimpiaAI Licence: (varies) Directory: https://www.convex.dev/components/clawdbot-message-hub

Description: Message hub for AI chatbots with webhook processing, session management, conversation history. Multi-gateway routing (WhatsApp, Telegram, Discord, Slack). Configurable session scoping, message deduplication, TTL-based cleanup.

How It Works: Webhook handlers for messaging platforms. Session management per user/conversation. Message deduplication by external ID. Conversation history stored with TTL. Routes messages to LLM via actions.

Install Command: 

npm install convex-clawdbot-hub

Use Cases: - Multi-platform AI chatbot - Unified message inbox for AI - Conversation history archival - Platform-agnostic chatbot backend

6. Convex Comments

npm: @hamzasaleemorg/convex-comments Version: 1.0.2 Weekly Downloads: 5 Author: hamzasaleem2 Licence: (varies) GitHub: https://github.com/hamzasaleem2/convex-comments npm URL: https://www.npmjs.com/package/@hamzasaleemorg/convex-comments Directory: https://www.convex.dev/components/convex-comments

Description: Threaded comment systems with mentions, reactions, typing indicators. Backend functions for threads organised into zones. Supports positioned comments for document annotation. React UI components included.

How It Works: Comments organised into zones (e.g., document ID). Thread support with nested replies. Mentions via @ syntax. Reactions (emoji) on comments. Typing indicators via presence. React components for comment UI.

Install Command: 

npm install @hamzasaleemorg/convex-comments

Use Cases: - Document annotation and feedback - Issue discussion threads - Collaborative review comments - Threaded feedback systems

Database components

1. Migrations

npm: @convex-dev/migrations Version: 0.3.3 Weekly Downloads: 44,692 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/migrations npm URL: https://www.npmjs.com/package/@convex-dev/migrations Directory: https://www.convex.dev/components/migrations

Description: Long-running data migrations on live databases with zero downtime. Batch processing, progress tracking, failure recovery, resumption. CLI/dashboard interfaces. Supports dry-run testing.

How It Works: Define migration as function over table/collection. Component batches processing to avoid write storms. Progress persisted in database; resumable on failure. Dashboard shows migration status. Dry-run mode for testing.

Install Command: 

npm install @convex-dev/migrations

Use Cases: - Schema transformations without downtime - Bulk data cleanup and consolidation - Incremental computed field population - Paid feature legacy data migration

2. Aggregate

npm: @convex-dev/aggregate Version: 0.2.1 Weekly Downloads: 26,208 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/aggregate npm URL: https://www.npmjs.com/package/@convex-dev/aggregate Directory: https://www.convex.dev/components/aggregate

Description: Maintains denormalised counts and sums in O(log n) time. Sorted key-value storage with range queries. Supports flexible grouping through tuple-based sort keys and namespaces. Ideal for leaderboards, pagination, analytics.

How It Works: Maintains aggregate tables with sort keys (namespace, grouping key). Increment/decrement operations update incrementally. Range queries fetch top N or sliced results. Namespace isolation.

Install Command: 

npm install @convex-dev/aggregate

Use Cases: - Leaderboards with rankings - Pagination with large result sets - Real-time analytics dashboards - Top-N queries (trending, popular items)

3. Sharded Counter

npm: @convex-dev/sharded-counter Version: 0.2.0 Weekly Downloads: 10,872 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/sharded-counter npm URL: https://www.npmjs.com/package/@convex-dev/sharded-counter Directory: https://www.convex.dev/components/sharded-counter

Description: High-performance counter using database sharding for concurrent increments without write conflicts. Methods: inc(), add(), count(), estimateCount(). Supports triggers and backfilling strategies.

How It Works: Distributes counter state across N shards. inc() randomly selects shard to update. count() sums all shards. Sharding prevents hotspot write contention. estimateCount() for stale-OK use cases.

Install Command: 

npm install @convex-dev/sharded-counter

Use Cases: - View/like counters at high scale - Metrics aggregation - Rate limit counters - Stock inventory tracking

4. Geospatial

npm: @convex-dev/geospatial Version: 0.2.1 Weekly Downloads: 2,314 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/geospatial npm URL: https://www.npmjs.com/package/@convex-dev/geospatial Directory: https://www.convex.dev/components/geospatial

Description: Query geographic points within map regions using efficient spatial indexing. Insert points with coordinates, filter keys, sort keys. Supports rectangular and nearest-neighbour queries.

How It Works: Geohash-based spatial indexing. Rectangular range queries by bounding box. Nearest-neighbour search via distance ranking. Optional metadata per point (name, properties, etc.). Efficient for large point clouds.

Install Command: 

npm install @convex-dev/geospatial

Use Cases: - Location-based search (nearby places) - Maps with point clustering - Geo-fencing alerts - Delivery route optimisation

5. Convex KV

npm: @hamzasaleemorg/convex-kv Version: 1.0.2 Weekly Downloads: 531 Author: hamzasaleem2 Licence: (varies) GitHub: https://github.com/hamzasaleem2/convex-kv npm URL: https://www.npmjs.com/package/@hamzasaleemorg/convex-kv Directory: https://www.convex.dev/components/convex-kv

Description: Hierarchical key-value store with namespaced paths, nested keys, efficient queries. Ideal for configuration, feature flags, metadata that doesn't fit structured table schemas. Full Convex reactivity.

How It Works: Path-based key structure (e.g., /org/123/settings). Nested key access with partial path queries. Efficient range queries. Stored in Convex tables with reactive subscriptions.

Install Command: 

npm install @hamzasaleemorg/convex-kv

Use Cases: - Feature flag storage - Configuration management - Hierarchical metadata - Settings per user/org/tenant

6. Cascading Deletes

npm: (by sholajegede) Version: varies Weekly Downloads: 295 Author: sholajegede Licence: (varies) Directory: https://www.convex.dev/components/cascading-deletes

Description: Delete a record and all its dependents in one call. Configure relationships via existing indexes. Atomic and batched deletion modes.

How It Works: Define deletion rules via foreign key indexes. Atomic mode (single transaction) or batched (incremental). Progress tracking and resumption on failure.

Install Command: 

npm install convex-cascading-deletes

Use Cases: - Referential integrity enforcement - Cleaning up dependent records on deletion - Large-scale data cleanup - Compliance and GDPR data deletion

7. Convex Audit Log

npm: convex-audit-log Version: 0.2.0 Weekly Downloads: 7 Author: robertalv Licence: (varies) GitHub: https://github.com/robertalv/convex-audit-log npm URL: https://www.npmjs.com/package/convex-audit-log Directory: https://www.convex.dev/components/convex-audit-log

Description: Comprehensive event tracking with PII redaction, before/after diff generation, flexible querying, anomaly detection. React hooks for audit log UI patterns. log(), logChange(), logBulk() methods.

How It Works: Record events with optional actor, resource, action. Automatic before/after diff for mutations. PII redaction via allowlist. Query by resource, actor, time range. Anomaly detection for unusual patterns.

Install Command: 

npm install convex-audit-log

Use Cases: - Compliance and audit trails - User action tracking - Change history for sensitive data - Anomaly detection for security

8. Smart Tags

npm: (by mdabdulmazidkhan) Version: varies Weekly Downloads: 2 Author: mdabdulmazidkhan Licence: (varies) Directory: https://www.convex.dev/components/smart-tags

Description: Smart tagging and categorisation with hierarchy and analytics. Hierarchical parent-child relationships, usage tracking, trending patterns, migration utilities.

How It Works: Hierarchical tag structure (e.g., "Technology > AI > LLMs"). Usage tracking per tag. Trending tags based on recent activity. Analytics dashboard support.

Install Command: 

npm install smart-tags

Use Cases: - Content tagging and categorisation - Hierarchical taxonomy management - Trending topic analysis - Faceted search

Durable Functions components

1. Workpool

npm: @convex-dev/workpool Version: 0.4.6 Weekly Downloads: 83,511 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/workpool npm URL: https://www.npmjs.com/package/@convex-dev/workpool Directory: https://www.convex.dev/components/workpool

Description: Manages parallel execution of actions/mutations in separate prioritised queues with configurable parallelism limits. Built-in retry with backoff/jitter. Completion callbacks for workflows. Real-time status tracking.

How It Works: Enqueue actions to named queues with priority levels. Worker loop processes queue with parallelism limit (default 1). Automatic retries with exponential backoff. Completion callbacks trigger downstream tasks. Real-time status via subscriptions.

Install Command: 

npm install @convex-dev/workpool

Use Cases: - Parallel API calls with rate limiting - Batch job processing - Fan-out/fan-in workflows - Priority-based task execution

2. Workflow

npm: @convex-dev/workflow Version: 0.3.9 Weekly Downloads: 44,341 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/workflow npm URL: https://www.npmjs.com/package/@convex-dev/workflow Directory: https://www.convex.dev/components/workflow

Description: Durable execution for long-running processes surviving server restarts. Deterministic workflows with configurable retry policies, parallel execution, reactive status monitoring. Can run for months with custom delays.

How It Works: Define workflows as deterministic async functions. Survives action/server restarts via durability checkpoints. Parallel step execution via Promise.all(). Configurable retry policies per step. Status stored and queryable reactively.

Install Command: 

npm install @convex-dev/workflow

Use Cases: - Multi-day approval workflows - Complex onboarding sequences - Data migration orchestration - Long-running background jobs (months)

3. Action Retrier

npm: @convex-dev/action-retrier Version: 0.3.0 Weekly Downloads: 27,060 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/action-retrier npm URL: https://www.npmjs.com/package/@convex-dev/action-retrier Directory: https://www.convex.dev/components/action-retrier

Description: Automatic retry with exponential backoff for failed actions. Configurable initialBackoffMs, base multiplier, maxFailures. Async status tracking, cancellation support, completion callbacks.

How It Works: Wraps action calls with retry logic. Exponential backoff: delay = initialBackoffMs * (base ^ attempt). Jitter prevents thundering herd. Async status tracking in database. Cancellation support. Completion callbacks.

Install Command: 

npm install @convex-dev/action-retrier

Use Cases: - Resilient external API calls - Transient failure recovery (network timeouts) - Webhook delivery with retries - Failed payment retry

4. Crons

npm: @convex-dev/crons Version: 0.2.0 Weekly Downloads: 10,725 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/crons npm URL: https://www.npmjs.com/package/@convex-dev/crons Directory: https://www.convex.dev/components/crons

Description: Dynamic cron job registration at runtime (vs Convex built-in static crons). Supports interval-based and unix cron expressions. Named crons for idempotent registration. Transactional creation.

Install Command: 

npm install @convex-dev/crons

How It Works: Register crons via mutation (not static config). Supports unix cron expressions (0 9 * * *) and interval-based (every 5 minutes). Named registration for idempotency. Stored in database.

Use Cases: - Runtime-configurable cron schedules - Tenant-specific cron jobs - Data cleanup and archival - Periodic synchronisation tasks

5. Convex Batch Processor

npm: convex-batch-processor Version: varies Weekly Downloads: 15 Author: blocknavi Licence: MIT GitHub: https://github.com/blocknavi/convex-batch-processor npm URL: https://www.npmjs.com/package/convex-batch-processor Directory: https://www.convex.dev/components/convex-batch-processor

Description: Two patterns: batch accumulator (collects items, flushes on size/time thresholds) and table iterator (processes large datasets in chunks with pause/resume). Built-in retries and progress tracking.

How It Works: Accumulator: buffers items in memory, flushes when size or time threshold reached. Iterator: process table in chunks with automatic resumption. Progress stored in database. Retry logic with backoff.

Install Command: 

npm install convex-batch-processor

Use Cases: - Batch email sending (accumulate, then flush) - Bulk import processing - Large table migrations - Event aggregation and processing

6. Quick Convex

npm: @danthegoodman/quick-convex Version: 0.1.5 Weekly Downloads: 7 Author: danthegoodman1 Licence: Apache-2.0 GitHub: https://github.com/danthegoodman1/quick-convex npm URL: https://www.npmjs.com/package/@danthegoodman/quick-convex Directory: https://www.convex.dev/components/quick-convex

Description: Implementation of Apple's QuiCK paper. FIFO and priority queue processing with retries and concurrent execution. Supports priority levels 0-15, batch enqueue, configurable backoff strategies.

How It Works: Priority queue (0=highest, 15=lowest). FIFO ordering within priority. Batch enqueue for bulk operations. Worker processes with configurable concurrency. Automatic retries with jitter.

Install Command: 

npm install @danthegoodman/quick-convex

Use Cases: - Multi-priority job queues - Emergency alert processing (high priority) - Background cleanup (low priority) - Fair task scheduling

Integrations components

1. Resend

npm: @convex-dev/resend Version: 0.2.3 Weekly Downloads: 33,353 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/resend npm URL: https://www.npmjs.com/package/@convex-dev/resend Directory: https://www.convex.dev/components/resend

Description: Official Resend email integration with queuing, batching, rate limiting, guaranteed delivery. Uses workpools for durable execution. Webhook handler for delivery tracking (bounces, opens, clicks, spam). React Email support for JSX templates.

How It Works: Queue emails via actions. Workpool processes queue with rate limiting. Webhook handler syncs delivery events. React Email components for template building. Status queries for client-side UI.

Install Command: 

npm install @convex-dev/resend

Use Cases: - Transactional email (password reset, order confirmation) - Marketing email campaigns - Delivery tracking and open rates - Bounce and compliance management

2. Cloudflare R2

npm: @convex-dev/r2 Version: 0.9.1 Weekly Downloads: 14,944 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/r2 npm URL: https://www.npmjs.com/package/@convex-dev/r2 Directory: https://www.convex.dev/components/r2

Description: File storage and serving with Cloudflare R2. Signed URL uploads, metadata sync, React/Svelte hooks. Supports multiple buckets, custom object keys, server-side storage from actions.

How It Works: Presigned upload URLs for direct browser uploads. Download with CloudFront CDN URLs (optional signing). Metadata stored in Convex. Component syncs with R2 to avoid metadata drift.

Install Command: 

npm install @convex-dev/r2

Use Cases: - User file uploads (avatars, documents) - Large media distribution via CDN - Video file hosting - Archive storage with lifecycle policies

3. Expo Push Notifications

npm: @convex-dev/expo-push-notifications Version: 0.3.1 Weekly Downloads: 5,910 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/expo-push-notifications npm URL: https://www.npmjs.com/package/@convex-dev/expo-push-notifications Directory: https://www.convex.dev/components/expo-push-notifications

Description: Mobile push notifications via Expo API with batching, exponential backoff retry, delivery tracking. Token registration, pause states, workpool-based parallel processing.

How It Works: Register device tokens. Queue push notifications. Workpool processes with parallel rate limiting. Automatic retries on transient failures. Delivery tracking and bounce handling.

Install Command: 

npm install @convex-dev/expo-push-notifications

Use Cases: - Mobile app push notifications - Real-time alerts to users - Engagement campaigns - Multi-device notification routing

4. Twilio SMS

npm: @convex-dev/twilio Version: 0.2.1 Weekly Downloads: 2,042 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/twilio npm URL: https://www.npmjs.com/package/@convex-dev/twilio Directory: https://www.convex.dev/components/twilio

Description: Send/receive SMS via Twilio. Webhook handlers for incoming messages and status updates. Auto-stores messages in database. Query methods for message history.

How It Works: sendSms() queues messages for delivery. Webhook handler stores inbound messages. Status updates (delivery, read, failure) via webhooks. Query interface for message history and logs.

Install Command: 

npm install @convex-dev/twilio

Use Cases: - Two-factor authentication SMS - Alert notifications - SMS chatbot backend - Customer communication channel

5. Loops

npm: @devwithbobby/loops Version: 0.2.0 Weekly Downloads: 406 Author: robertalv (devwithbobby) Licence: (varies) GitHub: https://github.com/devwithbobby/loops npm URL: https://www.npmjs.com/package/@devwithbobby/loops Directory: https://www.convex.dev/components/loops

Description: Integrate with Loops.so email marketing. Send transactional emails, manage contacts, trigger loops. Built-in monitoring, spam detection, rate limiting. Full TypeScript support.

How It Works: Send transactional emails via sendEmail(). Contact management with sync. Trigger automation loops. Webhook validation for security. Rate limiting per contact.

Install Command: 

npm install @devwithbobby/loops

Use Cases: - Email marketing automation - Transactional emails from Loops - Contact list management - Campaign triggering

6. LaunchDarkly Feature Flags

npm: @convex-dev/launchdarkly Version: 0.4.0 Weekly Downloads: 365 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/launchdarkly npm URL: https://www.npmjs.com/package/@convex-dev/launchdarkly Directory: https://www.convex.dev/components/launchdarkly

Description: Sync LaunchDarkly feature flags to Convex via webhooks. Server-side flag evaluation without external API calls. Supports multiple environments, A/B testing, gradual rollouts.

How It Works: Webhook syncs flag state to Convex database. Local flag evaluation without network latency. User targeting via context attributes. Real-time updates via websockets.

Install Command: 

npm install @convex-dev/launchdarkly

Use Cases: - Feature flagging without latency - A/B testing and gradual rollouts - Environment-specific feature control - Dynamic feature configuration

7. Bright Data Datasets

npm: (by sholajegede) Version: varies Weekly Downloads: 342 Author: sholajegede Licence: (varies) Directory: https://www.convex.dev/components/bright-data-datasets

Description: Trigger Bright Data dataset collections (LinkedIn, Amazon, job listings), receive results via webhook, store structured records. Real-time subscriptions via useQuery.

How It Works: Trigger dataset collection via action. Webhook receives results. Store in Convex tables. Reactive queries on results. Integration with web scraping workflows.

Install Command: 

npm install bright-data-datasets

Use Cases: - LinkedIn data scraping - Amazon product monitoring - Job listing aggregation - Competitive intelligence

8. Convex Bunny

npm: convex-bunny Version: 0.1.2 Weekly Downloads: 282 Author: lipaonline Licence: MIT GitHub: https://github.com/lipaonline/convex-bunny npm URL: https://www.npmjs.com/package/convex-bunny Directory: https://www.convex.dev/components/convex-bunny

Description: Upload files to Bunny.net CDN from Convex actions. Automatic metadata tracking, multi-region support (DE, NY, LA, SG, SYD, BR, JH). CDN URL generation.

How It Works: Upload files to Bunny.net via action. Region selection for geo-distribution. Automatic metadata (size, MIME type) tracking. CDN URLs for content delivery.

Install Command: 

npm install convex-bunny

Use Cases: - Global CDN distribution - User-generated content hosting - Video and image storage - Cost-effective file hosting

9. Bright Data (Cache)

npm: (by sholajegede) Version: varies Weekly Downloads: 270 Author: sholajegede Licence: (varies) Directory: https://www.convex.dev/components/bright-data-cache

Description: Cache Bright Data SERP API and Web Unlocker results with configurable TTLs and reactive queries. Supports search verticals (news, shopping, images) and recency filtering.

How It Works: Wrapper around Bright Data APIs with caching. Query caching by URL and parameters. Configurable TTL per query type. Superset matching for efficient cache hits.

Install Command: 

npm install bright-data-cache

Use Cases: - Search result caching - Web scraping with cache - SERP tracking over time - Cost reduction for repetitive queries

10. Brevo

npm: (by pierre-H) Version: varies Weekly Downloads: 226 Author: pierre-H Licence: (varies) Directory: https://www.convex.dev/components/brevo

Description: Durable transactional email and SMS via Brevo API. Wraps /v3/smtp/email and /v3/transactionalSMS/send with rate limiting, webhook status tracking, cancellation.

How It Works: Queue emails/SMS via actions. Automatic retry with backoff. Webhook handler tracks delivery. Rate limiting per contact. Cancellation support for unsent messages.

Install Command: 

npm install brevo

Use Cases: - Transactional email delivery - SMS alerts and notifications - Multi-channel communication - Delivery tracking

11. Static Hosting

npm: @convex-dev/static-hosting Version: varies Weekly Downloads: 214 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/static-hosting npm URL: https://www.npmjs.com/package/@convex-dev/static-hosting Directory: https://www.convex.dev/components/static-hosting

Description: Host static React/Vite apps from Convex HTTP actions and file storage. SPA fallback, smart caching for hashed assets, garbage collection of old deployments. Deploy via CLI.

How It Works: CLI uploads static assets to Convex file storage. HTTP action serves files with SPA fallback. Hashed assets get long cache headers. Garbage collection removes old deployments.

Install Command: 

npm install @convex-dev/static-hosting

Use Cases: - Host frontend SPA from Convex backend - Zero-downtime deployments - A/B testing via URL routing - Self-contained full-stack apps

12. Convex YouTube Cache

npm: (by TimpiaAI) Version: varies Weekly Downloads: 161 Author: TimpiaAI Licence: (varies) Directory: https://www.convex.dev/components/convex-youtube-cache

Description: YouTube video metadata caching with rate limiting, TTL, reservation system, batch lookups. Stale-while-revalidate pattern. Quota management and cache statistics.

How It Works: Cache YouTube metadata (title, description, duration, thumbnail). Batch lookups for efficiency. Stale-while-revalidate for availability. Quota management to prevent API limits.

Install Command: 

npm install convex-youtube-cache

Use Cases: - YouTube video metadata caching - Batch video lookups - Quota-aware API usage - Video library building

13. Convex Inbound

npm: @hamzasaleemorg/convex-inbound Version: 0.1.4 Weekly Downloads: 15 Author: hamzasaleem2 Licence: (varies) GitHub: https://github.com/hamzasaleem2/convex-inbound npm URL: https://www.npmjs.com/package/@hamzasaleemorg/convex-inbound Directory: https://www.convex.dev/components/convex-inbound

Description: Production-ready email sending/receiving with automatic retries, threading, rate limiting. Uses Convex Workpool for durable delivery. Idempotency protection.

How It Works: Queue emails with automatic retry. Inbound webhook handler for received email. Thread grouping by subject/conversation ID. Rate limiting per recipient. Idempotency via message IDs.

Install Command: 

npm install @hamzasaleemorg/convex-inbound

Use Cases: - Email communication layer - Transactional and marketing email - Email-to-app workflows - Support ticket creation from email

Payments components

1. Stripe

npm: @convex-dev/stripe Version: 0.1.3 Weekly Downloads: 10,876 Author: get-convex Licence: Apache-2.0 GitHub: https://github.com/get-convex/stripe npm URL: https://www.npmjs.com/package/@convex-dev/stripe Directory: https://www.convex.dev/components/stripe

Description: Complete Stripe integration: checkout sessions, subscription management, billing portals, webhook synchronisation. Auto-creates/manages customers. Syncs to dedicated Convex tables. 10+ webhook events handled.

How It Works: Webhook handler syncs Stripe events (customer.created, charge.succeeded, invoice.created, etc.). Creates Convex records for customers and subscriptions. Provides helper functions for checkout and billing portal links.

Install Command: 

npm install @convex-dev/stripe

Use Cases: - SaaS subscription billing - One-time payment processing - Billing portal for customers - Invoice tracking and collection

2. Autumn

npm: @useautumn/convex Version: 0.0.23 Weekly Downloads: 5,038 Author: useautumn Licence: Apache-2.0 GitHub: https://github.com/useautumn/autumn npm URL: https://www.npmjs.com/package/@useautumn/convex Directory: https://www.convex.dev/components/autumn

Description: Abstracts Stripe billing with three functions: check (feature access), track (usage metering), checkout (purchases). Handles subscriptions, usage-based, seat-based, trials, credits. React components and hooks.

How It Works: Define plans and pricing in Autumn dashboard. Check feature access via check(). Track metered usage via track(). Generate checkout links via checkout(). React components for subscription UI.

Install Command: 

npm install @useautumn/convex

Use Cases: - Usage-based billing (pay-as-you-go) - Seat-based SaaS pricing - Trial management - Credit-based systems

3. Polar

npm: @convex-dev/polar Version: 0.8.1 Weekly Downloads: 2,145 Author: erquhart Licence: (varies) GitHub: https://github.com/erquhart/convex-polar npm URL: https://www.npmjs.com/package/@convex-dev/polar Directory: https://www.convex.dev/components/polar

Description: Polar subscriptions and billing with webhook sync and React UI (CheckoutLink, CustomerPortalLink). All price types: fixed, custom, seat-based, metered. Product configuration via static mapping or dynamic listing.

How It Works: Polar provides checkout and customer portal links. Webhook handler syncs subscription state. React components for checkout and portal embedding.

Install Command: 

npm install @convex-dev/polar

Use Cases: - Flexible pricing models - Subscription and one-time billing - Metered/usage pricing - Creator economy payments

4. RevenueCat

npm: convex-revenuecat Version: 0.1.10 Weekly Downloads: 463 Author: ramonclaudio Licence: (varies) GitHub: https://github.com/ramonclaudio/convex-revenuecat npm URL: https://www.npmjs.com/package/convex-revenuecat Directory: https://www.convex.dev/components/revenuecat

Description: Process RevenueCat webhooks to maintain subscription state. Syncs all 18 webhook events. Real-time entitlement checking. Handles cancellations, grace periods, lifetime purchases correctly.

How It Works: Webhook handler processes RevenueCat events. Maintains subscription state in Convex. checkEntitlement() for feature gating. Handles complex states (grace period, cancelled-to-reactivated).

Install Command: 

npm install convex-revenuecat

Use Cases: - Mobile app subscription management - Entitlement checking - Grace period handling - Trial management

5. Dodo Payments

npm: @dodopayments/convex Version: 0.2.8 Weekly Downloads: 355 Author: dodopayments Licence: (varies) GitHub: https://github.com/dodopayments/convex npm URL: https://www.npmjs.com/package/@dodopayments/convex Directory: https://www.convex.dev/components/dodo-payments

Description: Billing and payment processing for AI and SaaS. Checkout sessions, customer portals, webhook handling. Maps Convex users to payment customers via identify function.

How It Works: Map Convex users to Dodo customers. Generate checkout sessions. Webhook handler syncs payment events. Customer portal for self-service management.

Install Command: 

npm install @dodopayments/convex

Use Cases: - AI SaaS billing - Usage-based pricing - Customer self-service portals - Payment processing

6. Creem

npm: @mmailaender/convex-creem Version: 0.2.0 Weekly Downloads: 130 Author: mmailaender Licence: Apache-2.0 GitHub: https://github.com/mmailaender/convex-creem npm URL: https://www.npmjs.com/package/@mmailaender/convex-creem Directory: https://www.convex.dev/components/creem

Description: Drop-in billing via Creem service: subscriptions, one-time purchases, seat-based pricing. React/Svelte UI widgets for checkout, plan switching, customer portals. User and organisation-level billing support.

How It Works: Creem provides UI components (checkout, portal, plan switcher). Webhook handler syncs subscription state. Support for user and organisation billing.

Install Command: 

npm install @mmailaender/convex-creem

Use Cases: - Flexible billing UI - Multi-tier subscriptions - Seat-based SaaS pricing - Frictionless checkouts

7. Kinde Billing

npm: convex-kinde-billing Version: 0.1.11 Weekly Downloads: 7 Author: sholajegede Licence: (varies) GitHub: https://github.com/sholajegede/convex-kinde-billing npm URL: https://www.npmjs.com/package/convex-kinde-billing Directory: https://www.convex.dev/components/kinde-billing

Description: Reactive Kinde billing integration with webhook handling, subscription state, feature gating. Functions: hasActivePlan(), hasFeature(), getCheckoutUrl(), getPortalUrl().

How It Works: Webhook handler syncs Kinde subscription events. Reactive queries on subscription state. Helper functions for feature gating and URL generation.

Install Command: 

npm install convex-kinde-billing

Use Cases: - Kinde billing integration - Feature access control - Subscription status checking - Checkout and portal URLs

Finding and using components

Component discovery

Browse all components at https://www.convex.dev/components

Each component provides: - llms.txt endpoint: https://www.convex.dev/components/{slug}/llms.txt: machine-readable API reference - Markdown documentation: https://www.convex.dev/components/{slug}/{name}.md - npm package: Install via npm install

Installation workflow

  1. Find component on the directory
  2. Install via npm: npm install @convex-dev/component-name
  3. Add to convex/convex.config.ts: Call app.use(component)
  4. Deploy: npx convex push
  5. Use in functions: Import helpers and call from queries/mutations/actions

Key principles

  • Sandboxed storage: Each component manages its own tables; no collision with app schema
  • Reactive data: All component data queryable via standard Convex mechanisms
  • Type-safe: Full TypeScript support; import types from component packages
  • Zero-overhead: Components compile to standard Convex functions; no extra indirection
  • Community & official: Mix get-convex official components with community contributions

Keeping up to date

  • Components receive updates independent of Convex core
  • Review changelogs on npm before upgrading
  • Use npm outdated to find upgradeable packages
  • Test upgrades in development branch before production deployment

References

  • Convex documentation: https://docs.convex.dev
  • Components directory: https://www.convex.dev/components
  • Components registry (machine-readable): https://www.convex.dev/components/components.md
  • Per-component llms.txt: https://www.convex.dev/components/{slug}/llms.txt
  • GitHub (first-party): https://github.com/get-convex
  • convex-helpers library: https://www.npmjs.com/package/convex-helpers
  • Local agent guidelines (read first when writing Convex code): convex/_generated/ai/guidelines.md
  • Community: Discord, GitHub Discussions, Twitter

This document is a reference companion to 02-system-architecture.md and 04-data-model.md. Capabilities, components, and download counts were accurate as of the snapshot dates in the Revision history; consult docs.convex.dev and convex.dev/components for current information.

Revision history

Version Date Author Notes
1.0.0 2026-04-16 andrew Initial consolidated reference. Merges the Convex Capability Statement (archive/old-numbering/43a-convex-capability-statement-v01.md, snapshot 2026-04-01) and the Convex Component Directory (archive/old-numbering/48-convex-component-directory-v01.md, snapshot 2026-04-03). Replaced Keycloak as the default auth example with Clerk to match Thinklio's auth stack. Cross-references retargeted from old numbering (04, 13, 14, 43, 44, 55) to the new consolidated documents (02, 04, 12). Supersedes old docs 43a and 48.