Requests - Python HTTP Requests for Humans

  •        44

Requests allows you to send organic, grass-fed HTTP/1.1 requests, without the need for manual labor. There's no need to manually add query strings to your URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling are 100% automatic, thanks to urllib3. Requests is one of the most downloaded Python packages of all time, pulling in over 11,000,000 downloads every month.

  • International Domains and URLs
  • Keep-Alive & Connection Pooling
  • Sessions with Cookie Persistence
  • Browser-style SSL Verification
  • Basic/Digest Authentication
  • Elegant Key/Value Cookies
  • Automatic Decompression
  • Automatic Content Decoding
  • Unicode Response Bodies
  • Multipart File Uploads
  • HTTP(S) Proxy Support
  • Connection Timeouts
  • Streaming Downloads
  • .netrc Support
  • Chunked Requests

http://python-requests.org
https://github.com/requests/requests

Tags
Implementation
License
Platform

   




Related Projects

elastic4s - Elasticsearch Scala Client - Non Blocking, Type Safe, HTTP, TCP


Elastic4s is a concise, idiomatic, reactive, type safe Scala client for Elasticsearch. The client can be used over both HTTP and TCP by choosing either of the elastic4s-http or elastic4s-tcp submodules. The official Elasticsearch Java client can of course be used in Scala, but due to Java's syntax it is more verbose and it naturally doesn't support classes in the core Scala core library nor Scala idioms.Elastic4s's DSL allows you to construct your requests programatically, with syntactic and semantic errors manifested at compile time, and uses standard Scala futures to enable you to easily integrate into an asynchronous workflow. The aim of the DSL is that requests are written in a builder-like way, while staying broadly similar to the Java API or Rest API. Each request is an immutable object, so you can create requests and safely reuse them, or further copy them for derived requests. Because each request is strongly typed your IDE or editor can use the type information to show you what operations are available for any request type.

stub-http - Library agnostic way to stub HTTP endpoints in Clojure


A Clojure library designed to stub HTTP responses regardless of which client library that is used to make the actual HTTP requests.There are several client specific "http mocking/stubbing/faking" libraries out there such as clj-http-fake and ring-mock but they work on the level of the library and not the HTTP level. I couldn't find a client agnostic library for stubbing HTTP endpoints so I sat out to write one myself based on nanohttpd. This is useful if you want to test your app against a real HTTP server with actual HTTP requests. And even if you don't want to this it may be your only option if you're (for example) using a Java library that makes HTTP requests and you want to stub/fake its responses.

sling - A Go HTTP client library for creating and sending API requests


Sling is a Go HTTP client library for creating and sending API requests.Slings store HTTP Request properties to simplify sending requests and decoding responses. Check usage or the examples to learn how to compose a Sling into your API client.

presto - PHP REST Orchestration


A REST client to access any services that support RESTful access or any HTTP access method. Supports all HTTP methods including: GET, POST, DELETE, PUT, OPTIONS, HEAD, AUTH, and custom. Simultaneous requests are supported through the use of a queue activation setting. Use of the queue will allow multiple requests to be processed in parallel, which can significantly speed up calls to multiple services or API end points.Presto relies on curl to make all requests. Many customization options are available including custom header additions, referrer, and user agent. Profiling is built-in and all the curl meta data and timing information are logged to assist with troubleshooting and optimization. Failed requests are logged as errors with optional exception throwing. A slow request configuration option allows logging of slow requests to the error log. Failed requests can automatically be retried a configureable number of times after a specified delay.

remote_http_testing - A small library for making remote HTTP requests and response assertions in tests


This module helps write integration tests which make HTTP requests to remote servers. Unlike Rack::Test, it doesn't make requests to an in-process Rack server. It uses Net::HTTP for making requests.To use it, mix it in to your test case, specify the server your integration test is talking to, and begin making requests.



HTTP_Request2


Provides an easy way to perform HTTP requests, uses pluggable adapters* Socket: pure PHP implementation of HTTP protocol (does *not* use http stream wrapper), based on older [PEAR HTTP_Request] package* Curl: wrapper around PHP's cURL extension* Mock: used for testing packages depending on HTTP_Request2, returns predefined responses without network interactionBoth Socket and Curl adapters support POST requests with data and file uploads, basic and digestauthentication, cookies, managing cookies

oauthlib - A generic, spec-compliant, thorough implementation of the OAuth request-signing logic


OAuthLib is a generic utility which implements the logic of OAuth without assuming a specific HTTP request object or web framework. Use it to graft OAuth client support onto your favorite HTTP library, or provide support onto your favourite web framework. If you're a maintainer of such a library, write a thin veneer on top of OAuthLib and get OAuth support for very little effort.Then you might be more interested in using requests which has OAuthLib powered OAuth support provided by the requests-oauthlib library.

toolbelt - A toolbelt of useful classes and functions to be used with python-requests


This is just a collection of utilities for python-requests, but don't really belong in requests proper. The minimum tested requests version is 2.1.0. In reality, the toolbelt should work with 2.0.1 as well, but some idiosyncracies prevent effective or sane testing on that version.On Python 3.3.0 and 3.3.1, the standard library's http module will fail when passing an instance of the MultipartEncoder. This is fixed in later minor releases of Python 3.3. Please consider upgrading to a later minor version or Python 3.4. There is absolutely nothing this library can do to work around that bug.

OkHttp - An HTTP & HTTP/2 client for Android and Java applications


OkHttp is an HTTP & HTTP/2 client for Android and Java applications. It provides HTTP/2 support allows all requests to the same host to share a socket, Connection pooling, Response caching and lot more.

core-http - Prototype of CORE HTTP API


The Python client API requires the [requests][requests-home] and the[ws4py][ws4py-home] modules.[requests-home]: http://docs.python-requests.org

urllib3 - Python HTTP library with thread-safe connection pooling, file post support, sanity friendly, and more


urllib3 is a powerful, sanity-friendly HTTP client for Python. Much of the Python ecosystem already uses urllib3 and you should too. urllib3 brings many critical features that are missing from the Python standard libraries:

chrome-stay-fresh - Chrome extension to reload tabs programmatically via HTTP requests


which accepts HTTP requests on port 7700 and notifies the Chrome extensionwhen those requests are made. The extension itself maintains a list of"listening" tabs which are automatically reloaded (i.e., "refreshed")whenever the **native messaging host** receives a `GET /reload HTTP/1.1`request.This extension is meant to accompany the[vim-stay-fresh](https://github.com/ahw/vim-stay-fresh) Vim plugin and/orthe [vim-hooks](https://github.com/ahw/vim-hooks) Vim plugin. Much likebacon, eggs, and toast,

Postman - A chrome addon, helps to test web services


Postman is a powerful HTTP client to help test web services easily and efficiently. Postman let's you craft simple as well as complex HTTP requests quickly. It also saves requests for future use so that you never have to repeat your keystrokes ever again.

http-client - A simple PHP-based client for making HTTP requests.


A simple PHP-based client for making HTTP requests.

requests-persona - A persona Auth module for requests http python library


A persona Auth module for requests http python library

laravel-requests - Port of Requests library to Laravel http://requests.ryanmccue.info/


Port of Requests library to Laravel http://requests.ryanmccue.info/

lolhttp - A scala HTTP server & client library.


A scala HTTP server & client library.Servers and clients are service functions. A service takes an HTTP request and eventually returns an HTTP response. Requests and responses are a set of HTTP headers along with a content body. The content body is a lazy stream of bytes based on fs2, making it easy to handle streaming scenarios if needed. For additional convenience, the library provides content encoders and decoders for the common scala types. All concepts are shared between servers and clients, making it simple to compose them. SSL is supported on both sides.

requests-mock - Mocked responses for the requests library


requests-mock provides a building block to stub out the HTTP requests portions of your testing code. You should checkout the docs for more information.Everything in requests eventually goes through an adapter to do the transport work. requests-mock creates a custom adapter that allows you to predefine responses when certain URIs are called.

play-requests-limiter - A Play! Framework 2 Filter that limits the concurrently processed requests and queues requests exceeding this limit


This Play! Framework 2 app shows how to limit the concurrently processed requests in an async/non-blocking application. Requests exceeding this limit are queued and processed as soon as other requests are finished.The solution (io.ino.play.ConcurrentRequestsLimiter) works with a limit of concurrently processed requests (configurable via maxProcessedRequests, default 100), so that incoming requests, that would exceed this limit, are queued until other requests are completed. Upon the completion of a request, the oldest queued request will then be processed. Additionally, it's possible to limit the number of queued requests (configurable via maxQueuedRequests, default 10000). Incoming requests that would exceed this limit are then in fact rejected with HTTP status 429 ("Too many requests").