HTTP for Humans
Requests
Download history. Public code evidence.
Explore the library’s recorded downloads and how public projects use it. Every usage entry links to the source.
01 — Download records
The latest reported counts Check for updates Daily source · delayed updates. A realtime event feed is not connected.
Latest day
34,806,193
2026-10-25 UTC · latest reported day
Last 7 days
330,732,968
2026-10-19 – 2026-10-25 UTC
This month
Pending
Next period — UTC
Historical total
39,565,637,882
From 2016-01-22 · incomplete coverage
Source snapshot available. Data through 2026-10-25 UTC.
Latest day is the most recent day the source has reported; Last 7 days ends on that day. This month is the calendar month so far. All dates are UTC. A card shows Pending only when no data has been reported. These are download records, not unique users.
Enable JavaScript for calendar counts, charts, filtering and interactive details. The historical total above is from the saved snapshot. Download the dated snapshot .
03 — Public project evidence
Where Requests shows up
120 reviewed projects · 116 organization and community labels. Reviewed, non-exhaustive selection of public projects from companies, foundations and open-source communities. Each entry proves the named project and usage scope at a pinned revision, not current runtime activity, company-wide deployment, or token endorsement. Organization counts are distinct directory labels, not a count of corporate parent groups.
Historical SDK usage Separate from the 120-project directory
Historical · v0.28.1 OpenAI · Official Python SDK Historically used in the official Python SDK
OpenAI's official Python SDK v0.28.1 used Requests to send synchronous API calls.
s = requests.Session()
How this version used Requests The client created a Requests session, configured its connection adapter, and sent API calls through that session. Its separate asynchronous path used aiohttp. OpenAI's v1 migration guide documents the later move to HTTPX.
Historical evidence for SDK v0.28.1. This entry does not establish present-day SDK dependencies or live OpenAI activity.
Session source · HTTP call source · OpenAI v1 migration guide
Historical · v0.2.9 Anthropic · Official Python SDK Historically used in the official Python SDK
Anthropic's official Python SDK v0.2.9 used Requests to send synchronous API calls.
self._session = requests.Session()
How this version used Requests The client created a Requests session with a retry adapter, then used that session for HTTP calls to the Anthropic API. Its separate asynchronous path used aiohttp. Later SDK versions moved away from Requests; the migration documentation describes the subsequent HTTPX-to-HTTPX2 transition.
Historical evidence for SDK v0.2.9. This entry does not establish present-day SDK dependencies or live Anthropic activity.
Session source · HTTP call source · Anthropic migration documentation
Search projects
SectorAll sectors Technology Crypto / Web3
CategoryAll categories AI & data Cloud & platforms Crypto & Web3 Developer tools Enterprise software Infrastructure & operations Knowledge & publishing Payments & commerce Science & research Security & identity
SortOrganization Project
Microsoft — Azure CLI : Azure CLI uses Requests in a release-version lookup helper. It downloads a package's setup file from Microsoft's release storage, checks that the server returned a successful response, and reads the version declaration from the returned text. This lets the CLI obtain published version information without relying on a GitHub lookup in that code path. This describes a specific Azure CLI version-check helper, not a measurement of Microsoft-wide usage or currently running downloads.Meta — Facebook Business SDK for Python : The SDK turns a Graph API operation into an HTTP request. It builds the versioned endpoint, adds standard headers, and places parameters in the query string for GET or DELETE, or in the body for other methods. A Requests session carries the call with uploads and timeout settings. The SDK then wraps the returned body, headers, and status in its own response object. This describes the public Business SDK's Graph API transport. It establishes client functionality, without observing Meta's internal systems or live activity.Google — Google Auth for Python : Google Auth offers an optional HTTP transport built on Requests. Its authorized session asks the credential object to prepare authentication headers, then sends the caller's HTTP request through the Requests session. If a response indicates that credentials need refreshing, the wrapper refreshes them and retries within its configured limits. Requests carries the network traffic while Google Auth manages credentials. This is the optional Requests transport in Google Auth; other transports exist, and this is not Google-wide runtime telemetry.Amazon Web Services — SageMaker Core : SageMaker Core's telemetry helper records information about an SDK operation, such as its feature, outcome, environment and elapsed time. When telemetry is enabled, it builds a regional S3 telemetry URL and sends a GET request using Requests. The send runs in a background daemon thread with a short timeout, while request failures are handled without replacing the SDK operation's result. This describes SageMaker Core's configurable telemetry path, not every AWS API request or an independently observed customer deployment.OpenAI — tiktoken : tiktoken's data loader uses Requests when a tokenizer data location starts with HTTP or HTTPS. It retrieves the bytes and raises an error for an unsuccessful HTTP response. The surrounding cache loader can reuse a local copy, check an expected SHA-256 digest and save newly downloaded data, so a usable cached file avoids another download. This covers tiktoken's public HTTP data-loading path, not OpenAI's API SDK or a claim about ChatGPT's internal traffic.NVIDIA — NeMo Speech voice agent : NeMo Speech's voice-agent integration checks whether a vLLM server is already listening on the requested local port. Requests calls the server's models endpoint with a five-second timeout. The helper reads the returned model identifier and can reuse the server when it matches the requested model, avoiding an unnecessary second server startup. The evidence concerns a local server check inside NeMo Speech, not Requests performing inference or monitoring NVIDIA-wide infrastructure.Hugging Face — Diffusers : Diffusers uses Requests in its image and video loading utilities when an input is an HTTP URL. The image path opens the streamed response as a Pillow image, corrects orientation and converts its color format. The video path downloads chunks into a temporary file before converting video frames into images that a calling pipeline can use. These calls load URL-based media inputs; they do not establish that every Diffusers operation or model download uses Requests.Coinbase — Advanced Trade Python SDK : The Advanced Trade Python SDK uses a Requests session as its REST transport. It combines the configured API host with an endpoint path, then sends the selected HTTP method, query parameters, JSON body, headers, and timeout. For authenticated calls, the surrounding code builds a bearer token. The response becomes decoded JSON, with optional rate limit headers and explicit HTTP error handling. This evidence covers the public Python SDK’s client transport; it does not establish how Coinbase’s exchange backend is implemented.Binance — Binance Python connectors : The connectors’ shared Python utilities use a Requests session to dispatch REST API calls. The transport assembles the base URL, endpoint, headers, query parameters, and payload, applying timeout and proxy settings. Signed requests receive a fresh timestamp and signature on each attempt. The surrounding logic interprets HTTP failures, handles rate limiting, and retries selected server errors before decoding the response. The verified scope is shared Python connector code used by API clients, without evidence about Binance’s internal exchange systems.Netflix — Metaflow : Metaflow's service metadata provider keeps a Requests session for communicating with its configured metadata service. It builds URLs for workflow records and sends GET, POST or PATCH calls with the configured service headers. Successful JSON responses are returned to the provider, while its request loop handles failures and retries around the metadata operations. This is Metaflow's service-backed metadata provider; the repository's Netflix ownership does not prove current internal Netflix deployment.Oracle — OCI Python SDK : Oracle's OCI Python SDK uses a bundled copy of Requests inside its shared API client. The client passes the operation's method, URL, parameters, headers, and body to a Requests session, together with the OCI authentication signer. It also controls timeouts and streamed responses. Requests performs the HTTP exchange and returns the service response for further SDK processing. The SDK vendors Requests inside its package; this proves SDK transport usage, not a separate PyPI download or company-wide activity.Alibaba Cloud — OpenAPI Python SDK : Alibaba Cloud's OpenAPI Python SDK builds outgoing HTTP messages with its bundled Requests classes. The transport assembles the service URL, body, and headers, prepares the request in a session, and sends it with proxy, timeout, and certificate-verification settings. It returns the response's status, headers, and content to the SDK layer that handles the cloud operation. This is a vendored Requests transport inside the named OpenAPI SDK, not evidence of every Alibaba product using Requests.Tencent Cloud — Tencent Cloud SDK for Python : Tencent Cloud's Python SDK uses Requests in its shared network transport. An API operation becomes a GET or POST request, and a persistent Requests session sends the URL, headers, and body. The transport supplies proxy settings, certificate verification, a timeout, and streamed response handling. The resulting HTTP response is passed back to the SDK's API-request layer. The proof covers the Python SDK HTTP transport at this revision, not Tencent-wide systems or a live activity feed.Huawei Cloud — Huawei Cloud Python SDK v3 : Huawei Cloud's Python SDK core uses Requests to carry outgoing service calls. It creates a session with connection-pool and retry settings, selects the HTTP method required by the SDK request, and supplies its URL, headers, body, timeout, proxy, and certificate settings. After the network response arrives, the SDK applies its response-error hooks before returning it to the caller. This is the shared HTTP client in the named Python SDK; it does not describe all Huawei Cloud infrastructure.NASA — Harmony Python client : NASA's Harmony Python client uses Requests to submit Earth-science service requests. It turns a validated Harmony request into an HTTP message, including query parameters, JSON, or multipart data when required. A session sends that prepared message to Harmony. The client then interprets the response, returning a job identifier or response content depending on the request and result. This describes the Harmony Python client for Earth-science data services, not spacecraft software or NASA-wide runtime activity.PayPal / Braintree — Braintree Python SDK : Braintree's HTTP helper converts an SDK operation into a prepared Requests request, including its method, endpoint, headers, body, and any files. It obtains a reusable session for the current thread, applies proxy settings, and sends with the configured certificate verification and timeout. The helper returns the HTTP status and text so the SDK can interpret the gateway's response. The evidence covers the public Braintree SDK's HTTP helper. It does not identify merchants, payment volumes, or current PayPal infrastructure activity.Stripe — Stripe Python SDK : Stripe's RequestsClient implementation supplies the network transport for SDK calls that use this client. It creates or reuses a thread-local Requests session, then sends the method, URL, headers, and body with timeout, certificate, and proxy options. It returns response bytes or a raw stream, plus status and headers, and translates connection failures into SDK errors. This describes Stripe's RequestsClient implementation. Other HTTP clients can exist in the SDK; the evidence does not measure Stripe's production traffic.Databricks — Databricks SDK for Python : The Databricks Python SDK's base client creates a reusable Requests session and attaches its authentication callback and HTTPS connection adapter. When an SDK operation reaches the transport layer, it sends the method, URL, parameters and payload through that session. It supports JSON bodies, files and streamed responses, then converts an API error response into the SDK's error form. This identifies the Python SDK's HTTP transport at the pinned revision; it is not evidence of all Databricks backend traffic.Google DeepMind — dm_control : dm_control includes a downloader for CMU motion-capture data fitted to its humanoid models. If the expected data file is not already cached, Requests streams the versioned HDF5 file from the project's storage location. The downloader writes chunks, updates progress and checks the completed file's SHA-256 digest before returning a usable local path. This evidence is the motion-capture dataset downloader, not the physics engine itself or a claim about DeepMind's internal systems.Polymarket — Python Builder Relayer Client : Polymarket’s Python builder relayer client has a small shared HTTP helper built around requests.request. Callers supply the endpoint, method, headers, and data; the helper sends the data as JSON. It checks for the expected successful status, returns a decoded JSON response when possible, and otherwise returns text. Network failures and unsuccessful responses are converted into the client’s relayer exceptions. This is the builder relayer client’s HTTP helper, not evidence that Polymarket’s entire trading platform runs on Requests.Hyperliquid — Hyperliquid Python SDK : The Hyperliquid Python SDK creates a Requests session with a JSON content type and a configurable API base URL. Its shared POST method combines that base with the caller’s path, sends the payload as JSON, and applies a timeout. The same layer converts unsuccessful HTTP responses into client or server exceptions and decodes successful response bodies for the SDK caller. The source establishes an HTTP transport inside the public SDK, not the implementation of Hyperliquid’s exchange or blockchain.Bybit — pybit : Pybit’s HTTP manager uses a Requests session to send prepared API requests. It cleans the supplied parameters, builds the payload, and adds authentication headers when the operation requires them. Each attempt sends the prepared request with the configured timeout, checks the status, and processes the response. Network failures and selected API conditions enter the manager’s retry and error handling paths. This describes Pybit’s client HTTP manager, including its request handling; it does not demonstrate Bybit’s internal exchange architecture.CrowdStrike — FalconPy : FalconPy's request executor gathers the endpoint, query parameters, headers, JSON or form data, and optional files for a Falcon API call. It uses a supplied Requests session when available, or calls Requests directly. The response can remain a stream for downloads, or be converted into FalconPy's result format with status and headers when requested. The evidence covers FalconPy's public API transport, including its download path. It does not reveal customers, protected devices, or current security activity.Datadog — Datadog Python Library : Datadog's Requests-based HTTP client keeps a shared session instead of creating a fresh connection context for every call. It installs an HTTPS adapter with the configured retry setting and adds the library's user-agent. API calls pass headers, query parameters, data, timeouts, proxies, and certificate options through that session; response status and connection failures are handled by the wrapper. This evidence concerns Datadog's HTTP API client implementation. It should not be interpreted as evidence that DogStatsD's separate transport uses Requests.Dropbox — Dropbox Python SDK : Dropbox's client uses Requests to carry three API styles: ordinary JSON operations, file uploads, and file downloads. It constructs the route and authentication headers, puts upload bytes in the body, or enables streaming for downloads. A session sends the POST request, after which the SDK checks errors and returns the appropriate JSON result or downloadable response stream. This describes the public Dropbox Python SDK's transport. It establishes supported file and API workflows, not anyone's private files or live usage.Box — Box Python SDK : Box's network client uses a Requests session to send API requests prepared by the SDK. The request contains the HTTP method, URL, headers, query parameters, body, redirect preference, and timeout. The client requests a streamed response and wraps it in the SDK's response representation. Network exceptions are captured, with additional handling for problems while sending multipart uploads. The evidence covers Box's public SDK network layer, including multipart-related error handling. It does not expose Box customer accounts or current transfers.Mozilla — Add-ons Server : A scheduled-update function in Mozilla's Add-ons Server fetches the configured developer blog endpoint with Requests and a ten-second timeout. It parses the JSON feed, rejects invalid responses, and keeps the latest five posts in the local blog cache. New posts are created, changed posts are updated, and entries outside the latest selection are removed. This is a concrete Add-ons Server maintenance function. The existing production dependency pin remains distinct from this directly inspected application callsite.Uber — Petastorm test suite : Petastorm's Spark dataset-converter example includes a helper that downloads the compressed MNIST dataset with Requests and writes the response bytes to a local file. Another helper first checks for a preloaded copy, otherwise creates a temporary directory and downloads it. Separately, the package lists Requests in its optional test dependencies; this example does not make it a core reader requirement. The directory entry remains scoped to optional test dependencies. The inspected downloader is a supporting example, not Petastorm's core dataset-reading implementation.Pinterest — Querybook : Querybook's Slack notifier uses Requests to deliver messages to Slack users or channels. It takes the configured Slack token, converts the message into its outgoing text format, and builds a JSON body with the recipient and text. For each recipient, it sends an authenticated POST to Slack's chat.postMessage endpoint with a thirty-second timeout. This proves an optional notification integration in Querybook's public code. It does not show Pinterest employees' messages or current internal Slack activity.Adyen — Adyen Python API Library : Adyen's HTTP client can select a Requests-based transport when Requests is available or explicitly requested. That implementation adds either basic authentication or the API-key header, includes the library's user-agent, and submits JSON or form data to the chosen endpoint. It returns the response text, status, and headers to the SDK. Other transport implementations remain available. Requests is an optional Adyen transport, not the only implementation. This code establishes SDK capability without demonstrating a live payment transaction.Akamai — EdgeGrid for Python : EdgeGrid integrates with Requests as an authentication handler. Before an outgoing request is sent, the handler creates a timestamp and nonce, computes the EdgeGrid authorization value, and attaches it to the request header. It also registers a response hook to handle signing for redirects. Requests provides the request object and authentication-hook lifecycle that this plugin extends. This evidence describes an authentication extension for Requests. It does not indicate how much traffic Akamai serves or which customers run it.Akamai — Linode API Python SDK : The Linode Python SDK uses Requests during an OAuth login flow. After a user authorizes an application, the SDK posts the returned exchange code and application credentials to the login service's token endpoint. It checks the response, then extracts the access token, granted permissions, expiry, and refresh token so the application can continue its authenticated workflow. The demonstrated code is the Linode SDK login client, a specific Akamai project rather than evidence of company-wide activity.Algorand — Indexer parity tests : An Algorand Indexer parity test uses Requests to download the Algod OpenAPI specification from the official go-algorand repository on GitHub. The test reads the downloaded JSON and extracts its Account definition, then loads the corresponding definition from the local Indexer specification. These two schemas become the inputs for comparison, helping developers identify differences between the APIs’ documented account structures. The evidence is a developer parity test for API specifications, not Requests carrying Algorand transactions or consensus messages.Apache Software Foundation — Apache Airflow : Airflow uses Requests in a helper that retrieves task logs from a log-serving service. The helper creates a short-lived signed authorization token tied to the requested log filename, makes a streaming HTTP GET with a configured timeout, and marks the response as UTF-8. The returned response lets the surrounding log handler read task output for users inspecting a run. This verifies Airflow Core log retrieval, not every Airflow task, provider integration, or running deployment in the world.Apache Software Foundation — Apache Beam Python SDK : Apache Beam's Python SDK uses Requests in a Google Compute Engine metadata helper. The helper queries the instance metadata endpoint with Google's required metadata header and a short timeout. One caller retrieves the Dataflow job identifier from custom instance attributes. A successful response returns text; an unavailable metadata service returns an empty value rather than failing the helper. This is a GCP/Dataflow metadata utility inside Beam, not a claim that every pipeline or runner makes this request.Apache Software Foundation — Apache Superset : Superset uses Requests for its optional report-webhook notification feature. When enabled, it builds a notification payload and gathers any report attachments, validates the destination, and posts the message through Requests or a Requests session. Attachments use multipart submission; notifications without files use JSON. The notifier checks the response so delivery failures can be handled by the reporting workflow. This is the feature-gated webhook notifier; the evidence does not imply every Superset installation has webhook delivery enabled.Aptos Labs — Local testnet end-to-end tests : The Aptos CLI end-to-end test helper uses Requests to check whether a local testnet is ready. It polls the node’s /v1 endpoint and the faucet’s /health endpoint, falling back to the faucet root when the health path returns 404. Both services must return a successful status. Otherwise the helper waits and tries again until its startup timeout is reached. This is local test infrastructure that checks service readiness before tests, rather than the Aptos node’s consensus implementation.Auth0 / Okta — Auth0 Python SDK : Auth0's authentication REST client uses Requests for its synchronous HTTP calls. It gathers query parameters, JSON or form data, headers, files, and a configured timeout. Form-encoded endpoints receive an encoded body when needed. After sending, the client can retry responses with HTTP 429 using calculated delays, then passes the final response into its parsing and error-handling logic. The evidence applies to Auth0's synchronous authentication REST client. It does not imply that every component or asynchronous client uses Requests.Ava Labs — ChainSafe Bridge analysis scripts : A token list helper in Ava Labs’ chainsafe-scripts repository uses Requests to retrieve JSON from a URL supplied by its caller. It decodes the HTTP response and passes the resulting fields into a TokenList model. This provides structured token metadata to the surrounding fee analysis code; the helper itself does not calculate fees, submit transactions, or choose a fixed external service. The verified use is a small token metadata loader in analysis tooling, not evidence about Avalanche node internals.BerriAI — LiteLLM CLI : LiteLLM's optional command-line client uses a user-management client to communicate with a configured proxy server. The CLI supplies the base URL and API key, and the client uses Requests to list, inspect, create or delete users through the corresponding endpoints. Responses are checked for authentication or HTTP errors before their JSON is displayed by the CLI. This is the optional CLI's proxy-management path; it does not imply that LiteLLM sends every model-completion request through Requests.Bitcoin Core — Signet faucet helper : Bitcoin Core’s Signet getcoins utility uses a Requests session to interact with a faucet. The script obtains a destination address when necessary, downloads a CAPTCHA while retaining the session cookie, and asks the operator to solve it. It then submits the address and CAPTCHA answer as a form. The response is checked for faucet errors or successful delivery of test coins. This is a contributor utility for Signet test coins, not Bitcoin’s peer protocol, mining logic, or mainnet transaction processing.Bitfinex — Bitfinex Python API client : The Bitfinex Python SDK’s REST middleware uses Requests for both GET and POST calls. It combines a configured host with the selected endpoint, passes query parameters, and adds authentication headers when API credentials are available. POST bodies use the SDK’s JSON encoder. Responses are decoded with its matching decoder, and exchange error responses are translated into the library’s error handling. This evidence concerns the synchronous REST middleware of the public SDK, not Bitfinex’s internal trading or matching systems.Blockstream — Blockstream Satellite : The Blockstream Satellite command line client uses Requests to fetch a USD conversion rate from its configured server’s currency/rate endpoint. It validates the HTTP response and reads the milli-satoshi rate from the JSON payload. A short cache avoids fetching the same rate repeatedly, while local conversion methods use it to translate between dollars, satoshis, and milli-satoshis for the tool. The verified component handles currency conversion in Satellite CLI tooling; it does not establish Requests as the satellite broadcast transport.Canonical — Snapcraft : Canonical's Snapcraft uses Requests when a package's icon is supplied as an HTTP or HTTPS URL. During asset preparation, it retrieves the remote image and places the returned bytes into the snap's icon asset. The mediated asset path also checks the HTTP response before returning the content and destination. Local icon files take a different path without this download. The shown usage concerns remote icon assets during packaging, not all Snapcraft operations or every application built as a snap.CCXT — Python exchange client : CCXT’s shared synchronous Python exchange implementation sends HTTP requests through a Requests session. Exchange-specific code supplies the URL, method, headers, and body; the transport applies timeout, proxy, and TLS settings and can include uploaded files. It decodes response content and JSON, checks HTTP status, and translates timeouts, connection failures, and other HTTP problems into CCXT’s own exceptions. This covers CCXT’s synchronous Python client transport; supported exchanges are API targets, not organizations shown running CCXT or Requests.Chainlink — Blockchain RPC Exporter : The Blockchain RPC Exporter’s HTTPS interface uses a Requests session to query a configured endpoint with GET or POST. It applies separate connection and response timeouts and measures the duration of successful calls. Additional methods validate REST or JSON-RPC response content and can cache results. This allows the monitoring code to inspect endpoint responses and record the latest query latency. The evidence is endpoint monitoring software in SmartContractKit’s repository, not proof about every Chainlink oracle or protocol component.Chainstack — Uniswap V2 subgraph tutorial : Chainstack Labs’ Uniswap V2 subgraph example uses Requests to execute GraphQL queries stored in local files. The script reads its target subgraph URL from configuration, loads each query, and posts it as a JSON query field with a timeout. It measures the call duration and saves the returned JSON to an output file, making the tutorial’s queries repeatable and inspectable. This is a Chainstack-authored querying example for a Uniswap subgraph, not evidence about Uniswap’s production infrastructure or smart contracts.Checkout.com — Checkout Python SDK : Checkout.com's default HTTP-client builder returns a Requests session. The API client prepares the endpoint, authorization and content headers, optional idempotency key, and JSON data or uploaded file. It delegates the request to that configured HTTP client, checks for HTTP errors, and wraps the response content together with metadata for the caller. This describes Checkout.com's default Python HTTP transport and API wrapper. Applications may configure a different client; no live transaction is being observed.Chia Network — Climate Token Driver : The climate token driver’s ClimateWareHouseCrud component uses Requests to retrieve registry data from a configured Climate Warehouse API. It sends an API key header when available, follows pagination for units and projects, and combines the returned pages. Separate calls retrieve organizations and their metadata. These HTTP reads supply climate registry information to the application, including filters for marketplace-linked records. This evidence concerns the application’s climate registry integration, not Requests acting as the Chia node RPC or consensus transport.ClearML — ClearML Python SDK : ClearML's session layer constructs an API URL from the configured server, service, action and optional API version. It sends the data through a Requests-derived session, adding worker and client headers and selecting a timeout. The code also handles network failures and can refresh an authorization token once after an unauthorized response before retrying the operation. The inspected path is ClearML's online backend API transport; offline mode explicitly skips the request and returns without sending.Cohere — Cohere Python SDK : Cohere's Python SDK uses Requests to obtain the tokenizer configuration needed by its local tokenization helpers. It first checks a model-specific cache and asks the model metadata for the tokenizer URL when needed. After downloading that configuration, it constructs and caches a tokenizer object that local encode and decode operations can reuse. This describes the local-tokenizer helper, not a blanket claim that Cohere's generated API clients use Requests for every endpoint.Comet — Opik Optimizer ColBERT client : Opik Optimizer's ColBERT utility creates a Requests session with retry adapters and submits a search query plus the desired result count to a retrieval server. It reads the JSON response, checks for server errors and extracts the top matching passages. Those results are normalized into the text fields expected by the surrounding retrieval integration. This is the ColBERT retrieval integration within Opik Optimizer, not evidence that every Comet feature or model operation uses Requests.Conda — Conda : Conda uses a Requests-based session for its regular HTTP download path. The downloader opens a temporary file, optionally sends a byte-range header to resume an incomplete download, and streams the server response with connection settings and timeouts. It checks HTTP errors before consuming the data. Some specialized adapters can download directly, so this is not the only possible transfer path. This covers Conda HTTP downloads; specialized storage adapters may use another transfer mechanism, and cached installs need no network download.Consensys — Legacy ethjsonrpc client : Consensys’ legacy ethjsonrpc Python client uses a Requests session to send JSON-RPC calls to a configured Ethereum node host and port. Its shared call method packages the RPC method name, parameters, and request identifier as JSON, then posts the body over HTTP or HTTPS. It checks the response status and JSON structure before returning the result or raising a client exception. This is legacy Consensys client code; it does not establish current company-wide use or Requests inside Ethereum’s consensus implementation.Dell — Python PowerStore : Dell's PowerStore client uses Requests both to establish a management session and to issue subsequent REST calls. Login collects the returned token and authentication cookie. Later requests attach those session details and send either JSON payloads, query parameters, or a plain request, using the configured certificate verification and timeout. This supplies the network layer beneath storage-management operations. The evidence covers the public PowerStore management client. It describes an administrative API workflow without identifying deployed storage systems or live operations.Docker — Docker SDK for Python : Docker's Python SDK builds its low-level Engine API client on Requests.Session. SDK helpers send HTTP GET, POST, PUT, and DELETE operations with configured timeouts, then convert response errors and decode results. Custom transport adapters allow the same client to reach a local Unix socket, Windows named pipe, SSH connection, or HTTP endpoint according to its configuration. This is client-side Docker SDK transport, not the implementation of Docker Engine itself or evidence that every container runs Requests.Docling — Docling document toolkit : Docling's EasyOCR integration uses a shared Requests downloader to obtain selected detection and recognition model archives. Existing files can be reused unless a forced download is requested. The helper streams the archive into an in-memory buffer, optionally reports progress, and passes it back so the integration can extract the model files into its local model directory. This is the EasyOCR model-preparation path; the evidence does not say Requests performs OCR inference or downloads every input document.Dune — Dune Python client : Dune’s synchronous Python API client creates a Requests session with an adapter that retries selected HTTP failures. Its router combines the configured API base, API version, and route, then sends requests with the Dune API key header and timeout. GET calls can return raw responses, while ordinary calls process JSON. POST and PATCH helpers send structured request bodies through the same session. This verifies the synchronous public Python client’s HTTP transport, without establishing how Dune’s query execution backend is implemented.dYdX — V4 governance proposal tooling : A governance helper in dYdX’s v4-chain repository uses Requests to retrieve market, perpetual, and order book pair definitions from configured REST endpoints. It matches the tickers selected for delisting to their identifiers, then constructs proposal messages that change the relevant market state and disable the market map entry. The script prints the resulting proposal JSON for a subsequent governance workflow. The verified script prepares governance proposal data; it does not itself submit the proposal or implement the dYdX trading engine.earthaccess — earthaccess : The community earthaccess library uses Requests sessions for NASA Earthdata authentication-related calls. Its session can carry a bearer token and handle authentication redirects. A demonstrated operation fetches temporary S3 credentials from a data provider's HTTPS endpoint and decodes the JSON response. Another operation posts to Earthdata Login to find or create a token for subsequent access. earthaccess is labeled as a community project; these client authentication calls do not establish ownership or NASA-wide production usage.Elastic — Enterprise Search Python Client : Elastic's Enterprise Search package exposes a named Requests extra alongside its standard dependencies. Installing that extra adds the supported Requests version range to the environment. This establishes an optional integration path, rather than mandatory use for every search call. The inspected package manifest does not identify a specific Requests callsite, so this entry describes dependency configuration only. This is dependency-level evidence for an optional extra; the inspected sources do not establish a specific runtime call.Ethereum — Execution specification tooling : A helper in Ethereum’s execution-specs repository uses Requests to download a particular Linux Geth release archive from the Geth build storage URL. It writes the response bytes to a local archive, extracts the package, moves the Geth executable into place, and removes temporary files. Requests supplies the download step in this developer setup process; the remaining operations use local filesystem utilities. This is an execution-specification setup script, not Requests implementing the Geth node, Ethereum execution rules, or consensus protocol.Explosion — spaCy : spaCy's download command uses Requests to fetch its pipeline compatibility table. It reads the table's JSON and selects versions matching the installed spaCy release, then determines an appropriate version for the requested pipeline. The command subsequently constructs the package download URL and invokes the package installer; Requests' directly verified role here is retrieving the compatibility information. The inspected Requests call retrieves compatibility metadata; package installation is delegated to a separate installer command in this code.F5 — iControl REST Python SDK : F5's iControl REST wrapper composes a Requests session and exposes methods for BIG-IP REST operations. Its GET implementation separates request options from send options, prepares a Requests request, applies the session timeout when needed, and sends through the session. Similar wrappers cover other HTTP methods, giving callers a consistent interface for management API communication. This evidence concerns the public BIG-IP management SDK. It does not establish which appliances, customers, or live network configurations currently use it.fast.ai — fastai image-search utility : fastai's SerpApi image-search helper sends a search term, engine choice and caller-provided API key through Requests. It checks the HTTP response, parses the returned JSON and collects original-image URLs. If more results are needed, it follows the service's next-page link, then removes duplicates and applies the requested maximum before returning the URL list. This helper retrieves image-search results for a caller; it does not show Requests running fastai's neural-network training computations.Filecoin Project — Slate upload examples : Slate’s API documentation includes Python examples that use Requests to upload a local file. The example opens the file in binary mode, supplies an API key in the Authorization header, and sends a multipart POST to uploads.slate.host. A second version places a collection identifier in the upload URL. Requests handles the example’s HTTP upload, while the service receives the file. The evidence is a published Python upload example in Filecoin Project’s Slate repository, not the implementation of Filecoin’s storage protocol.Fireblocks — Key Backup and Recovery Tool : A Tezos helper in Fireblocks’ key recovery tool uses Requests to query the TzStats explorer for an account address. It reads whether that account’s public key has already been revealed. If not, the helper adds a reveal operation before constructing and filling the transaction. Requests provides this external account-status lookup; other code handles the transaction operations and signing-related work. This is one account-status lookup in recovery tooling, not evidence that Requests performs cryptographic recovery or operates Fireblocks custody infrastructure.GoCardless — GoCardless Pro Python Client : GoCardless' API client maps SDK HTTP operations to Requests calls. GET requests carry query parameters, while POST, PUT, and DELETE serialize their bodies as JSON. The client supplies its endpoint and headers, then checks the response for API errors before returning it. Decorated methods also update the client's rate-limit information from the response. The evidence covers the public GoCardless client's HTTP implementation. It does not identify payment customers or confirm that a collection is happening.Hetzner — Hetzner Cloud Python SDK : Hetzner's Python SDK uses a Requests session in its common API client. It combines a relative operation path with the configured API endpoint, attaches the client's headers, and sends the chosen HTTP method. The response reader decodes JSON and turns error responses into SDK exceptions. The request wrapper also retries eligible API failures and timeouts within configured limits. This demonstrates the official Python SDK request path, not live Hetzner customer activity or every service in the company.Hummingbot — Reported Volumes dashboard tooling : Hummingbot’s reporting script uses Requests to call Datadog’s metrics query API with API and application keys. It supplies a query and time range, receives time series, and turns daily volume points into rows grouped by exchange connector. The script sorts those rows and writes a CSV file. The verified HTTP traffic retrieves previously reported metrics rather than placing exchange orders. This evidence covers a metrics export script, without proving that every Hummingbot installation reports data or uses Requests for trading.IBM — IBM Python SDK Core : IBM's SDK core creates a Requests session for its shared service base class. Its send method applies HTTP configuration, cookies, and a default timeout, then delegates the prepared call to that session. Successful responses become detailed results containing parsed JSON, a stream, or response data; unsuccessful responses become API exceptions. This centralizes transport behavior for SDKs using the base service. This evidence covers IBM's public SDK core base service. It does not establish use by every IBM product or reveal current customer activity.Imperva — Imperva Python SDK : Imperva's connection helper assembles a SecureSphere management API URL from the host, port, version, and path. It creates a Requests session, mounts its TLS adapter, and dispatches POST, GET, DELETE, or PUT with configured headers and timeout. Successful JSON responses are decoded for the caller, while missing endpoints and other failures become SDK exceptions. This describes the public SecureSphere SDK connection helper. It does not reveal protected applications, appliance deployments, or current security operations.Intel — Neural Compressor CI log collector : Neural Compressor's CI log collector uses Requests to query the Azure build-artifacts endpoint for a supplied build identifier. It reads the artifact names and download URLs into a lookup table. The script then uses those links when combining tuning and benchmark log entries, replacing placeholder URLs with paths to the relevant model's build artifact. This is a continuous-integration report helper, not the model-compression algorithm or evidence of Requests inside Intel hardware execution.Internet Archive — Internet Archive Python library and CLI : The Internet Archive Python library extends Requests.Session for its archive connection. In the demonstrated metadata method, it builds an item's metadata URL, optionally supplies archive credentials, performs an HTTP GET, and checks for errors. It then returns decoded JSON to the caller. This gives Python programs and the related CLI access to structured information about an archive item. This describes the library documented by Internet Archive, not a measurement of archive visitors or a claim about all backend services.Kubernetes — Kubernetes Python Client : The Kubernetes Python client's configuration loader has a Google authentication path that creates a Requests-backed Google Auth transport. When Google authentication support is available, it obtains default Google credentials and asks them to refresh through that transport. The refreshed credentials can then be used by the configuration flow. This is a specific authentication integration, not the SDK's general API networking implementation. The evidence is an optional Google-auth integration in configuration loading; it does not show all Kubernetes API calls using Requests.KuCoin — Universal SDK for Python : KuCoin’s Universal Python SDK uses Requests as the HTTP transport behind its prepared API calls. It creates a session with configured connection pools, retries, and proxy options, prepares URLs and request bodies, and attaches headers produced by the SDK signer. The transport sends each request with separate connection and read timeouts, runs configured interceptors, and processes the API response for its caller. The source establishes Requests inside the public SDK’s transport, not the implementation or current runtime of KuCoin’s exchange backend.Ledger — Ledger Blue Python loader : Ledger’s Python loader tooling includes an HTTP proxy transport built with Requests. It encodes a device command as hexadecimal, posts it to the proxy’s /send_apdu endpoint, and repeatedly calls /fetch_apdu until a response is available. The returned hexadecimal data is converted back into bytes. This lets the tool exchange device commands through a configured proxy rather than a direct device connection. This verifies an optional HTTP proxy transport in developer loader tooling, not all Ledger wallet traffic or firmware networking.Lido — Oracle healthcheck : The Lido oracle repository includes a command line healthcheck script that uses Requests to probe a supplied URL. It performs a GET with a configurable timeout and disables redirects, then treats only successful HTTP statuses as healthy. Network errors or other statuses produce a failure exit code. This gives the surrounding operational environment a simple way to detect an unhealthy service endpoint. The verified use is an operational healthcheck script, not Requests calculating oracle reports or participating in Lido’s onchain consensus.Lightning AI — PyTorch Lightning serving validator : Lightning's serving validator starts a local process for a model's serving endpoint, then polls its ping endpoint with Requests until it responds successfully. It posts the model's configured test payload to the serve endpoint and records the response. When an expected response is supplied, the validator compares it with the returned JSON before reporting whether validation succeeded. This is local serving validation around a Lightning model; the Requests calls are not the tensor operations that produce its predictions.LlamaIndex — LlamaIndex Core : LlamaIndex Core's image-document representation can hold an image as embedded data, a local path or a URL. For the URL case, its image resolver uses Requests to download the content with connection and read timeouts. It returns those bytes in an in-memory buffer, optionally encoded as base64, so image-consuming code can read a consistent representation. This describes resolving URL-backed ImageDocument content, not a claim that every LlamaIndex connector, model call or query uses Requests.Mercado Pago — Mercado Pago Python SDK : Mercado Pago's HTTP client creates a fresh Requests session for each call and mounts an HTTPS adapter with a retry policy. It forwards the selected method, endpoint, and request options through that session. The result is normalized into a status code and parsed JSON body, with explicit handling for empty responses and invalid JSON. The evidence covers Mercado Pago's public SDK transport. It describes request handling, not live payments, merchants, or transaction throughput.MLflow — MLflow : MLflow's HTTP utilities prepare authentication, certificate settings and request timeouts before sending an operation to a configured service endpoint. The standard transport uses a cached Requests session with connection adapters and a configured retry policy. It executes the requested method and returns the response to the calling API helper, allowing repeated service calls to share the transport configuration. This covers MLflow's standard HTTP transport path; the same module also contains a separate branch using the Databricks SDK.Mollie — Mollie API Client for Python : Mollie's API-key transport creates and reuses a Requests session, enables certificate verification, and configures retry behavior. For each call it formats the endpoint and payload, adds a bearer API key and optional idempotency key, and sends with the configured timeout. Requests supplies the HTTP response, while connection exceptions become Mollie client errors. This evidence describes Mollie's API-key client path. A separate OAuth path also exists; the source does not expose live payments or customer identities.Monero — Python RPC testing framework : Monero’s Python RPC test framework uses Requests to send calls to a configured server. Its JSON helper serializes the request, optionally adds HTTP digest authentication, posts to the selected path, and checks the returned JSON for errors. A separate binary helper sends serialized data, validates the HTTP status, and reads the streamed binary response. These helpers support automated RPC interactions in testing. This is the repository’s Python RPC test framework, not Requests implementing Monero’s peer networking, cryptography, or consensus engine.Mysten Labs — Walrus Python web API example : An official Walrus Python example uses Requests to communicate with a local Walrus client daemon’s web API. It uploads bytes with a PUT to /v1/blobs and a storage-duration parameter, extracts the returned blob identifier, and downloads that blob with GET. The example generates test data, compares the downloaded bytes with the original content, and reports timing for the round trip. The evidence is a Python web API example for a local Walrus client, not the storage network’s internal protocol implementation.NASA — Python CMR API client : NASA's Python CMR client uses Requests to query the Common Metadata Repository. It builds the search URL from the configured query, sends HTTP GET requests with page-size parameters and headers, and checks each response. JSON entries are collected or yielded to the caller. A continuation header tells the client how to request the next page of matching metadata. This is a client for searching Earthdata metadata; the shown calls do not download the underlying scientific data files themselves.NEAR Protocol — Nearcore test metrics helper : A NEAR test helper uses Requests to read a node’s Prometheus metrics endpoint from a supplied URL. It checks the HTTP status, decodes the text, and parses the metrics into structured values. The helper extracts processed blocks, transaction counts, memory usage, and timing histograms, making those measurements available to tests that inspect node behavior and performance. This evidence is a Python test metrics collector, not Requests carrying NEAR transactions or replacing the node’s peer networking.Odoo — Odoo : Odoo's Unsplash integration uses Requests to search for images. It reads configured Unsplash access credentials, filters incoming search options to supported fields, and sends an authenticated GET to the photo-search API with a timeout. A successful response returns image-search JSON to Odoo; configuration or HTTP failures produce an error result for the integration to handle. This is the web_unsplash add-on in Odoo; it does not imply that every Odoo installation enables this integration.OpenStack — Keystoneauth : OpenStack's Keystoneauth library uses Requests as the network layer beneath its authentication-aware session. Before sending an authenticated call, it obtains authentication headers and adds them to the outgoing message. Its send helper delegates the HTTP exchange to a Requests session and translates connection, timeout, and TLS failures into Keystoneauth errors that calling OpenStack clients can handle. This describes the Keystoneauth client library, not the internals of every OpenStack service or a census of deployed clouds.Optimism — OP Analytics GitHub helper : An Optimism analytics helper uses Requests to call GitHub’s repository contents API. The caller supplies a repository owner, repository name, and file path; the helper constructs the API URL and decodes the response JSON. It returns GitHub’s download_url field so other code can locate the file. The active function resolves that URL; the separate download code shown below it is commented out. The verified use is a repository metadata helper in analytics tooling, not the Optimism node, sequencer, or bridge transport.OVHcloud — OVHcloud Python API client : OVHcloud's Python API client uses a Requests session to send API operations. In its application-key authentication path, it builds the target URL, serializes any JSON body, computes an authentication signature, and adds the required headers. The session then sends the selected HTTP method with the configured timeout and returns the response to the API client. This details the application-key path of the Python client; the same file also offers a separately configured OAuth authentication path.PaddlePaddle — PaddleOCR : PaddleOCR's API client creates a Requests session with bearer authentication for its configured processing service. It can submit a document URL or upload a local file, then retrieve job or batch status. A separate Requests GET downloads the result JSONL from its result URL and parses each nonempty line into an object returned to the caller. This is PaddleOCR's remote-service client; it does not establish Requests as the implementation of local OCR model inference.Poetry — Poetry : Poetry uses Requests in its repository-aware HTTP authenticator. It finds credentials for the destination, constructs a request with optional basic authentication, and prepares it in a reusable session. The sender applies certificate, proxy, streaming, and timeout settings before the network exchange. It returns successful responses and retries selected temporary failures, helping package-repository interactions work with public or authenticated sources. This is Poetry application networking for repository interactions, not a claim that packages installed by Poetry themselves use Requests.Project Jupyter — JupyterHub : JupyterHub includes an official example that uses Requests to control a user's notebook server through the Hub API. It creates a session carrying a service token, checks the user's server state, posts a start command, and reads progress events until ready. The example later sends a delete request and polls until the server has stopped. This demonstrates the repository example client; it does not show the Hub server using Requests for its internal traffic.Pyth Network — Pyth Observer mapping tool : Pyth Observer’s mapping script uses Requests to fetch feed metadata and latest price updates from the Hermes API. It decodes the responses, batches price queries by feed identifier, and converts price values using their exponents. The wider script matches Pyth assets with CoinGecko entries to build a mapping file. The verified Requests calls supply Hermes data for this monitoring support workflow. This is an observer support script that reads public API data, not evidence that Requests publishes Pyth prices onchain.Python Packaging Authority — pip : pip uses its bundled copy of Requests to download package files. Its download helper sends a streaming GET through PipSession, checks HTTP errors, and returns the response for download processing. When resuming an interrupted transfer, it adds a byte-range header and, when possible, a file-version condition. This supports package retrieval while pip handles the installation workflow around it. pip vendors Requests inside its distribution, so this usage need not create a separate Requests package download from PyPI.PyTorch — Workflow statistics helper : PyTorch's statistics helper uses Requests to call GitHub's workflow-artifacts API with authentication supplied by the CI environment. It follows pagination and selects artifacts whose names match a requested prefix. Another Requests call downloads the selected archive bytes to a local file, making those workflow outputs available to the statistics-processing tools. This code supports PyTorch's CI statistics workflow; it is not evidence that training, autograd or tensor operations depend on HTTP calls.Qdrant — FastEmbed : FastEmbed retains an archive-download path for models with an explicit URL source. Its downloader uses Requests to stream the archive into a local file, checks HTTP failures and updates progress while writing chunks. The model-management layer can then unpack that archive into its cache. This is separate from the preferred Hugging Face path used by the built-in model sources. This is the explicit URL and legacy-cache path; the code notes built-in models are no longer downloaded from the old bucket.Ray — Dashboard submission client : Ray's dashboard submission client uses Requests for HTTP communication with a configured cluster. One concrete use is checking whether a runtime package already exists and uploading it when needed. The client builds the package endpoint, sends its bytes with a PUT request, and carries configured cookies, headers and TLS verification settings through the shared request helper. This describes the submission client's runtime-package transport, not Ray's distributed task-execution protocol or all communication between cluster workers.Razorpay — Razorpay Python SDK : Razorpay's client creates a Requests session unless the caller provides one. It builds the API URL, chooses the authentication details, and invokes the session method matching the operation. Successful responses are decoded, and API errors are translated. When retries are enabled, connection failures and timeouts can be retried with bounded exponential delays and jitter. This describes Razorpay's public SDK request dispatcher and optional retry behavior. It does not establish current payment activity or merchant adoption.Red Hat — Ansible AWX : AWX uses Requests in its webhook notification backend. It selects a configured POST or PUT operation, serializes the notification body, and combines the HTTP headers and optional authentication. After validating the destination, it sends the payload through Requests and inspects the response, including controlled redirect handling. This lets an automation workflow deliver job-related notifications to another service. This is the AWX webhook notifier, not proof that every automation job or every Red Hat product uses Requests.Rucio — Rucio client : Rucio's client uses a Requests session to communicate with its server. The shared sender adds the Rucio authentication token, account context, and other headers, then dispatches GET, PUT, POST, or DELETE calls. It can stream responses and applies configured timeouts and certificate settings. The surrounding logic handles failures and retries so client operations can receive server responses. This is the Rucio client transport; it does not establish use by every scientific institution or describe every data-transfer protocol.Safe — Safe-eth-py : Safe’s Python library includes a shared helper that constructs a Requests session for HTTP clients. It configures connection pool sizes, optional retry behavior, and whether callers wait when a pool is full, then mounts the adapter for HTTP and HTTPS. A related wrapper converts transport and decoding failures into library-level exceptions. The helper supplies networking infrastructure without choosing an application endpoint itself. The evidence establishes shared HTTP infrastructure in Safe’s Python library, not Requests executing Safe smart contracts or every wallet operation.Salt Project — Salt : Salt offers a Requests backend in its HTTP utility. When that backend is selected, the utility creates a session, applies authentication, headers, cookies, proxies, and certificate verification, and sends the requested HTTP operation. It can submit ordinary data or multipart form content and check response errors. Salt also contains alternative backends, so Requests is one supported execution path. This is a selectable HTTP backend in Salt; other backends exist, and not every Salt operation needs an HTTP request.Sentry — Sentry Server : Sentry's server defines a session class that extends Requests. Its request method applies a thirty-second default timeout, delegates the actual HTTP call to Requests, and assigns UTF-8 when the response has no encoding. A SafeSession variant adds Sentry's user-agent and specialized adapters for outbound connection handling. This provides reusable HTTP behavior for server components. This evidence covers Sentry's shared server HTTP utility. It does not identify a specific integration call or measure Sentry event-ingestion traffic.Spotify — Luigi : Luigi selects its Requests-backed fetcher when that transport is available. The fetcher maintains a session and posts encoded scheduler requests to the configured remote scheduler. It raises HTTP errors and returns response text, which the scheduler proxy parses as JSON. The proxy adds retry behavior, and the fetcher recreates its session after a process identifier changes. Requests is an available scheduler transport rather than a universal requirement here; Luigi falls back to a urllib-based fetcher when needed.Stability AI — Generative Models checkpoint helper : Stability AI's generative-models code contains a helper for obtaining the VGG LPIPS checkpoint. If the checkpoint is missing, or an optional existing-file check fails, Requests streams it to a local file while progress is displayed. The helper then computes the downloaded file's MD5 digest and compares it with the expected value before returning the checkpoint path. This is the LPIPS checkpoint-preparation utility, not proof that image generation or every Stability AI service runs through Requests.Stellar — Stellar Core overlay survey tooling : Stellar Core’s overlay survey script uses Requests to call a chosen node’s HTTP endpoints when it is not running in simulation mode. It reads peer information and node metadata, then repeatedly retrieves survey results containing network topology data. The script uses those responses to track surveyed peers and build its view of the overlay network. Requests is the survey tool’s HTTP client. This is an administrative network survey script in the repository, not Requests implementing Stellar Core’s consensus or peer protocol.Streamlit — Streamlit : Streamlit's network utility uses Requests to contact an external IP-check service when it needs the current machine's public address. It tries the configured HTTP endpoint and then HTTPS as a fallback, validates the returned text and caches a valid address. The code identifies this as best-effort information for the external URL banner and an origin-allowlist fallback. This is Streamlit's external-address discovery helper, not a claim that Requests transports every browser interaction or application data operation.TensorFlow — TPU worker helper : TensorFlow's TPU worker helper uses Requests to query Google Cloud's instance metadata service. It reads values such as the worker number, accelerator type, network endpoints and host IP address. Those responses are used to set environment variables for the TPU worker's identity, controller address and relevant topology before the helper starts the worker service. This is a Cloud TPU startup helper; it does not show Requests performing TensorFlow's numerical computation or general training communications.Trezor — Firmware repository tooling : A market data utility in the Trezor firmware repository uses Requests to query CoinMarketCap’s API with an API key header. It retrieves cryptocurrency listings in USD and additional metadata, then saves the results in a local JSON cache. Later lookups use that data to identify coins or obtain a price. The cache limits repeated API calls during the tool’s use. This is a Python data utility under common tools, not evidence of Requests running inside Trezor hardware wallet firmware.Twilio — Twilio Python Helper Library : Twilio's synchronous HTTP client builds a Requests request from the method, endpoint, parameters, headers, and authentication supplied by the SDK. It selects JSON or form data according to content type, prepares the request in a session, merges proxy and environment settings, and sends with timeout and redirect options. The resulting status, text, and headers become a Twilio response object. The evidence concerns Twilio's public synchronous SDK HTTP client. It does not prove that a message or call is being delivered now.Ultralytics — Ultralytics YOLO : Ultralytics' download utility uses Requests to transfer a remote file into a temporary partial file. When retrying an interrupted download, it can send a byte-range header and continue from previously written bytes. The code checks HTTP responses and expected sizes before publishing the completed file, while optional progress reporting tracks the transfer. This is Ultralytics' asset-download utility; an explicit curl path also exists, and the evidence does not describe model inference.vLLM — vLLM inference engine : vLLM's media connector can load an HTTP media URL through its shared connection helper. On the synchronous path, that helper creates or reuses a Requests session and retrieves the content as bytes with timeouts and download-size controls. The connector then passes those bytes to the selected media decoder so the calling code can consume the media. This covers synchronous remote-media loading; the inspected helper uses aiohttp for its asynchronous path, and Requests does not perform model inference.Weights & Biases — W&B Python SDK : The W&B Python SDK first queries its service for a direct URL to an artifact's manifest. It then uses a configured Requests session to download the manifest JSON from that URL and converts the content into its artifact-manifest representation. The session factory applies extra HTTP headers, connection pooling, retries and response-status checking for artifact-storage access. This describes Python-side artifact-manifest retrieval, not a claim that all W&B experiment logging or backend services use Requests.Wikimedia — Pywikibot : Pywikibot uses a shared Requests session in its HTTP communication layer. A site-aware helper prepares the wiki URL, user-agent header, and certificate settings, then delegates the network call to that session. The response passes through error handling and text-encoding selection before reaching the caller. The helper also reads retry timing so the bot can respect the site's response. This proves the Pywikibot client communication layer, not that Wikimedia servers or every edit on a wiki run through Requests.XRP Ledger — Developer portal wallet example : An XRP Ledger desktop wallet example uses Requests to retrieve the xrp-ledger.toml file from a domain advertised by an account. It decodes the account’s Domain field, builds the standard HTTPS well-known URL, and parses the downloaded TOML. The function checks whether that file lists the same account address. This demonstrates a domain association check within the sample wallet workflow. This is a documentation example for checking domain association, not proof of a person’s identity or XRP Ledger node implementation.Yearn — DeFi monitoring HTTP helper : Yearn’s monitoring repository includes an HTTP helper that uses Requests to call a URL selected by its caller. It applies a timeout, checks the status, and retries rate limiting, server failures, and connection problems with increasing delays. Other client errors are raised immediately. A companion function decodes successful JSON responses, giving monitoring code a common way to read external services. The verified component is shared monitoring HTTP code, not Requests executing Yearn vault smart contracts or establishing live production activity.Yelp — Bravado : Bravado's Requests client turns an API operation's parameters into an authenticated Requests request and wraps it in a future-style result. Its adapter prepares the request in a reusable session, merges certificate and proxy settings, and sends with timeout and redirect options. The returned response is adapted so Bravado's generated API interface can process it consistently. This describes Yelp's public Bravado library and its Requests backend. It does not demonstrate use by every Yelp service or observe live traffic.Zcash — Integration smoke tests : Zcash’s integration smoke tests use a Requests session to interact with a testnet faucet. The helper first visits the faucet to obtain a CSRF cookie, then submits a destination address and token with the required Referer header. Another helper retrieves donation address data as JSON. These HTTP calls provide supporting faucet interactions for tests that need testnet funds and address information. This evidence covers testnet faucet helpers in integration tests, not mainnet coin creation or the Zcash node’s consensus implementation.
04 — Check the source
What the numbers can tell us
Download counts come from the public ClickPy / ClickHouse replica of PyPI logs. The daily series uses its aggregate table; the historical baseline uses a raw-table count. They can differ.
The history starts in 2016, not at Requests’ first release. Missing days are not zero. Downloads can include automated builds and repeated or partial transfers; they do not identify a company running the library.
Counts update only when a new source snapshot arrives. The countdown marks the next UTC period. No per-second estimate is added to the totals.
Download the 25 Oct 2026 audit · PyPI source documentation · Download-count definitions
Project entries are reviewed against public source code at a specific commit. SDKs, tests, examples, optional dependencies and production components keep their actual scope. Presence in a repository does not establish current company-wide deployment or endorsement of a token.
Refreshes are shared and attempted at most hourly on visits. Failed checks keep the last snapshot and wait ten minutes before retrying. Data freshness is shown separately from the time of the latest check.
Reproduce the download queries
