Hoppscotch

Hoppscotch is a comprehensive open-source API development platform that rivals Postman in features while remaining fast, lightweight, and accessible from any browser without installation. Built as a Progressive Web App, it works offline and can be pinned to the home screen on any device, making it practical for developers who move between environments.

The platform spans every major API protocol: REST, GraphQL with schema introspection, WebSocket for real-time channels, Server-Sent Events for streaming, Socket.IO, and MQTT for IoT messaging. This breadth means a single tool handles the full spectrum of modern API testing without switching clients or paying for separate integrations.

Hoppscotch ships with a standalone CLI for embedding API tests into CI/CD pipelines, a native desktop app built on Tauri for platforms that need deeper system access, and a self-hostable backend that enables team workspaces, shared collections, role-based access, real-time sync, and an admin dashboard — all features typically locked behind enterprise pricing in competing tools.

The architecture is a TypeScript monorepo spanning twelve packages: a NestJS/GraphQL backend, a Vue 3 frontend core, a Rust-based HTTP relay for advanced request handling, a sandboxed JavaScript engine for pre/post-request scripting, and platform-specific kernels that abstract IO, storage, and networking differences between web and desktop deployments.

What You Get

• REST API client supporting all HTTP methods, custom headers, request body types (JSON, FormData, raw), and OAuth 2.0 / Bearer / Basic auth
• GraphQL client with schema introspection, multi-column documentation browser, query builder, and subscription support
• Real-time protocol support: WebSocket, Server-Sent Events, Socket.IO, and MQTT — each with dedicated UI panels
• Pre-request and post-request JavaScript scripting with a sandboxed VM for setting environment variables and asserting response values
• Collections and nested folders for organizing requests, with import/export to Postman/OpenAPI formats and GitHub Gists
• Environment variables system with unlimited environments for switching between dev, staging, and production endpoints
• CLI tool for running Hoppscotch collections in CI pipelines with exit codes and structured output
• Self-hostable backend with team workspaces, role-based access control, SSO (Enterprise Edition), and an admin dashboard for user and team management

Common Use Cases

• Rapid API exploration — developers testing a new third-party API send requests directly in the browser without installing anything, using the hosted PWA or the desktop app
• GraphQL development — frontend engineers introspect schemas, browse auto-generated documentation, and run queries against local dev servers from a single integrated interface
• Real-time protocol debugging — backend developers working on WebSocket or MQTT services connect, subscribe to topics, and inspect message streams in a dedicated panel
• CI/CD API testing — QA teams script pre/post-request assertions and run collections via the Hoppscotch CLI in GitHub Actions to catch regressions before deployment
• Team API documentation — engineering teams self-host Hoppscotch to share request collections and environments across the organization without relying on a paid SaaS
• Environment-aware request management — developers maintain separate environment files for local, staging, and production and switch between them with a single click

Under The Hood

Architecture Hoppscotch is organized as a twelve-package TypeScript monorepo that separates concerns into distinct, purpose-built layers. The frontend runs on a Vue 3 application defined in the common package, where a platform abstraction layer — called the kernel — decouples IO, relay, storage, and logging from the host environment, allowing the same Vue component tree to run identically in a browser PWA and a Tauri desktop application by swapping kernel implementations at boot time. A dependency-injection container built on the dioc library coordinates service initialization, and Pinia stores manage shared reactive state. The backend is a NestJS application organized into domain modules (users, teams, collections, environments, shortcodes, infra config), exposing a unified GraphQL API for the frontend alongside REST health endpoints; domain events are fanned out through a Redis-backed PubSub layer to power real-time GraphQL subscriptions across connected clients.

Tech Stack The frontend is built with Vue 3, TypeScript, Vite, Tailwind CSS, and vue-router, using VueUse for composable utilities and URQL for GraphQL client communication. The backend runs on NestJS 11 with the Apollo driver, connected to PostgreSQL through Prisma 7 and using Redis for pub/sub. Authentication covers GitHub, Google, Microsoft, email/password, and SAML SSO (Enterprise Edition), handled through Passport.js strategies with JWT session tokens. The Hoppscotch Relay package is written in Rust using curl-rust (with NTLM support) and compiled to a native binary bundled inside the Tauri desktop app, bypassing browser CORS restrictions and enabling mutual TLS, proxy configuration, and local certificate handling. The CLI is a Node.js binary using Commander, with isolated-vm providing the JavaScript sandbox for scripting.

Code Quality The backend carries extensive test coverage using Jest and jest-mock-extended for deep-mocking Prisma and external services; service-layer unit tests are thorough and cover error paths through fp-ts Either/Option types rather than throwing exceptions, making failure modes explicit in function signatures. The frontend has broad test infrastructure in place across packages using Vitest. The codebase enforces TypeScript strict mode throughout, uses ESLint with Vue-specific rules, and commitlint with conventional commits to gate PRs. The fp-ts functional programming pattern used in the backend, while unusual in a NestJS context, ensures that error handling is typed and composable rather than relying on try/catch chains — a deliberate architectural choice that improves reliability at the cost of a steeper learning curve for contributors unfamiliar with functional patterns.

What Makes It Unique Hoppscotch’s most distinctive technical decision is the kernel abstraction, which provides a versioned API surface for IO, relay, store, and logging that can be fulfilled by different implementations depending on the runtime environment. This design allows a single Vue application to operate as a browser PWA, a desktop application, or a self-hosted web app without conditional platform checks scattered through component code. The inclusion of a Rust-based HTTP relay that handles NTLM authentication, client certificates, and advanced proxy scenarios — capabilities that browser-based tools fundamentally cannot offer — extends the tool from a web curiosity into a genuine desktop-class client. The combination of MIT-licensed self-hostable backend, FOSS CLI runner, multi-protocol support, and real-time team sync in a single open-source package is unusual in the API tooling space.

Self-Hosting

Hoppscotch is released under the MIT License, one of the most permissive open-source licenses available. This means you are free to use it commercially, modify it, distribute it, and build proprietary products on top of it without any copyleft obligation to release your changes. There are no user limits, no request caps, and no telemetry required in the self-hosted version. The only exception is that a small set of features — notably SSO/SAML authentication — are labeled Enterprise Edition and require a commercial license from Hoppscotch, though the vast majority of functionality, including team workspaces, collections, role-based access, and the admin dashboard, is available under the open-source tier.

Self-hosting Hoppscotch requires running three primary services: a NestJS backend, a Vue-based frontend application, and a PostgreSQL database — all documented with a Docker Compose file that also supports profile-based deployment for running individual components separately. Redis is needed for real-time GraphQL subscriptions if team collaboration features are used. You are responsible for database backups, TLS termination (example Caddyfile configurations are provided), environment variable management, and applying version upgrades by pulling new Docker images. The project ships a separate all-in-one Docker image for simpler single-node deployments, which reduces operational complexity considerably for teams that don’t need high availability.

Compared to Hoppscotch’s cloud offering, a self-hosted instance gives you full data residency and the ability to connect to internal network services that are unreachable from the public internet, but you trade away managed upgrades, hosted infrastructure, uptime SLAs, priority support, and enterprise SSO out of the box. The cloud tier also includes SAML SSO and audit logging features that require the Enterprise Edition license when running on-premises. For teams that simply want to share collections and collaborate on API requests without handling infrastructure, the hosted version at hoppscotch.io is available on a free tier, making the self-hosted path most valuable for organizations with strict data governance or air-gapped deployment requirements.