Let clients edit the copy.
Not the website or code.

Mark approved copy in React. Clients click directly on the live page, type, and save without touching your codebase or layout.

$ pnpm add @copypatch/react
< 1 kB Visitor bundle (gzip)
SQLite + WAL Self-hosted data
Argon2id Enterprise auth
100% Plain Text Zero XSS surface
https://app.com?copypatch=1
Click outlined copy to edit
Lightweight & Open-Source

Build something people actually use.

Let clients edit approved website copy inline on the live site without touching code or layout.

Zero Layout Shift

Only plain text strings are updated. Styles and DOM structure stay intact.

SQLite Persistence

Single-file local database with in-memory snapshot cache for fast reads.

Argon2id Auth

Cryptographically secure sessions with HttpOnly cookies and CSRF checks.

Inline editing in three simple steps

No external SaaS dashboards, no content modeling schema, and no accidental layout corruption.

src/App.tsx Developer Experience
App.tsx
<EditableText contentKey="hero.title" as="h1">
  Build something people actually use.
</EditableText>

Designed for developers who value clean code

Integrates directly into existing React and Next.js applications in under two minutes.

src/App.tsx
import React from 'react';
import { CopyPatchProvider, EditableText } from '@copypatch/react';

export function LandingPage() {
  return (
    <CopyPatchProvider locale="en">
      <header>
        <EditableText contentKey="nav.brand" as="span">
          Acme Studio
        </EditableText>
      </header>

      <main>
        <EditableText contentKey="hero.title" as="h1">
          Crafting software for product-focused teams.
        </EditableText>
        
        <EditableText contentKey="hero.subtitle" as="p" allowLineBreaks={true}>
          Fast, accessible, and self-hosted inline copy editing for modern React teams.
        </EditableText>
      </main>
    </CopyPatchProvider>
  );
}

Why not just use a traditional CMS?

Headless CMSs and page builders solve large content modeling problems. CopyPatch solves a focused one: letting clients fix copy without breaking the app.

Feature CopyPatch Traditional Headless CMS Visual Page Builder
Editing Experience Inline on real website (?copypatch=1) Separate administrative dashboard Complex drag-and-drop canvas
Code & Layout Ownership 100% developer React code & CSS API data binding with rigid schemas Proprietary exported markup
Visitor Runtime Cost < 1 kB gzip (zero overhead) Varies by SDK (10-50 kB) 150-500+ kB bloated scripts
Content Security Strict plain-text invariant (XSS immune) Stored HTML / Markdown risk Arbitrary script injection risks
Data Sovereignty Self-hosted SQLite file on your server Third-party SaaS lock-in / API quotas Vendor-hosted platform
Pricing 100% Free & MIT Open-Source Monthly tier per user / seat Monthly subscription per domain

Engineered for sub-millisecond efficiency

Zero polling, zero WebSockets, and zero per-element network requests. One cached locale snapshot powers the entire page.

Read & Cache Pipeline

< 0.5 ms
01
Public Visitor Request HTTP / 304
Browser requests the standard URL with If-None-Match ETag check.
02
In-Memory Snapshot Map Map<string, string>
hero.title "Let clients edit..."
hero.subtitle "Mark approved copy..."
footer.copy "© 2026 CopyPatch"
03
SQLite WAL Persistence copypatch.db
Zero external DB server. Atomic revision increment upon writes.
01

Zero Per-Element Overhead

Every <EditableText> reads instantly from a shared in-memory React store without firing separate network queries.

02

Atomic Server Cache

The embedded server maintains an immutable memory cache rebuilt atomically upon writes for < 1 ms read responses.

03

Lazy Editor Isolation

Public visitors load < 1 kB of runtime. Editing toolbars, auth modals, and form hooks load exclusively when ?copypatch=1 is requested.

Zero-compromise self-hosted security

CopyPatch sends zero data to external servers. It runs in your own infrastructure with strict enterprise security invariants.

INVARIANT 01

Strict Plain-Text Invariant

Only plain strings are accepted and persisted. HTML, JSX, script tags, and markdown are strictly rejected, making stored XSS mathematically impossible.

assert(typeof text === 'string')
INVARIANT 02

Argon2id Passphrase Hashing

Administrative passphrases are hashed using state-of-the-art Argon2id with 19 MiB memory cost and 2 iterations to resist GPU-based brute-force attacks.

argon2.hash(pwd, { type: argon2id, m: 19456 })
INVARIANT 03

256-Bit Cryptographic Sessions

Editor sessions use 256-bit entropy tokens stored exclusively in HttpOnly, SameSite=Strict, and Secure cookies inaccessible to client scripts.

Set-Cookie: __Host-cp_session; HttpOnly; SameSite=Strict
INVARIANT 04

Dual-Token CSRF & Origin Guard

Every mutating request requires a custom memory-held x-copypatch-csrf header and validates the HTTP Origin header against explicit server whitelists.

headers['x-copypatch-csrf'] === session.csrf

Independent copy snapshots per locale

CopyPatch organizes approved copy per language tag. It stores copy independently without imposing translation frameworks or automated magic.

How Locale Scoping Works

When a client edits copy under locale="tr", revisions and snapshots for Turkish are modified in isolation. English (en) and German (de) remain untouched until edited.

  • Independent Snapshots: Each locale maintains its own database snapshot and revision number.
  • Zero I18n Lock-In: Works alongside Next.js Internationalization, react-i18next, or custom state.
  • No Auto-Translation Bloat: You and your human editors maintain full editorial fidelity over every word.
Locale Integration
// Simply pass your active locale string to CopyPatchProvider
<CopyPatchProvider locale={currentLocale}>
  <EditableText contentKey="pricing.hero.title">
    Transparent pricing for growing teams.
  </EditableText>
</CopyPatchProvider>
EN "Transparent pricing for growing teams."
TR "Büyüyen ekipler için şeffaf fiyatlandırma."
DE "Transparente Preise für wachsende Teams."

100% Free. MIT Licensed. Zero Telemetry.

CopyPatch is free software built for developers who care about performance and ownership. Inspect the source, run it locally, deploy anywhere with Docker, and never worry about subscription fees or tracking.

Permissive MIT License

Use it for personal experiments, commercial projects, client websites, or internal enterprise applications without restrictions.

Zero Telemetry or Phone-Home

CopyPatch never collects usage data, IPs, or content metrics. Your data stays strictly on your SQLite volume.

Community & Contributions

Built with modern TypeScript, comprehensive Vitest unit tests, and Playwright end-to-end browser tests.

Your client needs to change a sentence.
They shouldn't need a developer deployment.

Install the lightweight React library today and give your clients inline editing superpower without sacrificing your application architecture.