An HTTP server and five client components. TsgcHTTPServer publishes HTTP endpoints and static files from your own application. TsgcHTTP2Client speaks HTTP/2 with multiplexed streams over one TLS connection and HPACK header compression. TsgcGRPCClient is a gRPC client built on top of it, for unary and streaming Protocol Buffers calls. Three more classes reach Google Cloud over plain HTTPS: Pub/Sub, Calendar and Firebase Cloud Messaging.
A narrated, captioned quickstart: an HTTP/2 client sending many requests over one connection, then a gRPC call riding on that same transport, all from Delphi. Nothing downloads until you press play.
Call an HTTP/2 endpoint and make a gRPC call, from Delphi.
Both components are declared in the sgcHTTP unit, and TsgcGRPCClient carries its own HTTP/2 connection through its Client property.
TsgcHTTP2Client speaks HTTP/2 (RFC 9113): multiple requests share a single TCP connection as independent streams. Headers are compressed with HPACK, and h2 is negotiated during the TLS handshake through ALPN. Every verb is covered, Get, Post, Put, Patch, Delete and Options, each with a synchronous call and an Async twin.
TsgcGRPCClient inherits the multiplexed connection and adds the gRPC wire format on top. Call and CallAsync cover unary RPCs, ServerStreamingCall handles a stream of responses to one request, and OpenClientStream and OpenBidiStream cover client streaming and bidirectional streaming. RetryPolicy, Interceptors and ServiceConfig add retry behavior and cross-cutting logic without touching the call sites.
The five classes split cleanly by what they need underneath. HTTP/2 and gRPC need ALPN, which means sgcCustomIndy. Google Cloud needs nothing beyond HTTPS and a service account, which the bundled Core runtime already provides. The HTTP server comes from that runtime itself.
TsgcHTTPServer publishes HTTP endpoints from your own application. Set Port, handle OnCommandGet, set Active, and every request reaches your code. OnCommandOther covers verbs such as PUT and DELETE. It ships with the bundled Core runtime.
Point DocumentRoot at a folder and the server returns static files from it. HTTPUploadFiles saves uploaded files to disk, MaxRequestBodySize caps request bodies, and HTTPCompression and KeepAlive keep responses small and connections open.
SSL and SSLOptions enable TLS, Authentication and OnAuthentication protect endpoints, SessionState tracks sessions, and ThreadPool and MaxConnections control how it scales. The same engine as the WebSocket server, without the WebSocket part.
TsgcHTTP2Client multiplexes independent streams over one TLS connection, compresses headers with HPACK and negotiates h2 through ALPN. Connect, Get, Post, Put, Patch, Delete and Options, synchronous or Async.
TsgcGRPCClient rides on the HTTP/2 client: length-prefixed Protocol Buffers messages over HTTP/2 streams, with unary, server streaming, client streaming and bidirectional RPCs, plus retry policy and interceptors.
TsgcHTTPGoogleCloud_PubSub_Client, TsgcHTTPGoogleCloud_Calendar_Client and TsgcHTTPGoogleCloud_FCM_Client reach Pub/Sub, Calendar and Firebase Cloud Messaging, authenticated with a Google service account. None of them need sgcCustomIndy.
Events surface the connection lifecycle: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment for chunked bodies, OnHTTP2PushPromise for server push, OnHTTP2GoAway and OnHTTP2Disconnect. Nothing about the stream lifecycle is hidden from you.
The HTTP/2 and gRPC clients build on sgcCustomIndy, which covers the same platform range as sgcWebSockets itself. The Google Cloud clients are plain HTTPS, so they run wherever the Core runtime does. Delphi 7 through RAD Studio 13, and C++ Builder.
Every license carries the full source of the HTTP server, all five clients and the bundled runtime, so the wire-level implementations step through in your own debugger. Deployment is royalty-free.
Create the component, set a port or point it at a host, hook the event and go. The same code compiles in Delphi 7 to 13 and C++ Builder.
uses
sgcHTTP;
var
HTTP2: TsgcHTTP2Client;
begin
// HTTP/2: multiplexed requests over one TLS connection
HTTP2 := TsgcHTTP2Client.Create(nil);
HTTP2.Host := 'https://api.example.com';
HTTP2.OnHTTP2Response := HTTP2Response;
HTTP2.Active := True;
HTTP2.GetAsync('/v1/status');
end;
procedure TForm1.HTTP2Response(Sender: TObject;
const Connection: TsgcHTTP2ConnectionClient;
const Request: TsgcHTTP2RequestProperty;
const Response: TsgcHTTP2ResponseProperty);
begin
Memo1.Lines.Add(Response.DataString);
end;uses
sgcHTTP;
var
GRPC: TsgcGRPCClient;
begin
// gRPC: built on the HTTP/2 client, unary and streaming RPC
GRPC := TsgcGRPCClient.Create(nil);
GRPC.Client.Host := 'https://grpc.example.com';
GRPC.OnGRPCResponse := GRPCResponse;
GRPC.CallAsync('example.OrderService', 'GetOrder', RequestBytes);
end;
procedure TForm1.GRPCResponse(Sender: TObject;
const aResponse: TsgcGRPCResponse);
begin
Memo1.Lines.Add(aResponse.DataString);
end;uses
sgcHTTP_Server;
var
Server: TsgcHTTPServer;
begin
// HTTP server: endpoints and static files
Server := TsgcHTTPServer.Create(nil);
Server.Port := 8080;
Server.DocumentRoot := 'C:\www';
Server.OnCommandGet := ServerCommandGet;
Server.Active := True;
end;
procedure TForm1.ServerCommandGet(AContext: TIdContext;
ARequestInfo: TIdHTTPRequestInfo;
AResponseInfo: TIdHTTPResponseInfo);
begin
if ARequestInfo.Document = '/api/status' then
begin
AResponseInfo.ContentType := 'application/json';
AResponseInfo.ContentText := '{"status":"ok"}';
end;
end;The same shape in Object Pascal and in C++ Builder. The full feature matrix →
What sgcHTTP needs from you, and what it does not. Both answers are short, and both are on this page rather than in the small print.
class needs sgcCustomIndy
TsgcHTTPServer no, ships with the Core runtime
TsgcHTTP2Client yes, for ALPN
TsgcGRPCClient yes, rides on TsgcHTTP2Client
TsgcHTTPGoogleCloud_PubSub_Client no, plain HTTPS
TsgcHTTPGoogleCloud_Calendar_Client no, plain HTTPS
TsgcHTTPGoogleCloud_FCM_Client no, plain HTTPS
HTTP/2 negotiates h2 with ALPN during the TLS handshake.
The standard Indy library that ships with RAD Studio
has no ALPN support, so both HTTP/2 and gRPC are built
on sgcCustomIndy instead.The sgcWebSockets Core runtime is included: the HTTP server, the HTTP/TLS client stack every client sends its requests through, and the JSON layer that decodes Google Cloud responses. One installer, full source code in the box.
ALPN negotiation is not supported by the standard Indy library, so TsgcHTTP2Client and, by extension, TsgcGRPCClient are built on sgcCustomIndy instead. It is always included when you order sgcHTTP, and the price shown already covers it.
The three Google Cloud clients authenticate with a Google service account's project id, client email and private key, and call the REST APIs over the Core runtime's plain HTTPS stack. No native library, no sgcCustomIndy.
sgcHTTP targets Delphi 7 through RAD Studio 13 and C++ Builder. The same components also live inside sgcWebSockets Enterprise, so an existing Enterprise or All-Access license may already cover you. The trial installer is the sgcWebSockets All-Access trial, so the HTTP server and all five clients can be evaluated today.
sgcHTTP implements the published HTTP/2, gRPC and Google Cloud REST surfaces rather than wrapping a vendor SDK, so streams, headers, RPCs and push notifications are all first-class methods and events, and full source code means nothing in between is a black box.
sgcHTTP bundles the sgcWebSockets Core runtime it is built on, and the sgcCustomIndy add-on that HTTP/2 and gRPC need is always included. Every license ships with full source code and royalty-free deployment.
1 developer license. Use on one machine at a time.
2 developer licenses. Use on two machines at a time.
Unlimited developers. All company machines.
HTTP/2, gRPC and Google Cloud client components for Delphi and C++ Builder, with the sgcWebSockets Core runtime bundled in. Already on sgcWebSockets Enterprise? The same components are in there too.
View pricing and licensesTrusted by Delphi, C++ Builder, Lazarus and .NET developers around the world.
Your sgcWebSockets library is very useful and easy to setup. Keep up the good work!
sgcWebSockets is amazing and your support is the best!
Thanks so much for your help and support, I love your components.
An HTTP server, multiplexed HTTP/2, streaming gRPC and three Google Cloud clients, with the sgcWebSockets Core runtime bundled in and full source code in the box.
sgcHTTP shares conventions with the other eSeGeCe component libraries for Delphi, C++ Builder and .NET. They ship with full source, and they deploy royalty-free.
WebSocket, HTTP/2, MQTT, AMQP, WebRTC, AI and 30+ API integrations for Delphi, C++ Builder, Lazarus and .NET. Its Enterprise edition includes gRPC too.
REST server, OpenAPI server and OpenAPI client components for Delphi and C++ Builder. Publish REST APIs from an OpenAPI 3.x contract, or consume any OpenAPI-described API.
OAuth2 client, JWT client and WebAuthn support for Delphi and C++ Builder. Standalone, with the sgcWebSockets Core runtime bundled in.
MQTT, AMQP 0.9.1 and 1.0, Apache Kafka and STOMP client components for Delphi and C++ Builder. Standalone, with the sgcWebSockets Core runtime bundled in.
Telegram and WhatsApp Business client components for Delphi and C++ Builder. Standalone, with the sgcWebSockets Core runtime bundled in.
AI, LLM and MCP components for Delphi and C++ Builder. Seven LLM providers behind one component, plus MCP, embeddings and speech.
Server-side HTML and UI components on Bootstrap 5 and htmx for Delphi, C++ Builder and .NET.
Raw QUIC transport and an HTTP/3 client and server, with WebTransport. An add-on to sgcWebSockets Enterprise.
OpenAPI 3.x parser, native Pascal SDK generator, OpenAPI server component, and 1,195+ pre-built cloud SDKs.
XAdES, PAdES, CAdES and ASiC for documents, Authenticode, ClickOnce, NuGet and VSIX for code.
Create, edit, view, sign, redact and validate PDF files in pure Object Pascal, with no DLL to deploy. Licensed on its own.
Windows Hello, fingerprint sensors and the Windows Biometric Framework for Delphi and C++ Builder.
Updated Indy TCP/IP components with modern TLS, IPv6 and HTTP/2 for Delphi 7 through 13.
