Crate connectrpc 

ConnectRPC implementation for Rust

This crate provides a tower-based ConnectRPC runtime that can be integrated with any HTTP framework that supports tower services (axum, hyper, tonic, etc.).

Architecture

The core abstraction is ConnectRpcService, a tower::Service that handles ConnectRPC requests. This allows seamless integration with existing web servers:

use connectrpc::{Router, ConnectRpcService};
use std::sync::Arc;

// Build your router with RPC handlers
let greet_impl = Arc::new(MyGreetService);
let router = greet_impl.register(Router::new());

// Get a tower::Service - use with ANY compatible framework
let service = ConnectRpcService::new(router);

Framework Integration

With Axum (recommended)

Enable the axum feature for convenient integration:

use axum::{Router, routing::get};
use connectrpc::Router as ConnectRouter;
use std::sync::Arc;

let greet_impl = Arc::new(MyGreetService);
let connect = greet_impl.register(ConnectRouter::new());

let app = Router::new()
    .route("/health", get(health))
    .fallback_service(connect.into_axum_service());

axum::serve(listener, app).await?;

With Raw Hyper

Use ConnectRpcService directly with hyper’s service machinery.

Standalone Server

For simple cases, enable the server feature for a built-in hyper server:

use connectrpc::{Router, Server};

let router = Router::new();
// ... register handlers ...

Server::new(router).serve(addr).await?;

Modules

• codec - Message encoding/decoding (protobuf and JSON)
• compression - Pluggable compression (gzip, zstd) with streaming support
• envelope - Streaming message framing (5-byte header + payload)
• error - ConnectRPC error types and HTTP status mapping
• handler - Async handler traits for implementing RPC methods
• router - Request routing and service registration
• service - Tower service implementation (primary integration point)
• client - Tower-based HTTP client utilities (requires client feature)
• server - Standalone hyper-based server (requires server feature)

Protocol Support

This implementation follows the ConnectRPC protocol specification:

• Unary RPC calls (request-response)
• Proto and JSON message encoding
• Compression negotiation (gzip, zstd) with streaming support
• Error handling with proper HTTP status mapping
• Trailers via trailer- prefixed headers
• Envelope framing for streaming messages

Client

Enable the client feature and use generated clients with a transport.

For gRPC (HTTP/2), use Http2Connection:

use connectrpc::client::{Http2Connection, ClientConfig};
use connectrpc::Protocol;

let uri: http::Uri = "http://localhost:8080".parse()?;
let conn = Http2Connection::connect_plaintext(uri.clone()).await?.shared(1024);
let config = ClientConfig::new(uri).protocol(Protocol::Grpc);

let client = GreetServiceClient::new(conn, config);
let response = client.greet(request).await?;

For Connect over HTTP/1.1 (or unknown protocol), use HttpClient:

use connectrpc::client::{HttpClient, ClientConfig};

let http = HttpClient::plaintext();  // cleartext http:// only
let config = ClientConfig::new("http://localhost:8080".parse()?);

let client = GreetServiceClient::new(http, config);

Per-call options and defaults

Generated clients expose both foo(req) and foo_with_options(req, opts) for each RPC. Use CallOptions for per-call timeout, headers, message-size limits, and compression overrides.

For settings you want on every call, configure ClientConfig defaults — they’re applied automatically by the no-options method:

let config = ClientConfig::new(uri)
    .default_timeout(Duration::from_secs(30))
    .default_header("authorization", "Bearer ...");

let client = GreetServiceClient::new(http, config);
client.greet(req).await?;  // uses 30s timeout + auth header

Per-call CallOptions override config defaults.

See the client module docs for connection balancing and the transport selection rationale.

Feature Flags

Feature	Default	Description
gzip	✓	Gzip compression
zstd	✓	Zstandard compression
streaming	✓	Streaming compression support
client	✗	HTTP client transports (plaintext)
client-tls	✗	TLS for client transports
server	✗	Standalone hyper-based server
server-tls	✗	TLS for the built-in server
tls	✗	Convenience: server-tls + client-tls
axum	✗	Axum framework integration

Re-exports

pub use service::ConnectRpcBody;

pub use service::ConnectRpcService;

pub use service::Limits;

pub use service::StreamingResponseBody;

pub use router::MethodKind;

pub use router::Router;

pub use dispatcher::Chain;

pub use dispatcher::Dispatcher;

pub use dispatcher::MethodDescriptor;

pub use handler::BidiStreamingHandler;

pub use handler::ClientStreamingHandler;

pub use handler::Context;

pub use handler::Handler;

pub use handler::StreamingHandler;

pub use handler::ViewBidiStreamingHandler;

pub use handler::ViewClientStreamingHandler;

pub use handler::ViewHandler;

pub use handler::ViewStreamingHandler;

pub use handler::bidi_streaming_handler_fn;

pub use handler::client_streaming_handler_fn;

pub use handler::handler_fn;

pub use handler::streaming_handler_fn;

pub use handler::view_bidi_streaming_handler_fn;

pub use handler::view_client_streaming_handler_fn;

pub use handler::view_handler_fn;

pub use handler::view_streaming_handler_fn;

pub use error::ConnectError;

pub use error::ErrorCode;

pub use protocol::Protocol;

pub use protocol::RequestProtocol;

pub use codec::CodecFormat;

pub use codec::JsonCodec;

pub use codec::ProtoCodec;

pub use compression::CompressionPolicy;

pub use compression::CompressionProvider;

pub use compression::CompressionRegistry;

pub use compression::DEFAULT_COMPRESSION_MIN_SIZE;

pub use compression::GzipProvider;gzip

pub use compression::ZstdProvider;zstd

pub use compression::BoxedAsyncBufRead;streaming

pub use compression::BoxedAsyncRead;streaming

pub use compression::StreamingCompressionProvider;streaming

pub use server::BoundServer;server

pub use server::Server;server

pub use server::PeerAddr;server

pub use server::PeerCerts;server-tls

pub use rustls;server-tls or client-tls

Modules

client

Tower-based HTTP client transports for ConnectRPC.

codec

Message encoding and decoding for ConnectRPC.

compression

Pluggable compression support for ConnectRPC.

dispatcher

Request-to-handler dispatch abstraction.

envelope

Envelope framing for ConnectRPC streaming.

error

ConnectRPC error types and HTTP status mapping.

handler

Handler traits for implementing RPC methods.

protocol

Protocol detection and abstraction for multi-protocol support.

router

Request routing and service registration.

serverserver

Hyper-based HTTP server for ConnectRPC.

service

Tower service integration for ConnectRPC.