checked
A gRPC client you can actually read
Tetiva is a desktop gRPC client for macOS and Windows. It pulls a service schema over server reflection or builds one from .proto files, lists the methods it finds, generates an example message from the input type, and sends the call. The client is free and open source, and installs at about 30 MB. No account is required.
This page is written for someone who already has grpcurl working and would rather click than retype the flag line. It describes what the app does today, limits included.
Schema from reflection or .proto files
A gRPC request starts with a schema, because without descriptors a client cannot encode the message.
The address is written without a URL scheme: localhost:50051, api.example.com:443. Load services opens a connection and asks the server for its service list, and the internal grpc.reflection.* services are filtered out of the result. The refresh button beside it re-reads the schema after you rebuild the server. Environment variables are resolved in the address, so one saved request follows whichever environment is active.
Production servers often disable reflection so the service catalogue is not published. In that case, Import .proto offers two paths. Import File takes a single file and adds its directory plus up to five parent directories as import paths, so an import such as common/v1/types.proto usually resolves on its own. Import Directory walks the selected directory recursively and parses every .proto it finds, which is the safer choice for a schema split across packages.
The active source is shown as a chip carrying the file or directory name. Refresh re-reads it from disk; the cross clears the path and returns the request to reflection. The path is stored with the request, so reopening the tab does not mean picking the schema again.
Pick a method, get an example message
The picker lists services and their methods together, with substring search and arrow-key navigation, so a method is a few characters away instead of a scroll. Each entry carries a badge for its call form: UNARY, SERVER, CLIENT or BIDI. The badge is worth reading, because only unary methods can be invoked. The others return an error saying the method is streaming.
Generate Example builds a JSON message from the input type. Strings come out empty, numbers zero, booleans false, enums set to their first value; a repeated field is wrapped in a one-element array and a map is given a single pair. Recursive messages are not expanded forever. Treat the output as scaffolding rather than a valid domain request: those defaults are legal protobuf, but a server will most likely answer INVALID_ARGUMENT if you send them unchanged.
Cmd/Ctrl+Enter invokes the call; so does the Invoke button. Cmd/Ctrl+S saves the request.
Metadata, timeouts and the response
A gRPC request has no Auth tab. Whatever the server needs travels in metadata, and the Metadata tab is the same key-value editor used for HTTP headers, with environment variables resolved in the values, so a token usually reads authorization: Bearer {{access_token}}.
For a token shared by a whole collection, set it from a collection-level pre-script. Scripts are inherited by nested requests, and pm.request.metadata.set('authorization', ...) writes the key into the current call. Scripting and authentication describe how that inheritance works.
There is no deadline field to fill in. Connecting and the call itself get 30 seconds each.
The Schema tab prints the proto definitions behind the selected method: the input message, the output message, and the rpc signature with its stream markers. The source line below it says where the definitions came from, whether reflection, a file or a directory, and Open in Window moves the schema into a separate window so it can sit next to the request body.
The response is split into Body, Metadata and Tests. Metadata holds the call's headers and trailers merged into one list. A non-OK gRPC status is not treated as a failed request: the app shows the numeric code with its name, NOT_FOUND or PERMISSION_DENIED, alongside the message the server returned.
What is not there yet
Streaming is not supported yet. Server, client and bidirectional methods are listed in the picker with their badges, and invoking one returns an error instead of opening a stream, so only unary calls execute.
Connections are plaintext. The gRPC server has to be reachable without TLS, which covers local development and internal environments; a gRPC endpoint behind TLS termination is not supported yet.
Deadlines are not exposed either. The two 30-second timeouts above are what a call gets. The gRPC documentation is the reference for the current behaviour of all three.
When you would still reach for grpcurl
grpcurl is a terminal tool, and that is its advantage. It drops into a shell script or a CI step and needs no window. Tetiva does not replace it there. What it replaces is holding the import paths, the flags and the JSON body in your head between calls, since the schema source, the metadata and the message all stay attached to a saved request. Our gRPC testing guide walks the same sequence as grpcurl commands, which makes it a workable map between the two.
Frequently asked questions
Does it work without server reflection?
Yes. Import a single .proto file or a directory; the importer resolves imports from the file's directory and up to five parent directories.
Does Tetiva support gRPC streaming?
Not yet. Methods are listed with their call form (UNARY, SERVER, CLIENT, BIDI), but only unary calls can be invoked today.
Can I call a gRPC server behind TLS?
Not yet. Connections are plaintext, which covers local and internal environments; a gRPC endpoint behind TLS termination is not supported.
How do I send an auth token?
In the Metadata tab — the same key-value editor as HTTP headers, with environment variables. A collection-level pre-script can set it for every request.