Online Tool Store
gRPC Request Builder
Paste a .proto file, pick the service and method, and get a correct, package-qualified grpcurl command with TLS, timeout, and Windows/PowerShell support built in.
🔒 This tool runs entirely in your browser. Your files are never uploaded to a server.
Browser tool
gRPC Request Builder
Browser limitation: browsers can't open raw gRPC (HTTP/2 trailer-based) connections, so this tool can't call your server directly. Instead it builds a correct, ready-to-run grpcurl command from your endpoint, proto, and request - copy it into a terminal to actually send the call.
—
Metadata (headers)
Advanced options (TLS certificates, timeouts, message size, output format)
How it works
- Paste your .proto file - the tool parses it locally to find services, methods, and whether each is unary or streaming.
- Pick a service and method from the dropdowns, or type a fully-qualified symbol manually if parsing doesn't find one.
- Fill in the request message as JSON and add any metadata headers (e.g. an auth token).
- Choose the connection security - plaintext, TLS with verification skipped, or verified TLS - and pick a schema source: your local .proto file (no reflection needed) or server reflection.
- Open "Advanced options" if you need mutual TLS certificates, a connect/max-time deadline, a max message size, or protobuf text output instead of JSON.
- Pick the shell you'll run the command in - macOS/Linux, PowerShell, or cmd.exe - so quoting matches that shell exactly.
- Copy or download the generated grpcurl command (or script) and run it in a terminal to actually send the request.
FAQ
What does this tool help with?
It parses a .proto file to find your services and methods, lets you build the request message, metadata, TLS, and timeout settings, and generates a correct, package-qualified grpcurl command you can run to actually make the call.
Why can't it call my gRPC server directly?
Browsers cannot open a raw gRPC connection - gRPC relies on HTTP/2 trailers and framing that only a native client (or a gRPC-Web proxy) can speak. Generating the exact grpcurl command is the honest, correct way to give you a working call from a browser tool.
Does it send my proto or data anywhere?
No. Parsing, request-building, and command generation all run locally in your browser - nothing is uploaded.
What if my proto can't be parsed?
The parser handles a single self-contained .proto file (no imports across files). If it finds no service definitions, the tool switches to a manual mode where you type the fully-qualified Service/Method symbol yourself.
What is grpcurl, and do I need to install it separately?
grpcurl is a real command-line tool - like curl, but for gRPC. This page only generates the command; you still need grpcurl installed (e.g. via brew or go install) to actually run it against your server.
Do I need server reflection enabled on my gRPC server to use this?
No, by default. With "Local .proto file" selected as the schema source, the generated command passes your proto to grpcurl via -proto and -import-path, so it never depends on server reflection. If your server does expose reflection and you'd rather skip the file step, switch schema source to "Server reflection" and the command uses -use-reflection instead.
Does it support mutual TLS (client certificates)?
Yes. Open "Advanced options" to set a CA certificate, client certificate, and client key file path - the tool only adds -cacert, -cert, or -key when they apply to your chosen connection security (for example, -cacert is omitted for -insecure connections, since grpcurl ignores it there).
Can I set a timeout or connection deadline?
Yes - "Advanced options" has fields for connect timeout (-connect-timeout) and maximum total call time (-max-time), plus a max response message size (-max-msg-sz), all optional.
Does the generated command work on Windows?
Yes. Use the "Command syntax for" selector to switch between macOS/Linux shell quoting, PowerShell, and cmd.exe quoting - each uses that shell's actual escaping rules, and the downloadable script matches (.sh, .ps1, or .bat).
How we compare
| Feature | Online Tool Store | EaseCloud gRPC Client | Newtum API Navigator gRPC Client |
|---|---|---|---|
| Generates a correct, package-qualified grpcurl symbol (package.Service/Method) | Yes | No - omits the package prefix | N/A - sends live instead |
| Parses a pasted .proto to list services and methods automatically | Yes | Manual entry only | Requires server reflection |
| Detects unary vs. streaming RPC type from the proto | Yes | No | Shown after connecting |
| Metadata header builder with shell-safe escaping | Yes | No | Yes |
| Command actually skips reflection when using a local proto (adds -proto/-import-path, not just a claim) | Yes | No - no -proto flag generated, so it silently falls back to reflection | N/A - always live |
| Mutual TLS support (-cacert / -cert / -key) | Yes | No | No |
| Connect timeout, max time, and max message size flags | Yes | No | N/A - configured on the live connection instead |
| Correct command quoting for bash/zsh, PowerShell, and cmd.exe | Yes | No - one shell style only | N/A - no command output |
| No signup, no live network call required | Yes | Yes | No - requires a reachable server |
Because a browser can't speak raw gRPC, the honest and useful output is a correct command - and getting the package-qualified symbol, the reflection-free -proto flag, and the shell's own quoting rules right is exactly where a naive implementation breaks.