{"id":2690,"date":"2020-04-18T11:22:12","date_gmt":"2020-04-18T11:22:12","guid":{"rendered":"https:\/\/www.staging6.machinelearningplus.com\/?p=2690"},"modified":"2022-10-10T11:16:43","modified_gmt":"2022-10-10T11:16:43","slug":"requests-in-python","status":"publish","type":"post","link":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/","title":{"rendered":"Requests in Python Tutorial – How to send HTTP requests in Python?"},"content":{"rendered":"

Requests is an elegant and simple Python library built to handle HTTP requests in python easily. It allows you make GET, POST, PUT and other types of requests and process the received response in a flexible Pythonic way.<\/em><\/p>\r\n

Contents<\/h2>\r\n
    \r\n
  1. Introduction to Requests Library<\/li>\r\n
  2. What is a GET and POST request?<\/li>\r\n
  3. GET Method<\/li>\r\n
  4. Status Code<\/li>\r\n
  5. Contents of the Response Object<\/li>\r\n
  6. The Content<\/li>\r\n
  7. Full HTML source as Text<\/li>\r\n
  8. Retrieving an image from website<\/li>\r\n
  9. Headers<\/li>\r\n
  10. How to set Query String Parameters<\/li>\r\n
  11. POST Method<\/li>\r\n
  12. PUT Method<\/li>\r\n
  13. DELETE Method<\/li>\r\n
  14. PATCH Method<\/li>\r\n
  15. HEAD Method<\/li>\r\n
  16. Request Header<\/li>\r\n
  17. Inspecting the request made<\/li>\r\n
  18. Authentication<\/li>\r\n
  19. Time out<\/li>\r\n
  20. SSL Certification<\/li>\r\n<\/ol>\r\n

    Introduction to Requests Library<\/h2>\r\n

    Requests is an elegant and simple Python library built to handle HTTP requests in python easily.<\/strong> But what is a HTTP request? HTTP is a set of protocols designed to enable communication between clients and servers.<\/strong><\/p>\r\n

    A client is typically a local computer or device similar to what you are using to view this page. A HTTP request is the message sent (or received) from your local computer to a web server hosting, typically hosting a website.<\/p>\r\n

    For example, when you go to any internet website from your browser, the browser is sending a HTTP request and receives an appropriate ‘response’ from the host server.<\/p>\r\n

    Requests is an easy-to-use library with a lot of features ranging from passing additional parameters in URLs, sending custom headers, SSL Verification, processing the received response etc.<\/p>\r\n\r\n\r\n\r\n

    What is a GET and POST request?<\/h2>\r\n

    A GET request is used to request data from a specific server<\/strong>. It is the most common type of request.<\/p>\r\n

    This is synonymous to you visiting the homepage of a website from your browser. Another common type of request is the POST request, which is used to send data to a host server for further processing, like, to update a resource, such as a database.<\/strong><\/p>\r\n

    What is this synonymous to in real world?<\/p>\r\n

    For example, most data that you submit through forms in various websites is sent and processed as a POST request. Besides this, using requests you can add additional content like header information, form data, multipart files, and parameters via simple Python libraries. You don’t need to manually append the query strings to your URLs.<\/p>\r\n

    What does that practically mean?<\/p>\r\n

    For example, if you search for something, say the string ‘babies’ in google, your browser sends a GET request to Google server by appending the query string to the url.<\/p>\r\n

    So if you check the url in your address bar, you should see something like: https:\/\/www.google.com\/search?q=babies<\/code> Sometimes, there are more information making the query strings complex to construct.<\/p>\r\n

    With requests<\/code> library, you don’t have to explicity construct such query strings. But rather pass it as additional parameter to requests.get()<\/code>.<\/p>\r\n

    What makes requests really stand out is, the received response is packages as a standardized Response<\/code> object. It will contain all the response data (status, content, cookies etc). This makes further inspection and manipulation reliable and convenient.<\/p>\r\n

    Let’s start by downloading the requests library using: pip install requests<\/code>.<\/p>\r\n

    !pip install<\/span> requests\r\n<\/code><\/pre>\r\n
    Then import the library to use it in your program use the import requests<\/code> command.<\/p>\r\n
    import<\/span> requests\r\nfrom<\/span> pprint import<\/span> pprint  # prettyprint<\/span>\r\n<\/code><\/pre>\r\n
    Now let’s look into the details of request library and some of the important features.<\/p>\r\n
    GET Method<\/h2>\r\n
    Lets try to get some information from the official python website – https:\/\/www.python.org\/<\/a>. You can use any public site. All you need to do is call requests.get(url_name)<\/code>.<\/p>\r\n
    When you ping a website or portal for information it’s considered as ‘making a request’. requests.get()<\/code> is used exactly for this purpose. You need to specify the web address that you need to ping as an argument to the function.<\/p>\r\n
    r<\/span> = requests.get('https:\/\/www.python.org\/'<\/span>)\r\n<\/code><\/pre>\r\n
    The information that we got from the website will be stored in the Response<\/code> object we created r<\/code>. You can extract many features from this response object, like if you need to get the cookies that server sent, all you need to do is print r.cookies<\/code>.<\/p>\r\n
    Now as I have requested the data from the website, to check whether it has worked properly, let’s try priniting the r<\/code> value.<\/p>\r\n
    print<\/span>(r)<\/span><\/span>\r\n<\/code><\/pre>\r\n
    <Response [200]<\/span>>\r\n<\/code><\/pre>\r\n
    You can see that we have got Resonse [200]<\/code>. Let’s look into what this means.<\/p>\r\n
    STATUS Code<\/h2>\r\n
    Status codes are issued by a server in response to a client’s request made to the server.<\/strong> Use the r.status_code<\/code> command to return the status code for your request.<\/p>\r\n
    print<\/span>(r.status_code)<\/span><\/span>\r\n<\/code><\/pre>\r\n
    200<\/span>\r\n<\/code><\/pre>\r\n
    We have got a response of 200 which means the request is success. A response of 200<\/strong> means Success<\/strong>. A response of 300<\/strong> means Redirected<\/strong>. A response of 400<\/strong> means Client Error<\/strong>.<\/p>\r\n
    A response of 500<\/strong> means Server Error<\/strong>. A response of 404<\/strong> means Page Not Found Error<\/strong>. In general, any status code less than 400 means, the request was processed successfully.<\/p>\r\n
    If it is 400 and above, some sort of error occurred. You may need to use the if else statement about whether to further proceed into the code depending upon the status code you recieved from the server, as you don’t need to further run your program after you have got an error. Use the following code below in that case:<\/p>\r\n
    if<\/span> r.status_code<\/span> == 200<\/span>:\r\n    print('Success'<\/span>)\r\nelif r.status_code<\/span> == 404<\/span>:\r\n    print(\"Page not found\"<\/span>)\r\n<\/code><\/pre>\r\n
    Success<\/span>\r\n<\/code><\/pre>\r\n
    \u00a0<\/h4>\r\n
     <\/p>\r\n
    Contents of the Response object<\/h2>\r\n
    dir(r)<\/code> function is used to get details about what all useful information we can get from the data we retrived.<\/strong><\/p>\r\n
    r_attribs = [c<\/span> for<\/span> c<\/span> in<\/span> dir(r) if<\/span> not c<\/span>.startswith(\"_\"<\/span>)]\r\nr_attribs\r\n<\/code><\/pre>\r\n
    ['apparent_encoding<\/span>',\r\n 'close<\/span>',\r\n 'connection<\/span>',\r\n 'content<\/span>',\r\n 'cookies<\/span>',\r\n 'elapsed<\/span>',\r\n 'encoding<\/span>',\r\n 'headers<\/span>',\r\n 'history<\/span>',\r\n 'is_permanent_redirect<\/span>',\r\n 'is_redirect<\/span>',\r\n 'iter_content<\/span>',\r\n 'iter_lines<\/span>',\r\n 'json<\/span>',\r\n 'links<\/span>',\r\n 'next<\/span>',\r\n 'ok<\/span>',\r\n 'raise_for_status<\/span>',\r\n 'raw<\/span>',\r\n 'reason<\/span>',\r\n 'request<\/span>',\r\n 'status_code<\/span>',\r\n 'text<\/span>',\r\n 'url<\/span>']\r\n<\/code><\/pre>\r\n
    You can see that there are several commands available such as headers<\/code>, status_code<\/code>, content<\/code>, cookies<\/code> etc. You can also use help(r)<\/code> command to get more info about each of these. I’m showing some of the help info that’s useful below.<\/p>\r\n
    print(help<\/span>(r<\/span>))\r\n<\/code><\/pre>\r\n
    Help on<\/span> Response in<\/span> module<\/span> requests.models object<\/span>:\r\n\r\nclass<\/span> Response(builtins.object<\/span>)\r\n |  The :class<\/span>:`Response <Response>` object<\/span>, which contains a\r\n |  server's response to an HTTP request.<\/span>\r\n |  \r\n |  Methods defined here:\r\n |  \r\n |  __bool__(self)\r\n |      Returns True<\/span> if<\/span> :attr:`status_code` is<\/span> less than 400.<\/span>\r\n |      \r\n |      This attribute checks if<\/span> the status code of<\/span> the response is<\/span> between\r\n |      400<\/span> and<\/span> 600<\/span> to<\/span> see if<\/span> there was a client error<\/span> or<\/span> a server error<\/span>. If<\/span>\r\n |      the status code, is<\/span> between 200<\/span> and<\/span> 400<\/span>, this will return<\/span> True<\/span>. This\r\n |      is<\/span> **not<\/span>** a check to<\/span> see if<\/span> the response code is<\/span> ``200<\/span> OK``.\r\n |  \r\n |  __enter__(self)\r\n |  \r\n |  __exit__(self, *args)\r\n |  \r\n |  __getstate__(self)\r\n |  \r\n |  __init__(self)\r\n |      Initialize self.  See help(type(self)) for<\/span> accurate signature.\r\n |  \r\n |  __iter__(self)\r\n |      Allows you to<\/span> use a response as<\/span> an iterator.\r\n |  \r\n |  __nonzero__(self)\r\n |      Returns True<\/span> if<\/span> :attr:`status_code` is<\/span> less than 400.<\/span>\r\n |      \r\n |      This attribute checks if<\/span> the status code of<\/span> the response is<\/span> between\r\n |      400<\/span> and<\/span> 600<\/span> to<\/span> see if<\/span> there was a client error<\/span> or<\/span> a server error<\/span>. If<\/span>\r\n |      the status code, is<\/span> between 200<\/span> and<\/span> 400<\/span>, this will return<\/span> True<\/span>. This\r\n |      is<\/span> **not<\/span>** a check to<\/span> see if<\/span> the response code is<\/span> ``200<\/span> OK``.\r\n |  \r\n |  __repr__(self)\r\n |      Return<\/span> repr(self).\r\n |  \r\n |  __setstate__(self, state)\r\n |  \r\n |  close(self)\r\n |      Releases the connection back to<\/span> the pool. Once this method has been\r\n |      called the underlying ``raw`` object<\/span> must not<\/span> be accessed again.\r\n |      \r\n |      *Note: Should not<\/span> normally need to<\/span> be called explicitly.*\r\n |  \r\n |  iter_content(self, chunk_size=1<\/span>, decode_unicode=False<\/span>)\r\n |      Iterates over the response data.  When<\/span> stream=True<\/span> is<\/span> set<\/span> on<\/span> the\r\n |      request, this avoids reading the content at once into<\/span> memory for<\/span>\r\n |      large responses.  The chunk size is<\/span> the number of<\/span> bytes it should\r\n |      read into<\/span> memory.  This is<\/span> not<\/span> necessarily the length of<\/span> each<\/span> item\r\n |      returned as<\/span> decoding can take<\/span> place.\r\n |      \r\n |      chunk_size must be of<\/span> type int or<\/span> None. A value of<\/span> None will\r\n |      function<\/span> differently depending on<\/span> the value of<\/span> `stream`.\r\n |      stream=True<\/span> will read data as<\/span> it arrives in<\/span> whatever size the\r\n |      chunks are received. If<\/span> stream=False<\/span>, data is<\/span> returned as<\/span>\r\n |      a single<\/span> chunk.\r\n |      \r\n |      If<\/span> decode_unicode is<\/span> True<\/span>, content will be decoded using<\/span> the best\r\n |      available encoding based on<\/span> the response.\r\n |  \r\n |  iter_lines(self, chunk_size=512<\/span>, decode_unicode=False<\/span>, delimiter=None)\r\n |      Iterates over the response data, one line at a time.  When<\/span>\r\n |      stream=True<\/span> is<\/span> set<\/span> on<\/span> the request, this avoids reading the\r\n |      content at once into<\/span> memory for<\/span> large responses.\r\n |      \r\n |      .. note:: This method is<\/span> not<\/span> reentrant safe.\r\n |  \r\n |  json(self, **kwargs)\r\n |      Returns the json-encoded content of<\/span> a response, if<\/span> any.\r\n |      \r\n |      :param \\*\\*kwargs: Optional<\/span> arguments that ``json.loads`` takes.\r\n |      :raises ValueError: If<\/span> the response body does not<\/span> contain valid json.\r\n |  \r\n |  raise_for_status(self)\r\n |      Raises stored :class<\/span>:`HTTPError`, if<\/span> one occurred.\r\n |  \r\n |  ----------------------------------------------------------------------\r\n |  Data descriptors defined here:\r\n |  \r\n |  __dict__\r\n |      dictionary for<\/span> instance variables (if<\/span> defined)\r\n |  \r\n |  __weakref__\r\n |      list of<\/span> weak references to<\/span> the object<\/span> (if<\/span> defined)\r\n |  \r\n |  apparent_encoding\r\n |      The apparent encoding, provided by<\/span> the chardet library.\r\n |  \r\n |  content\r\n |      Content of<\/span> the response, in<\/span> bytes.\r\n |  \r\n |  is_permanent_redirect\r\n |      True<\/span> if<\/span> this Response one of<\/span> the permanent versions of<\/span> redirect.\r\n |  \r\n |  is_redirect\r\n |      True<\/span> if<\/span> this Response is<\/span> a well-formed HTTP redirect that could have\r\n |      been processed automatically (by<\/span> :meth:`Session.resolve_redirects`).\r\n |  \r\n |  links\r\n |      Returns the parsed header links of<\/span> the response, if<\/span> any.\r\n |  \r\n |  next<\/span>\r\n |      Returns a PreparedRequest for<\/span> the next<\/span> request in<\/span> a redirect chain, if<\/span> there is<\/span> one.\r\n |  \r\n |  ok\r\n |      Returns True<\/span> if<\/span> :attr:`status_code` is<\/span> less than 400<\/span>, False<\/span> if<\/span> not<\/span>.\r\n |      \r\n |      This attribute checks if<\/span> the status code of<\/span> the response is<\/span> between\r\n |      400<\/span> and<\/span> 600<\/span> to<\/span> see if<\/span> there was a client error<\/span> or<\/span> a server error<\/span>. If<\/span>\r\n |      the status code is<\/span> between 200<\/span> and<\/span> 400<\/span>, this will return<\/span> True<\/span>. This\r\n |      is<\/span> **not<\/span>** a check to<\/span> see if<\/span> the response code is<\/span> ``200<\/span> OK``.\r\n |  \r\n |  text<\/span>\r\n |      Content of<\/span> the response, in<\/span> unicode<\/span>.\r\n |      \r\n |      If<\/span> Response.encoding is<\/span> None, encoding will be guessed using<\/span>\r\n |      ``chardet``.\r\n |      \r\n |      The encoding of<\/span> the response content is<\/span> determined based solely on<\/span> HTTP\r\n |      headers, following RFC 2616<\/span> to<\/span> the letter. If<\/span> you can take<\/span> advantage of<\/span>\r\n |      non-HTTP knowledge to<\/span> make a better guess at the encoding, you should\r\n |      set<\/span> ``r.encoding`` appropriately before accessing this property<\/span>.\r\n |  \r\n |  ----------------------------------------------------------------------\r\n |  Data and<\/span> other attributes defined here:\r\n |  \r\n |  __attrs__ = ['_content', 'status_code', 'headers', 'url', 'history', '...<\/span>\r\n\r\nNone\r\n<\/code><\/pre>\r\n
    The Content<\/h2>\r\n
    The output from the requests.get()<\/code>, that is, the Response<\/code> object contains many useful information. Use the r.content<\/code> command to get the access to the raw data we recieved as output.<\/strong><\/p>\r\n
    This is the raw output of the html content behind the URL we requested, which in this case is https:\/\/www.python.org\/<\/a>.<\/p>\r\n
    # Printing first<\/span> 200<\/span> characters\r\nprint<\/span>(r.content<\/span>[:200<\/span>])\r\n<\/code><\/pre>\r\n
    b'<!doctype html><\/span>\\n<!--[if lt IE 7]>   <html class=\"no-js ie6 lt-ie7 lt-ie8 lt-ie9\">   <![endif]--><\/span>\\n<!--[if IE 7]>      <html class=\"no-js ie7 lt-ie8 lt-ie9\">          <![endif]--><\/span>\\n<!--[if IE 8]>      <h'<\/span>\r\n<\/code><\/pre>\r\n
    While .content<\/code> gives you access to the raw bytes of the response, you need to convert them into a string using a character encoding such as UTF-8.<\/p>\r\n
    You get that directly by using another stored attribute in the response called the r.text<\/code>.<\/p>\r\n
    The Full HTML source as Text<\/h2>\r\n
    Use the text()<\/code> command to get the content from the website as a unicode response.<\/strong> Unicode is a standard way for encoding characters. Unicode string is a python data structure that can store zero or more unicode characters. This output should match with what you see when you right click on the webpage and view its page source.<\/p>\r\n
    print<\/span>(r.text[:800<\/span>])<\/span><\/span>\r\n<\/code><\/pre>\r\n
    <!doctype html><\/span>\r\n<!--[if lt IE 7]>   <html class=\"no-js ie6 lt-ie7 lt-ie8 lt-ie9\">   <![endif]--><\/span>\r\n<!--[if IE 7]>      <html class=\"no-js ie7 lt-ie8 lt-ie9\">          <![endif]--><\/span>\r\n<!--[if IE 8]>      <html class=\"no-js ie8 lt-ie9\">                 <![endif]--><\/span>\r\n<!--[if gt IE 8]><!--><\/span><html<\/span> class<\/span>=\"no-js\"<\/span> lang<\/span>=\"en\"<\/span> dir<\/span>=\"ltr\"<\/span>><\/span>  <!--<![endif]--><\/span>\r\n\r\n<head<\/span>><\/span>\r\n    <meta<\/span> charset<\/span>=\"utf-8\"<\/span>><\/span>\r\n    <meta<\/span> http-equiv<\/span>=\"X-UA-Compatible\"<\/span> content<\/span>=\"IE=edge\"<\/span>><\/span>\r\n\r\n    <link<\/span> rel<\/span>=\"prefetch\"<\/span> href<\/span>=\"\/\/ajax.googleapis.com\/ajax\/libs\/jquery\/1.8.2\/jquery.min.js\"<\/span>><\/span>\r\n\r\n    <meta<\/span> name<\/span>=\"application-name\"<\/span> content<\/span>=\"Python.org\"<\/span>><\/span>\r\n    <meta<\/span> name<\/span>=\"msapplication-tooltip\"<\/span> content<\/span>=\"The official home of the Python Programming Language\"<\/span>><\/span>\r\n    <meta<\/span> name<\/span>=\"apple-mobile-web-app-title\"<\/span> content<\/span>=\"Python.org\"<\/span>><\/span>\r\n    <meta<\/span> name<\/span>=\"apple-mobile-web-app-capable\"<\/span> co<\/span><\/span>\r\n<\/code><\/pre>\r\n
    Retrieving an image from the website<\/h2>\r\n
    Use the same requests.get()<\/code> command to retrieve the image. I am using the image from the url – https:\/\/www.python.org\/static\/img\/python-logo.png<\/code> The received response is also a Response<\/code> object. The image is stored in r.content<\/code>, which you can write to a file.<\/p>\r\n
    This means, whatever be the content of the received response, be it text or image, it is stored in the content<\/code> attribute.<\/p>\r\n
    # Retrieve<\/span> image and<\/span> save in<\/span> local<\/span>\r\nr = requests.get(\"https:\/\/www.python.org\/static\/img\/python-logo.png\"<\/span>)\r\n\r\n# 'wb'<\/span> represents write byte mode\r\nwith<\/span> open<\/span>('file<\/span>.png','wb'<\/span>) as<\/span> f:\r\n    f.write(r.content)\r\n<\/code><\/pre>\r\n
    The image from the website will be downloaded to the folder in which you are running the program.<\/p>\r\n
    Headers<\/h2>\r\n
    Most webpages you visite will contain header, which contains various metadata. Use the r.headers<\/code> command to access the information in the header of the page.<\/strong> What does r.header<\/code> contain? If you look at the output from the r.header<\/code>, you\u00e2\u20ac\u2122ll see that it is actually a serialized JSON content.<\/p>\r\n
    More information like metadata about the response, it is stored in the header. It gives you many information such as the content type of the response payload, a time limit on how long to cache the response, and more. This will return you a dictionary-like object, allowing you to access header values by key.<\/p>\r\n
    # Header contents<\/span>\r\nfor<\/span> key, value<\/span> in<\/span> r.headers.items<\/span>():\r\n  print(key, \":\"<\/span>, value<\/span>)\r\n<\/code><\/pre>\r\n
    Server : nginx<\/span>\r\nContent-Type<\/span> : <\/span>text\/html; charset=utf-8<\/span>\r\nX-Frame-Options : DENY<\/span>\r\nVia : 1.1 vegur<\/span>, 1.1<\/span> varnish, 1.1<\/span> varnish\r\nContent-Length : 48918\r\nAccept<\/span>-Ranges : bytes<\/span>\r\nDate : Fri<\/span>, 17<\/span> Apr 2020<\/span> 05<\/span>:55<\/span>:13<\/span> GMT\r\nAge : 1334\r\nConnection : keep<\/span>-alive\r\nX-Served-By : cache<\/span>-bwi5145-BWI, cache-dca17774-DCA\r\nX-Cache : HIT<\/span>, HIT\r\nX-Cache-Hits : 3, 2\r\nX-Timer : S1587102914.994481<\/span>,VS0,VE0\r\nVary : Cookie<\/span>\r\nStrict-Transport-Security : max<\/span>-age=63072000<\/span>; includeSubDomains\r\n<\/code><\/pre>\r\n
    As you can see, it gives information about the content type, last modified date, Age of the website etc.. You can access each one of these by considering the ouput from the function as dictionary.<\/p>\r\n
    r.headers<\/span>['Content-Length'<\/span>]\r\n<\/code><\/pre>\r\n
    '48918<\/span>'\r\n<\/code><\/pre>\r\n
    Advanced Functions<\/h2>\r\n
    Now as we have looked into the basics of the requests library, lets dive into some of the advanced functions From now onwards, I will be using the website – http:\/\/httpbin.org\/<\/a> to retrive as well as send and store information. Let’s try the commands that you have learned so far.<\/p>\r\n
    How to Set Query String Parameters<\/h2>\r\n
    Often the response given by the server differs based on the query you send. Like, you want to view the 2nd page of a 10 page article, instead of the first page.<\/p>\r\n
    Or you want to search for a particular term in a website. In such cases, you will send additional parameters as part of the URL as a query. For example: https:\/\/www.google.com\/search?q=babies<\/code> will return the search results of ‘babies’.<\/p>\r\n
    Depending on the device you are using, location, referring source, user etc, these queries can easily get complicated. So instead of adding it in the url directly, using requests.get()<\/code>, you can pass it as a separate parameter using the params<\/code> argument. Let’s add couple of parameters to the query string, that is, page=5<\/code> and count=10<\/code> of httpbin.org<\/code>.<\/p>\r\n
    This essentially translates as “http:\/\/httpbin.org\/?page=5&count=10<\/a>“.<\/p>\r\n
    # Setting parameters\r\nparameter= {'page'<\/span>:5<\/span> , 'count'<\/span>:10<\/span>}\r\nr=requests.get<\/span>('http:\/\/httpbin.org\/'<\/span>, params=parameter)\r\nprint<\/span>(r.text<\/span>[:600<\/span>])\r\n<\/code><\/pre>\r\n
    <!DOCTYPE html><\/span>\r\n<html<\/span> lang<\/span>=\"en\"<\/span>><\/span>\r\n\r\n<head<\/span>><\/span>\r\n    <meta<\/span> charset<\/span>=\"UTF-8\"<\/span>><\/span>\r\n    <title<\/span>><\/span>httpbin.org<\/title<\/span>><\/span>\r\n    <link<\/span> href<\/span>=\"https:\/\/fonts.googleapis.com\/css?family=Open+Sans:400,700|Source+Code+Pro:300,600|Titillium+Web:400,600,700\"<\/span>\r\n        rel<\/span>=\"stylesheet\"<\/span>><\/span>\r\n    <link<\/span> rel<\/span>=\"stylesheet\"<\/span> type<\/span>=\"text\/css\"<\/span> href<\/span>=\"\/flasgger_static\/swagger-ui.css\"<\/span>><\/span>\r\n    <link<\/span> rel<\/span>=\"icon\"<\/span> type<\/span>=\"image\/png\"<\/span> href<\/span>=\"\/static\/favicon.ico\"<\/span> sizes<\/span>=\"64x64 32x32 16x16\"<\/span> \/><\/span>\r\n    <style<\/span>><\/span>\r\n        html<\/span> {\r\n            box-sizing<\/span>: border-box;\r\n            overflow<\/span>: -moz-scrollbars-vertical;\r\n            overflow-y<\/span>: scroll;\r\n        }\r\n\r\n        *,<\/span>\r\n<\/code><\/pre>\r\n
    You can see that I have first created a dictionary for the parameters and then I passed it into the get()<\/code> function. And we got a json response back from the httpbin website.<\/p>\r\n
    To check whether the parameter passing has worked properly, use r.url<\/code> to check the parameters we have passed.<\/strong><\/p>\r\n
    print<\/span>(r.url)<\/span><\/span>\r\n<\/code><\/pre>\r\n
    http:<\/span>\/\/httpbin.org<\/span>\/?page=5<\/span>&count=10<\/span>\r\n<\/code><\/pre>\r\n
    It has worked properly as the page is set to 5 and the count is set to 10. You can also pass it as a tuple or a byte which will give the same output.<\/p>\r\n
    # Setting parameters<\/span>\r\nparameter= (('page'<\/span>,5<\/span>) , ('count'<\/span>,10<\/span>))\r\nr=requests.get<\/span>('http:\/\/httpbin.org\/'<\/span>, params<\/span>=parameter)\r\nprint(r.text<\/span>[:400<\/span>])\r\n<\/code><\/pre>\r\n
    <!DOCTYPE html><\/span>\r\n<html<\/span> lang<\/span>=\"en\"<\/span>><\/span>\r\n\r\n<head<\/span>><\/span>\r\n    <meta<\/span> charset<\/span>=\"UTF-8\"<\/span>><\/span>\r\n    <title<\/span>><\/span>httpbin.org<\/title<\/span>><\/span>\r\n    <link<\/span> href<\/span>=\"https:\/\/fonts.googleapis.com\/css?family=Open+Sans:400,700|Source+Code+Pro:300,600|Titillium+Web:400,600,700\"<\/span>\r\n        rel<\/span>=\"stylesheet\"<\/span>><\/span>\r\n    <link<\/span> rel<\/span>=\"stylesheet\"<\/span> type<\/span>=\"text\/css\"<\/span> href<\/span>=\"\/flasgger_static\/swagger-ui.css\"<\/span>><\/span>\r\n    <link<\/span> rel<\/span>=\"icon\"<\/span> type<\/span>=\"image\/png\"<\/span> href<\/span>=\"\/static\/favicon.ico\"<\/span> si<\/span><\/span>\r\n<\/code><\/pre>\r\n
    POST Method<\/h2>\r\n
    The POST method is used to submit data to be further handled by the server.<\/strong> The server typically understands the context and knows what to do with the data.<\/p>\r\n
    Generally it’s used while submitting a web form or when uploading a file to the server. The requests.post()<\/code> function allows you to do this. Let’s look into an example with httpbin.org<\/code> website.<\/p>\r\n
    # POST request<\/span>\r\nparam = { 'custname'<\/span>:'abcd'<\/span>, 'custemail'<\/span>: 'efgh@gmail.com'<\/span>}\r\nr = requests.post('http:\/\/httpbin.org\/post'<\/span>, data=param)\r\n\r\n# As we are getting a json response, instead of using the text command, I am using json().<\/span>\r\npprint(r.json())\r\n<\/code><\/pre>\r\n
    {'args'<\/span>: {},\r\n 'data'<\/span>: ''<\/span>,\r\n 'files'<\/span>: {},\r\n 'form'<\/span>: {'custemail'<\/span>: 'efgh@gmail.com'<\/span>, 'custname'<\/span>: 'abcd'<\/span>},\r\n 'headers'<\/span>: {'Accept'<\/span>: '*\/*'<\/span>,\r\n             'Accept-Encoding'<\/span>: 'gzip, deflate'<\/span>,\r\n             'Content-Length'<\/span>: '40'<\/span>,\r\n             'Content-Type'<\/span>: 'application\/x-www-form-urlencoded'<\/span>,\r\n             'Host'<\/span>: 'httpbin.org'<\/span>,\r\n             'User-Agent'<\/span>: 'python-requests\/2.21.0'<\/span>,\r\n             'X-Amzn-Trace-Id'<\/span>: 'Root=1-5e9c69e3-44d2f060dfeb7a401ffe7c28'<\/span>},\r\n 'json'<\/span>: None,\r\n 'origin'<\/span>: '35.196.30.16'<\/span>,\r\n 'url'<\/span>: 'http:\/\/httpbin.org\/post'<\/span>}\r\n<\/code><\/pre>\r\n
    You can see in the form type the custname<\/code> and the custemail<\/code> has been recorded. If you need to pass some form values into it, then you need to look into the source of the url and find out what kind of values the form expects.<\/p>\r\n
    To process the received json response, iterate through the contents of r.json()<\/code>.<\/p>\r\n
    Or if you know what the contents, you can access it directly as you would with a dict<\/code>.<\/p>\r\n
    for<\/span> k, v in<\/span> r.json().items():\r\n  print<\/span>(k, \": \"<\/span>, v)\r\n<\/code><\/pre>\r\n
    args :<\/span>  {}\r\ndata :<\/span>  \r\nfiles :<\/span>  {}\r\nform :<\/span>  {'custemail'<\/span>: 'efgh@gmail.com'<\/span>, 'custname'<\/span>: 'abcd'<\/span>}\r\nheaders :<\/span>  {'Accept'<\/span>: '*\/*'<\/span>, 'Accept-Encoding'<\/span>: 'gzip, deflate'<\/span>, 'Content-Length'<\/span>: '40'<\/span>, 'Content-Type'<\/span>: 'application\/x-www-form-urlencoded'<\/span>, 'Host'<\/span>: 'httpbin.org'<\/span>, 'User-Agent'<\/span>: 'python-requests\/2.21.0'<\/span>, 'X-Amzn-Trace-Id'<\/span>: 'Root=1-5e9c69e3-44d2f060dfeb7a401ffe7c28'<\/span>}\r\njson :<\/span>  None\r\norigin :<\/span>  35.196<\/span>.30<\/span>.16<\/span>\r\nurl :<\/span>  http:<\/span>\/\/httpbin.org\/post<\/span>\r\n<\/code><\/pre>\r\n
    Post function can be used to send large amount of data (text \/ binary) data.<\/p>\r\n
    PUT Method<\/h2>\r\n
    The PUT method requests that the data you are sending to be stored under the supplied URL.<\/strong> If the URL refers to an already existing resource, it is modified and if the URL does not point to an existing resource, then the server creates the resource with that URL. As you can see, the PUT is somewhat similar in functionality to POST.<\/p>\r\n
    So what is the difference between PUT and POST? The difference is, the POST method sends data to a URI and the the receiving resource understands the context and knows how to handle the request. Whereas, in a PUT method, if there is a file in the given URI, it gets replaced. And if there isn’t any, a file is created.<\/p>\r\n
    Besides, not matter how many times you execute a given PUT request, the resulting action is always the same. This property is called idempotence. Whereas, for a POST method, the response need not always be the same. This makes the PUT method idempotent and the POST method is not. To make a PUT request, use the requests.put()<\/code> method.<\/p>\r\n
    import requests \r\nr = requests.put('https:\/\/httpbin.org\/put'<\/span>, data ={'name'<\/span>:'abcd'<\/span>})\r\nprint<\/span>(r)<\/span><\/span> \r\nprint<\/span>(r.content)<\/span><\/span>\r\n<\/code><\/pre>\r\n
    <Response<\/span> [200<\/span>]>\r\nb'{\\n  \"args\"<\/span>: {}, \\n  \"data\"<\/span>: \"\"<\/span>, \\n  \"files\"<\/span>: {}, \\n  \"form\"<\/span>: {\\n    \"name\"<\/span>: \"abcd\"<\/span>\\n  }, \\n  \"headers\"<\/span>: {\\n    \"Accept\"<\/span>: \"*\/*\"<\/span>, \\n    \"Accept-Encoding\"<\/span>: \"gzip, deflate\"<\/span>, \\n    \"Content-Length\"<\/span>: \"9\"<\/span>, \\n    \"Content-Type\"<\/span>: \"application\/x-www-form-urlencoded\"<\/span>, \\n    \"Host\"<\/span>: \"httpbin.org\"<\/span>, \\n    \"User-Agent\"<\/span>: \"python-requests\/2.21.0\"<\/span>, \\n    \"X-Amzn-Trace-Id\"<\/span>: \"Root=1-5e997c61-9382102be4038f1b7f1352d0\"<\/span>\\n  }, \\n  \"json\"<\/span>: null, \\n  \"origin\"<\/span>: \"35.221.187.164\"<\/span>, \\n  \"url\"<\/span>: \"https:\/\/httpbin.org\/put\"<\/span>\\n}\\n'\r\n<\/code><\/pre>\r\n
    Generally in practice, put()<\/code> function is used for updating operations and post()<\/code> function is used for creating operations.<\/p>\r\n
    DELETE Method<\/h2>\r\n
    The delete() method sends a DELETE request to the specified url. DELETE requests are made for deleting the specified resource (file, record etc). A successful response should be:<\/p>\r\n
      \r\n
    1. 200 (OK)<\/strong> if the response includes an entity describing the status.<\/li>\r\n
    2. 202 (Accepted)<\/strong> if the action has not yet been enacted<\/li>\r\n
    3. 204 (No Content)<\/strong> if the action has been enacted but the response does not include an entity.<\/li>\r\n<\/ol>\r\n
      import requests \r\nr = requests.delete('https:\/\/httpbin.org\/delete'<\/span>, data ={'name'<\/span>:'abcd'<\/span>}) \r\nprint<\/span>(r)<\/span><\/span> \r\nprint<\/span>(r.json()<\/span><\/span>)\r\n<\/code><\/pre>\r\n
      <Response [200<\/span>]>\r\n{'args'<\/span>: {}, 'data'<\/span>: ''<\/span>, 'files'<\/span>: {}, 'form'<\/span>: {'name'<\/span>: 'abcd'<\/span>}, 'headers'<\/span>: {'Accept'<\/span>: '*\/*'<\/span>, 'Accept-Encoding'<\/span>: 'gzip, deflate'<\/span>, 'Content-Length'<\/span>: '9'<\/span>, 'Content-Type'<\/span>: 'application\/x-www-form-urlencoded'<\/span>, 'Host'<\/span>: 'httpbin.org'<\/span>, 'User-Agent'<\/span>: 'python-requests\/2.21.0'<\/span>, 'X-Amzn-Trace-Id'<\/span>: 'Root=1-5e997dff-2b42c5cf3ebe64c9d60fa8a8'<\/span>}, 'json'<\/span>: None, 'origin'<\/span>: '35.221.187.164'<\/span>, 'url'<\/span>: 'https:\/\/httpbin.org\/delete'<\/span>}\r\n<\/code><\/pre>\r\n
      The delete()<\/code> function will request the server to delete a resource that you have specified in the URL. The client, however, cannot be guaranteed that the operation has been carried out.<\/p>\r\n
      PATCH Method<\/h2>\r\n
      The PATCH method is a request method supported by the HTTP protocol for making partial changes to an existing resource.<\/strong> The main difference between the PUT and PATCH method is that the PUT method uses the request URL to supply a modified version of the requested resource.<\/strong><\/p>\r\n
      And it replaces the original version of the resource. Whereas, the PATCH method only supplies a set of instructions to modify the resource. This means, the PATCH request needs to contain only the changes that needs to be applied to a resource and not the entire resource. Although it resembles PUT, it typically contains a set of instructions that tell how a resource residing at a URI should be modified to produce a new version. Use the requests.patch()<\/code> command to implement this. So when to use PATCH? Whenever you want to make only partial changes to the resource.<\/p>\r\n
      import requests \r\nr = requests.patch('https:\/\/httpbin.org\/patch'<\/span>, data ={'name'<\/span>:'abcd'<\/span>}) \r\nprint<\/span>(r)<\/span><\/span> \r\npprint<\/span>(r.json()<\/span><\/span>)\r\n<\/code><\/pre>\r\n
      <Response [200<\/span>]>\r\n{'args'<\/span>: {},\r\n 'data'<\/span>: ''<\/span>,\r\n 'files'<\/span>: {},\r\n 'form'<\/span>: {'name'<\/span>: 'abcd'<\/span>},\r\n 'headers'<\/span>: {'Accept'<\/span>: '*\/*'<\/span>,\r\n             'Accept-Encoding'<\/span>: 'gzip, deflate'<\/span>,\r\n             'Content-Length'<\/span>: '9'<\/span>,\r\n             'Content-Type'<\/span>: 'application\/x-www-form-urlencoded'<\/span>,\r\n             'Host'<\/span>: 'httpbin.org'<\/span>,\r\n             'User-Agent'<\/span>: 'python-requests\/2.21.0'<\/span>,\r\n             'X-Amzn-Trace-Id'<\/span>: 'Root=1-5e9c6fd2-fea9a805120b3ab9b59bf62a'<\/span>},\r\n 'json'<\/span>: None,\r\n 'origin'<\/span>: '35.196.30.16'<\/span>,\r\n 'url'<\/span>: 'https:\/\/httpbin.org\/patch'<\/span>}\r\n<\/code><\/pre>\r\n
      HEAD Method<\/h2>\r\n
      head()<\/code> function is useful for retrieving only the meta-information written in response headers<\/strong>, without having to transport the entire content like the get()<\/code> command.<\/p>\r\n
      This method is often used for testing hypertext links for validity, accessibility, and recent modification. You can do this by using the requests.head()<\/code> command with the web address and data as argument.<\/p>\r\n
      import requests \r\nr = requests.head('https:\/\/httpbin.org\/'<\/span>, data ={'key'<\/span>:'value'<\/span>}) \r\nprint<\/span>(r)<\/span><\/span> \r\nprint<\/span>(r.headers)<\/span><\/span> \r\npprint<\/span>(r.text)<\/span><\/span>\r\n<\/code><\/pre>\r\n
      <Response<\/span> [200<\/span>]>\r\n{'Date'<\/span>: 'Sun, 19 Apr 2020 15:45:25 GMT'<\/span>, 'Content-Type'<\/span>: 'text\/html; charset=utf-8'<\/span>, 'Content-Length'<\/span>: '9593'<\/span>, 'Connection'<\/span>: 'keep-alive'<\/span>, 'Server'<\/span>: 'gunicorn\/19.9.0'<\/span>, 'Access-Control-Allow-Origin'<\/span>: '*'<\/span>, 'Access-Control-Allow-Credentials'<\/span>: 'true'<\/span>}\r\n''<\/span>\r\n<\/code><\/pre>\r\n
      Let’s run the same as a GET request and see the difference.<\/p>\r\n
      r = requests.get('https:\/\/httpbin.org\/'<\/span>, data ={'key'<\/span>:'value'<\/span>}) \r\nprint<\/span>(r)<\/span><\/span> \r\nprint<\/span>(r.headers)<\/span><\/span> \r\npprint<\/span>(r.text[:500<\/span>])<\/span><\/span>\r\n<\/code><\/pre>\r\n
      <Response [200<\/span>]>\r\n{'Date'<\/span>: 'Sun, 19 Apr 2020 15:49:24 GMT'<\/span>, 'Content-Type'<\/span>: 'text\/html; charset=utf-8'<\/span>, 'Content-Length'<\/span>: '9593'<\/span>, 'Connection'<\/span>: 'keep-alive'<\/span>, 'Server'<\/span>: 'gunicorn\/19.9.0'<\/span>, 'Access-Control-Allow-Origin'<\/span>: '*'<\/span>, 'Access-Control-Allow-Credentials'<\/span>: 'true'<\/span>}\r\n('<!DOCTYPE html>\\n'<\/span>\r\n '<html lang=\"<\/span>en\">\\n'<\/span>\r\n '\\n'<\/span>\r\n '<head>\\n'<\/span>\r\n '    <meta charset=\"<\/span>UTF-8<\/span>\">\\n'<\/span>\r\n '    <title>httpbin.org<\/title>\\n'<\/span>\r\n '    <link '<\/span>\r\n 'href=\"<\/span>https:\/\/fonts.googleapis.com\/css?family=Open+Sans:400,700|Source+Code+Pro:300,600|Titillium+Web:400,600,700\"\\n'<\/span>\r\n '        rel=\"<\/span>stylesheet\">\\n'<\/span>\r\n '    <link rel=\"<\/span>stylesheet\" type=\"<\/span>text\/css\" '<\/span>\r\n 'href=\"<\/span>\/flasgger_static\/swagger-ui.css\">\\n'<\/span>\r\n '    <link rel=\"<\/span>icon\" type=\"<\/span>image\/png\" href=\"<\/span>\/static\/favicon.ico\" '<\/span>\r\n 'sizes=\"<\/span>64<\/span>x64 32<\/span>x32 16<\/span>x16\" \/>\\n'<\/span>\r\n '    <style>\\n'<\/span>\r\n '        html {\\n'<\/span>\r\n '            box-sizing: border-box;\\n'<\/span>\r\n '          '<\/span>)\r\n<\/code><\/pre>\r\n
      Notice, we received only header content with requests.head()<\/code>. Rest of the content is ignored. So, it will save time and resource if you are interested only in the header content.<\/p>\r\n
      Request Header<\/h2>\r\n
      A request header is an HTTP header that can be used in an HTTP request, and that doesn’t relate to the content of the message.<\/strong><\/p>\r\n
      To customize headers, you pass a dictionary of HTTP headers to get()<\/code> using the headers<\/code> parameter. Through the ‘Accept’ header, the client tells the server what content types your application can handle.<\/p>\r\n
      import<\/span> requests\r\nr=requests.get<\/span>(\"http:\/\/www.example.com\/\"<\/span>, headers={'Accept'<\/span>: 'application\/qrd.github.v1.text+json'<\/span>})\r\nr\r\n<\/code><\/pre>\r\n
      <Response [200]<\/span>>\r\n<\/code><\/pre>\r\n
      Inspecting the request made<\/h2>\r\n
      When you make a request, the requests library prepares the request before actually sending it to the destination server. Request preparation includes things like validating headers and serializing JSON content.<\/strong><\/p>\r\n
      Only after preparing the request, the request will be sent to the destination server. You can view the PreparedRequest by accessing the json.<\/p>\r\n
      # Inspect the URL<\/span>\r\nparam= { 'username'<\/span>:'abcd'<\/span>, 'password'<\/span>: 'efgh'<\/span>}\r\n\r\n# We are passing this param as the data<\/span>\r\nr=requests.post('http:\/\/httpbin.org\/post'<\/span>,data=param)\r\nr.request.url\r\n<\/code><\/pre>\r\n
      'http<\/span>:\/\/httpbin.org\/post'<\/span>\r\n<\/code><\/pre>\r\n
      This helps you in getting access to informations like payload, URL, headers, authentication, and more.<\/p>\r\n
      # Inspect the Parameters<\/span>\r\nparam= { 'username'<\/span>:'abcd'<\/span>, 'password'<\/span>: 'efgh'<\/span>}\r\nr=requests.post('http:\/\/httpbin.org\/post'<\/span>,data=param)\r\n\r\n# As we are getting a json resposne, instead of using the text command, I am using json().<\/span>\r\ndict<\/span>=r.json()\r\nprint(dict<\/span>['form'<\/span>])\r\n<\/code><\/pre>\r\n
      {'password'<\/span>: 'efgh'<\/span>, 'username'<\/span>: 'abcd'<\/span>}\r\n<\/code><\/pre>\r\n
      You can see that I have stored the ouput of the r.json<\/code> in a dictionary and I can accesing different information from the dictionary separately.<\/p>\r\n
      Authentication<\/h2>\r\n
      Authentication helps a service understand who you are.<\/strong> You provide your credentials to a server by passing data through the Authorization header or a custom header defined by the service. You need to use the auth<\/code> command to do this.<\/p>\r\n
      r= requests.get<\/span>('http:\/\/httpbin.org\/basic-auth\/abcd\/efgh'<\/span>, auth=('abcd'<\/span>,'efgh'<\/span>))\r\nprint<\/span>(r.text<\/span>)\r\n<\/code><\/pre>\r\n
      {\r\n  \"authenticated\"<\/span>: true<\/span>, \r\n  \"user\"<\/span>: \"abcd\"<\/span>\r\n}\r\n<\/code><\/pre>\r\n
      What we are doing is we are giving our data to the server by passing data through the authorization<\/code> header. If we go into the httpbins<\/code> website, you can see that the basic authentication format for the website is of the form http:\/\/httpbin.org\/basic-auth\/username\/password<\/code>.<\/strong> In this the username<\/code> and password<\/code> will be what we have specified.<\/p>\r\n
      The authentication output comes out to be ‘true’ which means that our username and password is correct. If our password is wrong, we wont be getting any output for authentication.<\/p>\r\n
      r= requests.get('http:\/\/httpbin.org\/basic-auth\/abcd\/efgh'<\/span>, auth=('abcdfgh'<\/span>,'efgh'<\/span>))\r\nprint<\/span>(r)<\/span><\/span>\r\n<\/code><\/pre>\r\n
      <Response [401]<\/span>>\r\n<\/code><\/pre>\r\n
      You can see that if I use the wrong username, I am getting an 401 error. When you pass your username and password in a tuple to the auth parameter, requests is applying the credentials using HTTP\u00e2\u20ac\u2122s Basic access authentication scheme under the hood.<\/p>\r\n
      Time out<\/h2>\r\n
      When you send a request to a server, your system typically waits for a certain amount of time for the other server to respond. If this takes too much times, then there is a possibility that your system will hang.<\/p>\r\n
      Time-out is set to make sure that the if the website is not responding for a certain amount of time it has to stop loading.<\/strong> If we dont set the timeout then the website will be loading forever if the server is not responding. Use the timeout=<\/code> command to set the time limit in seconds.<\/p>\r\n
      r<\/span>= requests.get('http:\/\/httpbin.org\/basic-auth\/abcd\/efgh'<\/span>, timeout=5<\/span>)\r\n<\/code><\/pre>\r\n
      In the above case, I have set the time limit to 5 seconds.<\/p>\r\n
      You can also pass a tuple to timeout with the first element being a connect timeout<\/strong> (the timeout allows for the client to establish a connection to the server), and the second being a read timeout<\/strong> (the time it will wait on a response once your client has established a connection):<\/p>\r\n
      r<\/span>=requests.get('http:\/\/httpbin.org\/basic-auth\/abcd\/efgh'<\/span>, timeout=(3<\/span>,7<\/span>))\r\n<\/code><\/pre>\r\n
      This means that the request should establish a connection with server before 3 seconds and the data must be recieved within 7 seconds after the connection is established.<\/p>\r\n
      If the request times out, then the function will raise a Timeout exception. You can handle this exception as well by importing Timeout<\/code> from requests.exceptions<\/code>.<\/p>\r\n
      from<\/span> requests.exceptions import<\/span> Timeout\r\n\r\ntry<\/span>:\r\n    response = requests.get('http:\/\/httpbin.org\/basic-auth\/abcd\/efgh'<\/span>, timeout=1<\/span>)\r\nexcept<\/span> Timeout:\r\n    print('Request timed out'<\/span>)\r\nelse<\/span>:\r\n    print('Request went through'<\/span>)\r\n<\/code><\/pre>\r\n
      SSL Certificate Vertification<\/h2>\r\n
      SSL Certificates are small data files that digitally bind a cryptographic key to an organization\u00e2\u20ac\u2122s detail.<\/strong> An organization needs to install the SSL Certificate onto its web server to initiate a secure session with browsers<\/strong>.<\/p>\r\n
      Once a secure connection is established, all web traffic between the web server and the web browser will be secure. If the data you are trying to receive or send is sensitive, then it is done by establishing a encrypted connection using SSL. requests library does this for you by default. If you don’t want to do this, then we can set the paramter verify to be false in the get()<\/code> function.<\/p>\r\n
      requests.get('http<\/span>:\/\/httpbin.org\/basic-auth\/abcd\/efgh', verify=False<\/span>)\r\n<\/code><\/pre>\r\n
      <Response [401]<\/span>>\r\n<\/code><\/pre>","protected":false},"excerpt":{"rendered":"
      Requests is an elegant and simple Python library built to handle HTTP requests in python easily. It allows you make GET, POST, PUT and other types of requests and process the received response in a flexible Pythonic way. Contents Introduction to Requests Library What is a GET and POST request? GET Method Status Code Contents […]<\/p>\n","protected":false},"author":7,"featured_media":3490,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"site-sidebar-layout":"default","site-content-layout":"default","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"default","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[21],"tags":[98,22,97],"class_list":["post-2690","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-http","tag-python","tag-requests"],"acf":[],"yoast_head":"\nRequests in Python Tutorial - How to send HTTP requests in Python? - machinelearningplus<\/title>\n<meta name=\"description\" content=\"Learn how to send HTTP requests in Python using the Requests library. Covers GET, POST, PUT, DELETE methods, headers, parameters, and response handling.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/machinelearningplus.com\/python\/requests-in-python\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Requests in Python Tutorial - How to send HTTP requests in Python? - machinelearningplus\" \/>\n<meta property=\"og:description\" content=\"Learn how to send HTTP requests in Python using the Requests library. Covers GET, POST, PUT, DELETE methods, headers, parameters, and response handling.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/machinelearningplus.com\/python\/requests-in-python\/\" \/>\n<meta property=\"og:site_name\" content=\"machinelearningplus\" \/>\n<meta property=\"article:published_time\" content=\"2020-04-18T11:22:12+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-10-10T11:16:43+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2020\/04\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1280\" \/>\n\t<meta property=\"og:image:height\" content=\"720\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Venmani A D\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Venmani A D\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"21 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/\"},\"author\":{\"name\":\"Venmani A D\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#\\\/schema\\\/person\\\/5496cd92445387e04c3ee0737a78efa0\"},\"headline\":\"Requests in Python Tutorial – How to send HTTP requests in Python?\",\"datePublished\":\"2020-04-18T11:22:12+00:00\",\"dateModified\":\"2022-10-10T11:16:43+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/\"},\"wordCount\":2867,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2020\\\/04\\\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png\",\"keywords\":[\"HTTP\",\"Python\",\"Requests\"],\"articleSection\":[\"Python\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/\",\"name\":\"Requests in Python Tutorial - How to send HTTP requests in Python? - machinelearningplus\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2020\\\/04\\\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png\",\"datePublished\":\"2020-04-18T11:22:12+00:00\",\"dateModified\":\"2022-10-10T11:16:43+00:00\",\"description\":\"Learn how to send HTTP requests in Python using the Requests library. Covers GET, POST, PUT, DELETE methods, headers, parameters, and response handling.\",\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/python\\\/requests-in-python\\\/#primaryimage\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2020\\\/04\\\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png\",\"contentUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2020\\\/04\\\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png\",\"width\":1280,\"height\":720},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#website\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/\",\"name\":\"machinelearningplus\",\"description\":\"Learn Data Science (AI \\\/ ML) Online\",\"publisher\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/machinelearningplus.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#organization\",\"name\":\"machinelearningplus\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2022\\\/05\\\/MachineLearningplus-logo.svg\",\"contentUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/uploads\\\/2022\\\/05\\\/MachineLearningplus-logo.svg\",\"width\":348,\"height\":36,\"caption\":\"machinelearningplus\"},\"image\":{\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/#\\\/schema\\\/person\\\/5496cd92445387e04c3ee0737a78efa0\",\"name\":\"Venmani A D\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/litespeed\\\/avatar\\\/d1b80494908c2c820cbd96a6a804f163.jpg?ver=1776364784\",\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/litespeed\\\/avatar\\\/d1b80494908c2c820cbd96a6a804f163.jpg?ver=1776364784\",\"contentUrl\":\"https:\\\/\\\/machinelearningplus.com\\\/wp-content\\\/litespeed\\\/avatar\\\/d1b80494908c2c820cbd96a6a804f163.jpg?ver=1776364784\",\"caption\":\"Venmani A D\"},\"url\":\"https:\\\/\\\/machinelearningplus.com\\\/author\\\/venmani\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Requests in Python Tutorial - How to send HTTP requests in Python? - machinelearningplus","description":"Learn how to send HTTP requests in Python using the Requests library. Covers GET, POST, PUT, DELETE methods, headers, parameters, and response handling.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/","og_locale":"en_US","og_type":"article","og_title":"Requests in Python Tutorial - How to send HTTP requests in Python? - machinelearningplus","og_description":"Learn how to send HTTP requests in Python using the Requests library. Covers GET, POST, PUT, DELETE methods, headers, parameters, and response handling.","og_url":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/","og_site_name":"machinelearningplus","article_published_time":"2020-04-18T11:22:12+00:00","article_modified_time":"2022-10-10T11:16:43+00:00","og_image":[{"width":1280,"height":720,"url":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2020\/04\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png","type":"image\/png"}],"author":"Venmani A D","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Venmani A D","Est. reading time":"21 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/#article","isPartOf":{"@id":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/"},"author":{"name":"Venmani A D","@id":"https:\/\/machinelearningplus.com\/#\/schema\/person\/5496cd92445387e04c3ee0737a78efa0"},"headline":"Requests in Python Tutorial – How to send HTTP requests in Python?","datePublished":"2020-04-18T11:22:12+00:00","dateModified":"2022-10-10T11:16:43+00:00","mainEntityOfPage":{"@id":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/"},"wordCount":2867,"commentCount":0,"publisher":{"@id":"https:\/\/machinelearningplus.com\/#organization"},"image":{"@id":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/#primaryimage"},"thumbnailUrl":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2020\/04\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png","keywords":["HTTP","Python","Requests"],"articleSection":["Python"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/machinelearningplus.com\/python\/requests-in-python\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/","url":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/","name":"Requests in Python Tutorial - How to send HTTP requests in Python? - machinelearningplus","isPartOf":{"@id":"https:\/\/machinelearningplus.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/#primaryimage"},"image":{"@id":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/#primaryimage"},"thumbnailUrl":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2020\/04\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png","datePublished":"2020-04-18T11:22:12+00:00","dateModified":"2022-10-10T11:16:43+00:00","description":"Learn how to send HTTP requests in Python using the Requests library. Covers GET, POST, PUT, DELETE methods, headers, parameters, and response handling.","inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/machinelearningplus.com\/python\/requests-in-python\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/machinelearningplus.com\/python\/requests-in-python\/#primaryimage","url":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2020\/04\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png","contentUrl":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2020\/04\/MACHINE-LEARNING-PLUS-A-Complete-Beginners-Guide-to-SQLite-IN-Python-3.png","width":1280,"height":720},{"@type":"WebSite","@id":"https:\/\/machinelearningplus.com\/#website","url":"https:\/\/machinelearningplus.com\/","name":"machinelearningplus","description":"Learn Data Science (AI \/ ML) Online","publisher":{"@id":"https:\/\/machinelearningplus.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/machinelearningplus.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/machinelearningplus.com\/#organization","name":"machinelearningplus","url":"https:\/\/machinelearningplus.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/machinelearningplus.com\/#\/schema\/logo\/image\/","url":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2022\/05\/MachineLearningplus-logo.svg","contentUrl":"https:\/\/machinelearningplus.com\/wp-content\/uploads\/2022\/05\/MachineLearningplus-logo.svg","width":348,"height":36,"caption":"machinelearningplus"},"image":{"@id":"https:\/\/machinelearningplus.com\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/machinelearningplus.com\/#\/schema\/person\/5496cd92445387e04c3ee0737a78efa0","name":"Venmani A D","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/machinelearningplus.com\/wp-content\/litespeed\/avatar\/d1b80494908c2c820cbd96a6a804f163.jpg?ver=1776364784","url":"https:\/\/machinelearningplus.com\/wp-content\/litespeed\/avatar\/d1b80494908c2c820cbd96a6a804f163.jpg?ver=1776364784","contentUrl":"https:\/\/machinelearningplus.com\/wp-content\/litespeed\/avatar\/d1b80494908c2c820cbd96a6a804f163.jpg?ver=1776364784","caption":"Venmani A D"},"url":"https:\/\/machinelearningplus.com\/author\/venmani\/"}]}},"_links":{"self":[{"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/posts\/2690","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/comments?post=2690"}],"version-history":[{"count":0,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/posts\/2690\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/media\/3490"}],"wp:attachment":[{"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/media?parent=2690"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/categories?post=2690"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/machinelearningplus.com\/wp-json\/wp\/v2\/tags?post=2690"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}