Snapify

Snapify is an open-source screen recording and video sharing platform that lets anyone record their screen, browser tab, or any application and share the result via a public link. Viewers need no account to watch, which removes friction for support tickets, async code reviews, and internal walkthroughs. Recordings can be set to auto-delete or become unlisted after a configurable time window, giving teams fine-grained control over how long content stays accessible.

The platform is built with Next.js, tRPC, Prisma, and PostgreSQL, and ships a full Stripe billing integration alongside an optional free tier. Video files are stored in any AWS S3-compatible endpoint — Backblaze B2 is the documented default — while Upstash Redis handles server-side rate limiting so the free tier can be enforced without a heavy infrastructure footprint. Deployment targets include Vercel and Docker; the included Dockerfile produces a multi-stage, production-ready Node.js image.

Authentication is handled via NextAuth with GitHub and Google OAuth providers, and PostHog analytics are wired into every significant user action for product telemetry. The paywall component is context-aware: it fires differently depending on whether the user was recording or uploading, enabling conversion experiments without changes to core recording logic. Playwright end-to-end tests cover the full user journey from landing through billing and video management.

Self-hosters get complete data ownership — videos live in their own S3 bucket, user data stays in their own Postgres instance, and there are no telemetry or licensing callbacks to external services unless PostHog and Stripe keys are explicitly configured. The AGPL-3.0 license means any modifications to the server must be shared back under the same terms.

What You Get

• Browser-native screen recording - Capture full screen, browser tab, or any application window directly in Chrome without installing a desktop app, with audio from both the screen and a selected microphone device.
• Instant shareable links - Every recording gets a public URL that recipients can watch immediately without logging in, with optional OG image thumbnails for rich link previews in Slack or email.
• Time-limited video expiry - Set recordings to auto-delete from storage or become unlisted after a configurable period, giving teams control over data retention without manual cleanup.
• External video upload - Upload pre-recorded video files and share them through the same public-link system, extending the platform beyond live screen capture.
• Stripe billing and free-tier enforcement - Built-in subscription management with monthly and annual plans, context-aware paywalls, and Upstash Redis rate limiting to enforce upload limits on the free tier.
• S3-compatible storage backend - Store all video and thumbnail assets in any AWS S3-compatible service, with Backblaze B2 documented as the default, using presigned URLs so files are never exposed publicly without authorization.
• Self-hosting with Docker or Vercel - Ship to your own infrastructure using the included multi-stage Dockerfile or deploy to Vercel in one click; all secrets are environment-variable driven with no hard-coded assumptions.
• PostHog analytics integration - Capture granular product events across the full user journey, from opening the record modal to hitting a paywall, enabling data-driven decisions about the free-to-paid conversion funnel.

Common Use Cases

• Async code review walkthroughs - Engineers record themselves walking through a pull request or debugging session and share the link in GitHub comments, letting reviewers understand context without a calendar invite.
• Customer support resolution videos - Support agents record step-by-step solutions to reported issues and paste the public link into a ticket, reducing back-and-forth and enabling customers to follow along at their own pace.
• Internal tool onboarding - Team leads record short walkthroughs of internal dashboards, admin panels, or deployment processes and share them with new hires via a permanent link in Notion or Confluence.
• Design and QA feedback - Designers and QA engineers record visual bugs or UI feedback and send the recording directly to developers, capturing the exact sequence of clicks that triggered an issue.
• Remote team status updates - Distributed teams replace synchronous standup calls with short recorded updates, shareable to a Slack channel without requiring everyone to be online at the same time.

Under The Hood

Architecture Snapify uses Next.js Pages Router with a clear boundary between client components and a server layer organized under a dedicated server directory. tRPC provides end-to-end type safety from database query to React hook, eliminating a class of runtime type errors that plague REST APIs. Jotai atoms manage lightweight UI state — whether the record modal is open, whether the paywall should render — while React Query (via tRPC) handles all server state and cache invalidation. The paywall is implemented as a standalone component that receives its trigger context through Jotai atoms, so billing logic never leaks into recording or upload flows. Presigned S3 URLs are generated server-side and handed to the client, keeping AWS credentials entirely out of the browser.

Tech Stack The application is built on Next.js 13 with TypeScript throughout and Prisma as the ORM targeting PostgreSQL. tRPC v10 connects client and server with shared type definitions, while NextAuth v4 handles OAuth sessions via GitHub and Google providers, persisting sessions in Postgres through the Prisma adapter. Video storage uses the AWS SDK v3 with S3-compatible endpoints, and presigned URLs are generated with the s3-request-presigner package. RecordRTC captures media streams in the browser, ts-ebml post-processes the resulting WebM container to make it seekable, and VidStack renders the final player. Stripe v12 powers subscriptions with webhook processing, Upstash Redis enforces rate limits, and Upstash QStash handles async tasks such as deleting expired videos. PostHog tracks product telemetry; Playwright runs end-to-end tests against a real database seed.

Code Quality Playwright end-to-end tests cover landing page flows, billing interactions, video upload, and individual video page behavior across a seeded database, giving the project meaningful regression coverage for its most critical user journeys. TypeScript is used comprehensively across all layers, including custom module augmentation for NextAuth session types and typed tRPC router inference helpers. Error handling is explicit in the Recorder component, catching UNAUTHORIZED and upload-limit tRPC errors separately and routing each to the appropriate UI response — paywall or OAuth popup — rather than displaying a generic message. Inline code comments are sparse, and there is no dedicated documentation directory beyond the README and CONTRIBUTING guide. ESLint and Prettier are configured with tailwind class sorting, and the typecheck script validates the full TypeScript compilation independently of the build.

What Makes It Unique The most distinctive design choice is the seekable WebM fix: after RecordRTC produces a recording, the application reads the raw container with ts-ebml, rewrites the metadata block to include accurate cue points and duration, and reassembles the file into a new Blob before upload. This makes browser-recorded video files properly seekable in any player without a server-side transcoding step. The paywall is also unusually context-sensitive — the Jotai atom that opens it carries the originating action, so the upgrade prompt can present different messaging and conversion paths depending on whether the user hit the limit while recording or uploading. Combined with PostHog feature flags gating experimental UI elements, this gives operators a lightweight A/B testing capability without a separate experimentation platform.

Self-Hosting

Snapify is licensed under the GNU Affero General Public License version 3 (AGPL-3.0). This is a strong copyleft license with a network-use provision: if you modify Snapify and run it as a service — even without distributing binaries — you must make your modified source code available to users of that service under the same license. For internal corporate deployments where no external users access the instance, the practical impact is lower, but any public-facing fork must publish its changes. There is no commercial exception or enterprise license variant available from the author.

Running Snapify yourself requires a PostgreSQL database, an S3-compatible object storage bucket, GitHub or Google OAuth credentials, and a Node.js environment or Docker runtime. Stripe and Upstash Redis are optional but necessary if you want the subscription tier and rate-limiting features. The provided Dockerfile handles the application layer cleanly, but you are responsible for provisioning, backing up, and scaling the database and storage independently. The codebase has no built-in backup or disaster-recovery tooling, so operational maturity depends entirely on what you bring to the infrastructure layer. Upstash Redis is referenced as a managed external service rather than a self-hosted component, adding a runtime dependency on a third-party SaaS unless you swap in a compatible alternative.

There is no official hosted or managed tier from the author, which means you also give up any formal support channel, guaranteed uptime SLA, or managed upgrade path. The last commit was in November 2024 and commit activity has been low for over a year, so community-maintained patches and security updates are unlikely to arrive quickly. Self-hosters should factor in the cost of monitoring the upstream repository for security advisories, applying patches, and maintaining the deployment as Node.js and dependency versions age. For teams that want a Loom alternative without operational overhead, a commercial SaaS product may offer a more durable path despite the loss of data sovereignty.