One endpoint · Six protocols
Catch every request. See it live. Answer with rules.
SoliTrace catches HTTP, gRPC, gRPC-Web, WebSocket and WebRTC requests the moment they hit your endpoint, shows them in a live stream, and answers them automatically with the rules you set — SSE streaming included. It even calls out on your behalf, on a cron schedule or with a single manual click.
Debug a webhook, test an integration, mock a service — sign up, grab your URL, and start sending.
No credit card · 1,000 requests/month free
Sample stream — once you sign up, you'll watch your own requests land here live.
Supported protocols
One address, whatever comes in
Every protocol has its own color — so you can tell at a glance what just landed in the live stream.
HTTP
REST · Webhook
gRPC
Unary · Streaming
gRPC-Web
Browser gRPC
WS
Two-way frames
WebRTC
Data channel
MQTT
over-WebSocket
What it does
One endpoint, every protocol, full visibility
Every line here is a capability that actually ships today — no marketing hand-waving.
Capture HTTP, gRPC, gRPC-Web, WebSocket and WebRTC
All five protocols on a single endpoint: headers/body/query, gRPC unary + streaming frames, every WS frame type (text/binary/ping/pong/close) and WebRTC data channel messages.
Rule-based auto responses
Build responses from conditions (protocol/path/method/header/query/body/JSONPath/frame type): HTTP status + headers + body template + delay, gRPC status + message, any WS frame type, ws_close with a custom code, and SSE streaming responses.
MQTT-over-WebSocket capture
Point your MQTT client at the endpoint; it captures CONNECT/PUBLISH/SUBSCRIBE/PING packets with topic + QoS + payload. Rules can auto-answer an incoming PUBLISH by publishing to a topic.
Scheduled and manual outbound calls
On a cron schedule or one click from the panel, SoliTrace sends HTTP/gRPC/gRPC-Web/WS requests on your behalf and keeps the results in history — with SSRF-guarded target validation.
Two-pane inspection
A header table, a JSON/form/multipart/text/hex body viewer, and a gRPC/WS/WebRTC frame list — see what came in and what went back out in a single session.
Teams and role-based access
Owner/admin/member roles inside an organization; every project and endpoint lives in the org context, and who can do what is bounded by role.
WebRTC NAT traversal (STUN + TURN relay)
WebRTC data-channel capture works over STUN; for restricted / UDP-blocked NATs, once an operator runs coturn, clients fetch ephemeral TURN credentials from GET /turn-credentials and connect through the relay. With no TURN env set, it falls back safely to STUN-only.
Usage and retention visibility
Watch your monthly request usage against your plan limit in real time; retention is applied automatically per your plan.
Native MQTT-over-TCP (1883)
Coming soonToday MQTT is captured over the WebSocket transport; native MQTT-over-TCP (1883, per-tenant port/username routing) and full inter-client broker routing (retained/session, QoS2) are on the roadmap — not shipped yet.
How it works
Live in three steps
No setup, no agent. Catching your first request takes seconds.
01
Create your endpoint
Sign up, open a project, and get a capture URL that's uniquely yours in seconds.
02
Send your request
Point your client, webhook or service at that address — HTTP, gRPC, WebSocket, WebRTC or MQTT, it doesn't matter.
03
Capture and respond
Inspect every request in the live stream; define rules by condition and let SoliTrace answer automatically or call out for you on a cron schedule.
Pricing
Start free, upgrade as you grow
Begin on Free with no credit card; move to Starter or Pro from the billing section in your dashboard when you're ready. Pay yearly and get two months free.
FREE
$0
free forever
- Requests / month
- 1,000
- Data retention
- 3 days
- Projects
- 1
- Body limit
- 512 KB
- Protocols
- HTTP only
Named proto decode (gRPC/gRPC-Web)
not included
Cron + manual outbound calls
not included
Team + role-based access (RBAC)
not included
STARTER
$5
/mo
$50 yearly (2 months free)
- Requests / month
- 50,000
- Data retention
- 14 days
- Projects
- 10
- Body limit
- 5 MB
- Protocols
- HTTP, gRPC, gRPC-Web, WS, WebRTC
Named proto decode (gRPC/gRPC-Web)
not included
Cron + manual outbound calls
included
Team + role-based access (RBAC)
included
PRO
Recommended$15
/mo
$150 yearly (2 months free)
- Requests / month
- 500,000
- Data retention
- 30 days
- Projects
- Unlimited
- Body limit
- 10 MB
- Protocols
- HTTP, gRPC, gRPC-Web, WS, WebRTC
Named proto decode (gRPC/gRPC-Web)
included
Cron + manual outbound calls
included
Team + role-based access (RBAC)
included
Paid plans are activated from the dashboard after you log in. Prices are in USD; the yearly price is 10× the monthly one (you pay for 10 months instead of 12).
FAQ
Frequently asked
Most of what you're wondering is here; for the rest, reach out on the contact page.
What is SoliTrace?
SoliTrace is a developer tool that live-captures HTTP, gRPC, gRPC-Web, WebSocket, WebRTC and MQTT-over-WebSocket requests on a single endpoint, answers them automatically with a rule engine (including SSE streaming), and can call out via cron or manually. It is a multi-protocol alternative for webhook.site-style request-bin/inspector needs.
Which protocols does it support?
HTTP, gRPC, gRPC-Web, WebSocket, WebRTC data channel and MQTT-over-WebSocket are captured. Rule-based responses cover HTTP status/header/body templates and delay, gRPC status/message, all WebSocket frame types, SSE streaming and MQTT PUBLISH responses. Outbound calls support HTTP, gRPC, gRPC-Web and WebSocket.
Is there a free plan?
Yes. The free plan requires no credit card; it includes a monthly request quota, a short retention period and HTTP capture with a single project. You can upgrade to paid plans from the billing section in the dashboard for all protocols, a higher quota, longer retention and team features.
How does request capture and rule-based response work?
You create an endpoint and point your clients at that address. Every incoming request appears in a live stream with its headers/body/query, gRPC and WebSocket frames, WebRTC messages and MQTT packets. Rules you define based on conditions (protocol, path, method, header, query, body, JSONPath, frame type) generate automatic responses to the request.
How long is captured data retained?
Retention depends on your plan: on the free plan captured data is deleted automatically after a short period, while paid plans have longer retention. Details are explained on the Privacy Policy page.
Is there team and role-based access?
Yes. Within an organization there are owner, admin and member roles; each project and endpoint is tracked in the organization context and who can do what is limited by role.
Ready to catch your first request?
No credit card, no setup. Sign up, grab your URL, and start sending.
1,000 requests/month free · forever