Open-source alternatives to Httpx

This is a header-only C++ library that provides implementations for HTTP clients, HTTP servers, and a WebSocket framework. It allows for the creation of network services and the consumption of remote APIs without requiring a separate compilation step or external binary linking. The project features backend-agnostic TLS integration for secure HTTPS and WSS communication and employs a thread-pool model to process concurrent requests. It distinguishes itself with a full-duplex WebSocket state-machine and a middleware-based request pipeline that supports regular-expression path routing. The libr

Requests is a high-level HTTP client library designed to simplify web communication and API integration. It provides an intuitive, human-readable interface for performing standard network operations, including request execution, connection pooling, and stateful session management. By encapsulating raw network data into structured objects, the library automates the complexities of headers, cookies, and payload transmission. The library distinguishes itself through a modular transport adapter layer that allows for custom protocol handling and extensible authentication hooks. It supports a wide

Got is a promise-based HTTP request library for Node.js that supports HTTP/2 and streaming. It provides a system for making network requests with a focus on asynchronous control flow and type-safe API client development. The library is distinguished by its middleware-based request lifecycle, which uses interceptors and plugins to modify request options and response data. It includes a configurable automatic retry mechanism with backoff strategies, a built-in HTTP response cache, and a cookie-jar system for maintaining persistent sessions. Broad capabilities cover data handling through duplex

node-fetch is a promise-based HTTP client library that provides a lightweight implementation of the Fetch API for the Node.js runtime. It serves as a network interface for performing asynchronous HTTP requests, handling server communication, and managing headers. The library utilizes a promise-based request lifecycle to wrap network calls, ensuring asynchronous behavior. It incorporates stream-based handling for both requests and responses to process large payloads efficiently without overloading system memory. Its capabilities cover a broad range of network communication tasks, including th

This project is an asynchronous network framework for Python that provides both a client and a server for HTTP communication. It is designed to handle high-concurrency network operations by leveraging cooperative multitasking, allowing for the management of thousands of simultaneous connections without the overhead of traditional thread-per-request models. The framework distinguishes itself through its focus on efficient resource management and persistent communication. It utilizes connection pooling to reuse network sockets, which reduces latency during sequential requests, and supports full

Guzzle is a PHP HTTP client used for sending synchronous and asynchronous requests to web services. It serves as a concurrent HTTP request manager, an HTTP stream handler, and a middleware-based HTTP pipeline. The project is a PSR-7 compliant client, utilizing standardized PHP interfaces for requests, responses, and streams. The library differentiates itself through a customizable functional handler stack that allows for the interception and modification of the request and response lifecycle. It features an adapter-based transport system that enables swapping between network implementations,

Feign is a declarative Java HTTP client framework that maps method signatures to REST API requests. It functions as an HTTP interface mapper, allowing the creation of type-safe clients by defining service interfaces with annotations to eliminate manual request logic. The framework features a pluggable HTTP transport layer, which decouples request definition from execution by routing network traffic through interchangeable underlying HTTP engines. It provides a comprehensive request management pipeline including interceptors for modifying headers, policy-driven retry logic for failure recover

Superagent is an isomorphic JavaScript HTTP client for sending network requests and processing responses across both Node.js and web browser environments. It provides a fluent request builder that uses a chainable interface to construct complex network requests with custom headers, query strings, and bodies. The library functions as a runtime-agnostic request adapter, allowing a single codebase to work consistently across different environments. It includes specialized capabilities such as an HTTP/2 client for forcing the HTTP/2 protocol and a Node.js agent for managing Unix socket connection

Fasthttp is a high-performance networking framework for Go, designed to maximize throughput and minimize memory overhead in demanding web applications. It functions as a specialized HTTP server and client library that prioritizes efficient resource management, allowing developers to build scalable services capable of handling massive concurrent traffic with minimal garbage collection pressure. The library distinguishes itself through a focus on zero-allocation processing and low-level optimization. It achieves this by recycling temporary request and response objects through managed pools and

cpr is a C++ networking library that provides a high-level HTTP request client. It functions as a wrapper around libcurl to simplify the process of sending and receiving data from web servers, specifically managing GET and POST calls and multipart form uploads. The library provides both synchronous and asynchronous execution models, allowing network requests to run on background threads to prevent application freezing. It integrates with the C++ Standard Library to map low-level pointers to standard strings and containers, utilizing RAII for automatic resource management. The project covers

RestSharp is a .NET HTTP client library designed for interacting with RESTful web services. It provides a high-level request wrapper and a dedicated REST API client to manage endpoints, headers, and query parameters. The library includes a serialization mechanism that automatically converts objects to and from JSON or XML formats for API payloads. It also features a system for managing API credentials and security tokens to ensure authorized access to protected remote resources. The toolkit covers broad capabilities for external web service integration, including generic type-based deseriali

Faraday is an HTTP client library for Ruby that sends requests and processes responses through a middleware pipeline with pluggable adapters. Its core identity is built around a middleware-pipeline architecture where HTTP requests and responses flow through a chain of components that can modify, log, or transform data before reaching the backend, combined with an adapter-based backend abstraction that delegates HTTP execution to interchangeable backends like Net::HTTP or Typhoeus. The library distinguishes itself through a parallel-execution engine that dispatches multiple HTTP requests concu

This is a Ruby HTTP client designed for REST API integration, resource modeling, and automated network communication. It provides a set of tools for managing headers, cookies, and SSL configurations, along with a dedicated command-line interface for executing one-off HTTP commands and managing interactive API testing sessions. The project differentiates itself through its resource modeling capabilities, which allow for the definition of persistent base URLs and credentials to construct nested subresource endpoints. It also features a multipart request handler that detects MIME types to upload

This is a non-blocking network client for Java applications that provides asynchronous HTTP request capabilities and bidirectional WebSocket connectivity. It leverages a Netty-based architecture to handle high volumes of network input and output. The library utilizes native transport abstractions such as Epoll, KQueue, and io_uring to reduce system latency. It supports HTTP/2 multiplexing to run multiple concurrent request-response streams over a single connection and provides automatic response body decompression for various formats. Core capabilities cover the management of complex network

Resty is a high-level HTTP client library for Go designed for consuming REST services. It provides a streamlined interface for executing network requests, managing server-sent event streams, and automatically mapping JSON and XML responses into data structures. The library includes built-in mechanisms for service resilience and traffic management, such as circuit breakers to prevent cascading failures, token-bucket rate limiting, and automated request retries with exponential backoff. It also features client-side load balancing to distribute outgoing traffic across multiple base URLs and requ

Typhoeus is a Ruby wrapper for libcurl that functions as a session-based HTTP client. It provides an interface for making both synchronous and asynchronous network requests. The project acts as a parallel request manager, using a managed queue to execute multiple network requests concurrently. It further distinguishes itself as a mocking tool for stubbing requests with predefined responses and as a caching layer that stores responses to avoid redundant network calls. The library covers a broad range of capabilities including session cookie management, response body streaming for large files,

CodeIgniter is a PHP web framework built on the Model-View-Controller pattern, designed for building full-stack web applications. It provides a lightweight toolkit with minimal configuration, organizing application logic into controllers, models, and views for clean separation of concerns. The framework includes a fluent query builder for constructing SQL statements programmatically, PSR-4 autoloading with namespace mapping, and a service-based dependency injection container for managing shared class instances. The framework distinguishes itself through its comprehensive set of built-in tools

Subfinder is a security reconnaissance framework designed for subdomain enumeration and attack surface management. It functions as a discovery engine that identifies and maps internet-exposed infrastructure, cloud-hosted assets, and network ranges to maintain a comprehensive inventory of an organization's digital footprint. The project distinguishes itself through a modular, template-driven scanning engine that executes security checks against discovered assets. It leverages cloud-native asset discovery to query provider APIs and infrastructure metadata, while supporting distributed agent orc

Wretch is a chainable HTTP client library and Fetch API wrapper designed to simplify network request configuration, response parsing, and error handling. It functions as a network request manager and middleware framework for managing the end-to-end lifecycle of HTTP calls. The project is distinguished by a fluent interface for request configuration and a modular extension system. It utilizes a programmable response resolver to automate parsing and a plugin-based architecture to add new capabilities to request and response objects. The library covers a broad range of operational capabilities,

Refit is a type-safe REST client for .NET that transforms API definitions into live interfaces. It functions as an automatic API proxy generator, allowing developers to define endpoints as interfaces to eliminate manual HTTP request boilerplate. The library is designed for compatibility with ahead-of-time compilation and trimmed binaries, utilizing build-time source generation to ensure support for native AoT deployments. The project covers a broad range of API integration capabilities, including attribute-driven request composition, automatic JSON deserialization, and request header managem

Curl is a command-line tool and portable library for transferring data across a wide range of network protocols. It functions as a unified engine that abstracts diverse communication standards, allowing users and developers to move files and information between servers using a consistent interface. The project provides both a versatile command-line client for terminal-based automation and a stable programmatic interface for integrating complex network operations into applications. The system is distinguished by its protocol-agnostic core and its ability to manage both synchronous and asynchro

urllib3 is a Python HTTP client library used to send network requests and receive responses. It provides core components for managing HTTP connection pools, routing traffic through proxies, validating TLS certificates, and executing automatic request retries. The library focuses on network reliability and efficiency by maintaining a system that reuses established connections to multiple hosts to reduce latency. It ensures secure communication through client-side certificate verification and handles transient network errors using policy-based retry logic. The project covers broad networking c

Moya is a network abstraction layer for Swift that provides a structured framework for defining and executing REST API requests. It functions as a type-safe API client that decouples network endpoint definitions from the underlying implementation details to prevent configuration errors and URL typos. The project distinguishes itself by using protocol-based endpoint definitions and a provider-coordinated execution model. It includes a system for mapping network responses to strongly typed objects and features a dedicated tool for generating type-safe network interface files from external REST

Rest-assured is a Java-based REST API testing framework and HTTP client library designed for automating web service tests. It provides a fluent domain-specific language and assertion library to send HTTP requests and validate response metadata, including status codes, headers, cookies, and bodies. The framework is distinguished by a method-chaining DSL that creates readable specifications for API interactions. It features a filter-based request interception pipeline, object-mapping serialization for converting Java objects to JSON or XML, and a path-based parsing system to isolate specific fi

Beast is a C++ library for implementing low-level HTTP and WebSocket clients and servers. It functions as an asynchronous networking framework designed to compose non-blocking I/O operations and layered stream stacks for managing concurrent network traffic, specifically utilizing the Boost.Asio asynchronous model. The library provides a comprehensive implementation of the HTTP/1.1 and WebSocket protocols. For HTTP, it includes primitives for parsing and serializing messages with support for chunked transfer encoding, incremental body reading, and request pipelining. Its WebSocket implementati

libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP, WebSocket, and MQTT clients and servers. It provides a non-blocking event loop for managing network sockets, timers, and system signals across multiple threads. The project is distinguished by its integrated support for specialized network roles, including a full HTTP web server with RESTful routing and middleware, an MQTT messaging client for IoT communication, and the ability to implement SOCKS5 and HTTP proxies. It also features a reliable UDP implementation to ensure ordered

Grequests is an asynchronous HTTP batcher and Gevent-based client library used to execute large sets of network requests simultaneously. It functions as a concurrent request wrapper for the Requests library, enabling non-blocking operations to reduce the total time spent waiting for server responses. The project provides a task-pool execution model to handle batch network operations, such as high-throughput web scraping and API polling. It can stream responses as they arrive via a generator, allowing for immediate data processing without waiting for the entire batch to complete. The library