Open-source alternatives to Async Http Client

This is an HTTP client library used for sending and receiving network requests. It functions as an HTTP traffic replicator, a multipart form uploader, and an OAuth request signer, while also serving as an HTTP client capable of routing traffic through Unix domain sockets for local inter-process communication. The project distinguishes itself with the ability to import and parse HTTP Archive JSON files to reproduce recorded network traffic. It also provides cryptographic OAuth signing to secure API access using hashing algorithms and supports routing requests through Unix domain sockets using

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

This project is a comprehensive Python network request framework designed for both synchronous and asynchronous HTTP communication. It provides a high-performance client capable of executing non-blocking requests within event-driven applications, while also supporting standard blocking calls for simpler scripts. The library is built to operate natively across diverse asynchronous runtimes, automatically detecting and utilizing the underlying event loop for concurrency. What distinguishes this library is its modular architecture, which decouples request construction from network execution thro

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,

This is a Java library for establishing real-time bidirectional communication with servers using the Socket.IO protocol. It functions as an event-driven communication client that allows Java applications to exchange named events and binary data with a remote server. The library implements both WebSocket and HTTP long-polling transports, providing a fallback mechanism when WebSocket connections are unavailable. It supports namespace-based multiplexing to divide a single physical network connection into multiple logical channels for separating data streams. The project covers a broad range of

Primus is a real-time communication abstraction layer and middleware framework. It provides a standardized interface for messaging that allows developers to switch between different transport engines without rewriting application logic, while also serving as a wrapper for managing socket lifecycles. The project distinguishes itself by functioning as a real-time client library generator, producing compatible client-side code based on server configurations. It further organizes data flow through virtual stream multiplexing and the ability to group connections into named communication rooms for

The C++ REST SDK is a library for asynchronous HTTP and RESTful communication in native C++ applications. It provides a non-blocking network client for sending requests and receiving responses, a JSON parser for serializing and deserializing data, and a WebSocket client library for real-time, full-duplex communication. The project includes a dedicated OAuth2 authentication client to manage access tokens and authorization flows for secure communication with protected cloud resources. It utilizes a task-based asynchronous model to coordinate background operations and keep application interfaces

Proxygen is a collection of C++ libraries for building high-performance HTTP servers and clients. It provides a protocol parser that converts raw network bytes into high-level transaction objects and includes a network stack for processing web traffic over the QUIC transport protocol. The project implements a layered protocol abstraction and a QUIC-based transport integration to support multiple versions of the HTTP standard, including HTTP/3. It utilizes state-machine based parsing and an event-driven I/O loop to manage concurrent network connections. The library covers asynchronous buffer

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,

evpp is a C++ network library and framework designed for building high-performance network services using TCP, UDP, and HTTP protocols. It provides an asynchronous event loop to manage nonblocking I/O operations and concurrent network connections across multiple threads. The framework includes specialized tools for asynchronous DNS resolution and a system for asynchronous task scheduling using a managed thread pool. It also features a nonblocking HTTP server and client with integrated connection pooling. The project covers low-level transport layer connectivity for TCP and UDP, as well as hi

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

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

Axios is a promise-based HTTP client used to make asynchronous network requests in both browser and Node.js environments. It functions as a multi-environment network adapter that abstracts the transport layer to ensure consistent behavior across different runtimes. The project distinguishes itself through a request lifecycle management system that allows for the cancellation of active requests, the setting of timeouts, and the monitoring of upload and download transfer progress. It includes a mechanism for intercepting network traffic, enabling the transformation of outgoing requests and inco

This is an asynchronous HTTP client for Android that simplifies network requests by wrapping Apache HttpClient. It provides a callback-based networking library for fetching remote data and communicating with servers without blocking the user interface. The project includes a multipart HTTP uploader for sending binary files and large data payloads, as well as a JSON parser to convert raw response text into structured data objects. It features a session manager that persists cookies in local application preferences to maintain state across multiple requests. Additional capabilities include aut

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,

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

Axios is an isomorphic, promise-based HTTP client designed for making asynchronous network requests across different JavaScript execution environments, including the browser and Node.js. It functions as a JSON API client that serializes JavaScript objects into JSON and parses server responses into structured data. The project features a system for managing reusable client instances with shared configurations, such as base URLs and default settings. It includes a mechanism for intercepting outgoing requests and incoming responses globally, allowing data to be transformed before it reaches the

Vibora is an asynchronous Python web framework and built-in HTTP server designed for building high-performance web applications. It utilizes an asynchronous event loop and coroutines to process network requests and serve responses without requiring external server wrappers. The project features a high-performance asynchronous schema validator for request integrity, a non-blocking template engine with support for hot-reloading, and a WebSocket communication server for bidirectional real-time data exchange. The framework covers a broad range of capabilities, including modular route management

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

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

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

This project is an Objective-C HTTP networking library that provides an object-oriented wrapper for CFNetwork to execute synchronous and asynchronous requests on macOS and iOS. It functions as a framework for managing HTTP sessions, performing resumable file transfers, and handling offline content caching. The library distinguishes itself through a resumable file transfer manager that tracks byte offsets and utilizes disk-backed streaming for large uploads and downloads. It also includes a secure credential manager that integrates with the system keychain to handle client certificates and aut

HTTParty is a Ruby HTTP client library designed for building standardized API clients. It abstracts low-level network primitives into a high-level interface, allowing developers to encapsulate base URIs and request configurations within classes to maintain consistent interactions with remote web services. The library automates the transformation of raw network response data into native Ruby structures by using a registry-based system that parses content based on response headers. It also provides specialized mechanisms for sending multipart form data and streaming large payloads to maintain m

openai-go is an LLM SDK for Go and a client for interacting with OpenAI services. It provides type-safe bindings to generate text, images, and audio via REST endpoints, enabling the integration of large language models and AI assistant orchestration into Go applications. The library serves as an agent orchestration tool for managing stateful conversation threads and autonomous agents with integrated tool calling and file search. It also functions as an asynchronous batch processing client for monitoring large-scale request groups and fine-tuning jobs, alongside a management SDK for controllin

Evio is a high-performance networking library for Go that provides a non-blocking socket framework. It utilizes an event loop to process TCP, UDP, and Unix domain socket traffic through a low-level asynchronous protocol interface. The project functions as a multi-core network load balancer, distributing connections across multiple CPU cores using round-robin or least-connections strategies. It supports socket reuse, allowing multiple sockets on a single host to bind to the same port. The library covers a broad range of socket management and packet processing capabilities, including multi-pro

Swift NIO is a low-level, event-driven network framework for the Swift language. It serves as an asynchronous network protocol stack and I/O library designed to build high-performance network servers and clients that handle thousands of simultaneous connections. The framework functions as a high-concurrency network engine that dispatches events across multiple CPU cores. It enables the implementation of custom network protocols by processing raw bytes through a sequence of reusable data transformation handlers. The system provides capabilities for non-blocking I/O multiplexing, asynchronous