This page is the customer-facing feature catalog. For tier gates and limits, see the pricing page. For workflow deep-dives, use the related guides linked at the bottom of each section.

HTTP client

Compose and send any HTTP request — every method, every body type, variable interpolation everywhere, and a cURL paste parser to skip manual setup.

GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD
URL bar with auto-send on Enter; method picker (Ctrl+M)
Paste cURL → auto-fill method, URL, headers, and body
Query params and headers with per-row enable/disable
{{variable}} interpolation in URL, headers, params, body, and auth
JSON, XML, YAML, HTML, JavaScript, plain text, multipart, form-urlencoded, GraphQL, SOAP, binary, and no-body modes
GraphQL schema introspection with explorer and query autocomplete
Form Data file picker; binary upload streamed from disk
Configurable timeout (1–300 s), follow-redirects cap, SSL toggle, proxy

Authentication

From simple Bearer tokens to OAuth/OIDC flows and mutual TLS — auth is configured per request or per collection with optional token auto-refresh.

No Auth, Basic Auth, Bearer Token, API Key (header or query)
Digest Auth (preemptive MD5)
OAuth 2.0 (authorization code, client credentials, password grant)
OpenID Connect (OIDC) with discovery and PKCE
AWS Signature V4, Hawk Authentication, NTLM Authentication
Mutual TLS (client certificate)
Per-collection OAuth/OIDC token auto-refresh

Response viewer

Inspect responses in the format that fits the payload — tree, graph, binary preview, or side-by-side diff against a saved example.

Status bar: code, text, time, byte size, timestamp
Preview / Headers / Console / Diff tabs
Raw, Tree, and Graph preview (interactive JSON graph with pan/zoom)
Binary preview for images, audio, video, PDF, fonts, archives, wasm, protobuf
Large-response truncation with “show full” toggle
In-response search with next/previous match (Ctrl+F)
Side-by-side diff vs. saved response
Global console panel for app-wide log aggregation
Export as standalone HTML snapshot; copy, download, copy as cURL
Generate code in fetch, axios, Python requests, C# HttpClient, cURL
Saved response examples per request

Tabs & workspace

Unlimited tabs with full per-tab state. Layout, panel sizes, and open tabs restore automatically when you restart the app.

Unlimited tabs — HTTP, WebSocket/SSE, and gRPC each keep separate state
Auto-save and restore on restart
Per-tab Markdown Docs editor with edit/preview toggle
Drag-to-resize panels; collapsible sidebars
Response panel toggle: bottom ↔ right
Tools panel with fullscreen mode
Unified search picker (Collections, History, response search)
Dark and light themes

Collections, requests & history

Organize requests in nested folders, scope variables and cookies per collection, and replay anything from history.

Nested hierarchical collections (folders inside folders)
Per-collection variables and cookie jar
Save method, URL, headers, params, body, auth, description, sort order
Reorder, move, rename, delete saved requests
Full request history with status, time, payload, and response
Load from history to rehydrate a tab; clear single or all
Extract JSON paths from responses into collection variables
Unresolved-variable warnings and variable count helpers

Environments & variables

Switch between named environments, mask secrets in the UI, and use dynamic generators like {{$uuid}} and {{$timestamp}}.

Named environments with switcher (Ctrl+E)
Global variables across all collections (Ctrl+Shift+Y)
Secret variables with masking in UI
Dynamic variables: {{$uuid}}, {{$timestamp}}, and 25+ generators
Precedence: globals → environment → collection
Postman environment import/export
Initial vs. current value tracking with reset

Import & export

Bring existing work from Postman, Insomnia, or OpenAPI specs — and export back out when you need to share or migrate.

Import Postman v2.1 collections and Insomnia v4 export bundles
Import OpenAPI 2.0 / Swagger and OpenAPI 3.x specs (Ctrl+Shift+O)
Import WSDL (.wsdl / .xml) — SOAP requests per operation
Import HAR files to request history
Re-import Ripple native exports
Export all or single collection to JSON
Export collection(s) to OpenAPI 3.0 (JSON or YAML) or Postman v2.1
Export response as standalone HTML snapshot

OpenAPI Design Studio

Design-first workflow: keep first-class OpenAPI documents locally, lint them, generate collections, launch mocks, and export specs — without a separate tool or cloud project.

First-class design documents stored locally in ripple.db
In-app spec editor (JSON or YAML) with document sidebar
Structural linting — Standard and Extended rule sets
Import and export spec files to disk
Generate collection from design doc; create design doc from collection
Start Mock — generate mock routes from spec and launch local server
Live preview: path tree, servers, tags, x-ripple-protocols
Spec versioning — automatic snapshots on save (up to 50)
Collection linking — associate a design doc with a collection
Richer export — infers JSON Schema from request/response bodies
Non-HTTP protocol export under x-ripple-protocols (gRPC, WebSocket, SSE, GraphQL)

Scripts & automation

Pre-request and test scripts with full async/await. Scripts execute in-session and expose a pm.* API for chaining, cookies, crypto, and assertions.

Scripts execute in-session; persistence to saved requests is not yet complete.

pm.sendRequest() — HTTP client for chaining requests within scripts
pm.cookies — cookie management with domain/path support
pm.utils — crypto utilities (base64, SHA1/256, MD5, UUID, random)
pm.variables, pm.globals, pm.collectionVariables
pm.test() and pm.expect() — test assertion framework
pm.console — logging with log/warn/error levels
Stream scripts for WebSocket/SSE (onMessage handlers)

Request chains

Multi-step workflows: run saved requests in order, extract JSON paths into collection variables, and stop the chain on failure.

Ordered steps of saved requests
JSON-path extractions into collection variables
Auto-suggested variable names from extracted paths
Run a single step or the entire chain
Per-step status: pending / running / success / error / skipped
Later steps see earlier steps' variables; chain stops on failure

Collection runner

Run every saved request in a collection in sidebar sort order — with optional iterations and CSV/JSON data files for parameterized runs.

WebSocket, SSE, gRPC, and Socket.IO requests are skipped in the runner. Use Request Chains or manual tabs for stream protocols. The same engine runs headless via rip.

Run all requests in collection sort order
Configurable iterations (repeat full collection N times)
CSV/JSON data files for parameterized runs
Resolves variables from global, collection, environment, and data-file scopes
Applies auth and collection cookie jar on each request
Live results panel with pass/fail/skip counts, status codes, timing
Progress logged to Console tab

Real-time protocols

WebSocket, Server-Sent Events, and Socket.IO clients with per-tab message logs, custom headers, and stream scripts.

WebSocket

Connect/disconnect from URL bar (Ctrl+Enter)
Send text or binary frames; per-tab message log with sent/received counts
Custom headers on connect; auto-scroll log; clear messages (Ctrl+L)

Server-Sent Events (SSE)

Persistent connection with auto-reconnect
Filter log by event type; custom headers; clear events (Ctrl+L)

Socket.IO

Connect, namespace/auth, event subscriptions, multi-arg emit, event log
Stream scripts with partial persistence

gRPC client

Unary and streaming gRPC calls with service/method discovery via reflection and per-tab session state.

Unary calls with service/method discovery via reflection
Proto message composition and response viewing
Server streaming, client streaming, and bidirectional streaming
Per-tab gRPC session state

SQL runner

Run queries against PostgreSQL, MySQL, or SQLite with saved connection profiles and pooled connections in the Rust backend.

PostgreSQL, MySQL, SQLite with saved connection profiles
SELECT returns typed rows, row counts, execution time
DML returns affected-rows count
Query history with per-entry errors
Pooled connections managed in the Rust backend

Local mock servers

Spin up local HTTP mock servers from a route table or directly from an OpenAPI Design document — with CORS enabled for browser testing.

Route table — GET/POST/PUT/PATCH/DELETE/OPTIONS/HEAD or * (any method)
Path parameters — /users/{id} with {id} substitution in response body
Configurable status, delay (ms), and response headers
Live request log — method, path, status, timestamp
CORS enabled for browser and Ripple HTTP client
Import routes from OpenAPI Design document
Start Mock from Design Studio — one-click generate, save, and start

Load test lab

Multi-threaded load testing with configurable concurrency and duration. Son of Anton can assist with load test plan generation.

Multi-threaded load testing with configurable concurrency and duration
Collection probe for bulk request execution
AI-assisted load test plan generation via Son of Anton
Real-time metrics and response time analysis

Developer utility tools

Built-in panels for network diagnostics, side-by-side diff, JWT decoding, and encode/decode — without leaving the app.

Network diagnostics

DNS resolve, port check, ping, trace route

Diff / compare

Side-by-side diff editor (Ctrl+Shift+B) with fullscreen
Configurable context lines, show-only-changes, word-wrap, ignore-whitespace
Inline character diff; next/previous change navigation
Send a response into the diff tool as either side

JWT decoder

Decode header / payload / signature; expiry computation; copy parts (Ctrl+Shift+J)

Encode / decode

Base64 and URL encode/decode (Ctrl+Shift+E)

Son of Anton

On-device LLM chatbot with tool-calling — list collections, run requests, set variables, and more. No cloud round-trips.

Ships in the default build; exclude with --no-default-features for a slimmer distributable.

On-device LLM inference (no cloud round-trips)
Curated model catalog (Hermes 3, Qwen 2.5, Phi 3.5 Mini — Q4_K_M GGUF)
Model download with progress, pause, resume, cancel, delete
GPU acceleration when supported; CPU fallback
Streaming tokens with Stop / Cancel
Tool-calling: list_collections, list_requests, inspect_request, get_request, run_request, get_variables, set_variable, get_history, get_last_response
Grammar-constrained tool-call generation
Chat panel sub-tabs: Chat / Action Log / History / Models
Persistent multi-chat history; composer autocomplete

MCP (Model Context Protocol)

Connect MCP servers to extend Son of Anton with external tools — stdio and remote transports with OAuth and keychain secrets.

MCP server management with stdio and remote transports
OAuth authentication for MCP servers
Keychain secrets integration for MCP
Dynamic tool surface extension for Son of Anton chatbot

Ripple CLI (rip)

Headless command-line tool sharing ripple-core with the desktop app. Same collection runner engine — available on Free and Pro tiers.

Run commands

rip run collection — execute from DB, workspace, or ripple-collection JSON
rip run chain — multi-step chains from DB or exported JSON
rip run postman / run insomnia / run openapi — import and run in one step
rip request send — one saved request by id or name
rip request raw — ad-hoc METHOD + URL with headers, body, proxy, timeout

Management & CI

rip collections list / export / import / validate
rip env list / show; rip workspace info / collections-list
Reporters: human, JSON, JUnit, HTML, GitHub Actions
Declarative JSON assertions (status, jsonPath, equals, header, timeMsLt)
CI exit codes: 0 pass, 1 fail, 2 usage error
Cross-platform binaries; Docker image; npm wrapper

CLI limitations

Nunjucks {% %} templates: desktop only
OAuth browser authorization UI: desktop only — CLI uses token fetch/refresh
WebSocket, SSE, gRPC, Socket.IO in runner: skipped
GUI response viewer, diff, Load Test Lab, SQL, Design Studio: desktop only

Team workspaces

File-based collaboration on disk — no cloud sync server required. Optional Git init, pull, commit, and push on the workspace folder.

Personal vs Workspace data mode switcher
Create team workspace (folder scaffold on disk)
Open registered workspace folders
File-based collection CRUD (JSON on disk)
Workspace environments with shared + local secret overrides
Import collections/requests from Personal → Workspace
External change polling (~3s) with auto-reload
Optional Git init / pull / commit / push / status on workspace folder
Conflict backups in .ripple/conflicts/

Settings, persistence & updates

Everything lives in a single local SQLite database (ripple.db) under the OS app-data directory. Tabs, UI state, and panel sizes restore on restart.

Settings

Request timeout, follow-redirects, SSL verification, proxy settings
Reset-to-defaults with Saved indicator (Ctrl+,)

Persistence

Single local SQLite database with schema migrations
Auto-restore of tabs, UI state, panel sizes across restarts

Updates & distribution

Self-hosted update channel via latest.json
Private GitHub release channel
Silent startup update check; UI-triggered download and install
Default build with embedded LLM stack; slim build without LLM

Keyboard shortcuts & UX

Searchable in-app shortcut panel (Ctrl+/) covering send, save, navigation, body-type quick-keys, and tool launchers.

In-app shortcut panel, searchable (Ctrl+/)
Send, Save, Method picker, Tab navigation, sidebar focus
Body-type quick-keys after Ctrl+B
Response tab jumps, graph view zoom controls
WebSocket / SSE shortcuts
Tool launchers for all utility panels
DevTools enabled in production builds (Ctrl+Shift+I)