Network.Wreq

Issue a GET request.

Example:

get "http://httpbin.org/get"
 

>>> r <- get "http://httpbin.org/get">>> r ^. responseStatus . statusCode200

Issue a GET request, using the supplied Options.

Example:

let opts = defaults & param "foo" .~ ["bar"]
getWith opts "http://httpbin.org/get"
 

>>> let opts = defaults & param "foo" .~ ["bar"]>>> r <- getWith opts "http://httpbin.org/get">>> r ^? responseBody . key "url"Just (String "http://httpbin.org/get?foo=bar")

Issue a POST request.

Example:

post "http://httpbin.org/post" (toJSON [1,2,3])
 

>>> r <- post "http://httpbin.org/post" (toJSON [1,2,3])>>> r ^? responseBody . key "json" . nth 2Just (Number 3.0)

Issue a POST request, using the supplied Options.

Example:

let opts = defaults & param "foo" .~ ["bar"]
postWith opts "http://httpbin.org/post" (toJSON [1,2,3])
 

>>> let opts = defaults & param "foo" .~ ["bar"]>>> r <- postWith opts "http://httpbin.org/post" (toJSON [1,2,3])>>> r ^? responseBody . key "url"Just (String "http://httpbin.org/post?foo=bar")

Issue a HEAD request.

Example:

head_ "http://httpbin.org/get"
 

>>> r <- head_ "http://httpbin.org/get">>> r ^? responseHeader "Content-Type"Just "application/json"

Issue a HEAD request, using the supplied Options.

Example:

let opts = defaults & param "foo" .~ ["bar"]
headWith opts "http://httpbin.org/get"
 

>>> let opts = defaults & param "foo" .~ ["bar"]>>> r <- headWith opts "http://httpbin.org/get">>> r ^? responseHeader "Connection"Just "keep-alive"

Issue an OPTIONS request.

Example:

options "http://httpbin.org/get"
 

See atto for a more complex worked example.

Issue an OPTIONS request, using the supplied Options.

Example:

let opts = defaults & param "foo" .~ ["bar"]
optionsWith opts "http://httpbin.org/get"
 

Issue a PUT request.

Issue a PUT request, using the supplied Options.

Issue a PATCH request.

Issue a PATCH request, using the supplied Options.

Issue a DELETE request.

Example:

delete "http://httpbin.org/delete"
 

>>> r <- delete "http://httpbin.org/delete">>> r ^. responseStatus . statusCode200

Issue a DELETE request, using the supplied Options.

Example:

let opts = defaults & redirects .~ 0
deleteWith opts "http://httpbin.org/delete"
 

>>> let opts = defaults & redirects .~ 0>>> r <- deleteWith opts "http://httpbin.org/delete">>> r ^. responseStatus . statusCode200

Issue a custom-method request

Example:

customMethod "PATCH" "http://httpbin.org/patch"

>>> r <- customMethod "PATCH" "http://httpbin.org/patch">>> r ^. responseStatus . statusCode200

Issue a custom request method request, using the supplied Options.

Example:

let opts = defaults & redirects .~ 0
customMethodWith "PATCH" opts "http://httpbin.org/patch"
 

>>> let opts = defaults & redirects .~ 0>>> r <- customMethodWith "PATCH" opts "http://httpbin.org/patch">>> r ^. responseStatus . statusCode200

Issue a custom request method. Keep track of redirects and return the HistoriedResponse

Example:

customHistoriedMethod "GET" "http://httpbin.org/redirect/3"

>>> r <- customHistoriedMethod "GET" "http://httpbin.org/redirect/3">>> length (r ^. hrRedirects)3

Issue a custom request method request, using the supplied Options. Keep track of redirects and return the HistoriedResponse.

Issue a custom-method request with a payload

Issue a custom-method request with a payload, using the supplied Options.

Issue a custom-method historied request with a payload

Issue a custom-method historied request with a paylod, using the supplied Options.

Supported authentication types.

Do not use HTTP authentication unless you are using TLS encryption. These authentication tokens can easily be captured and reused by an attacker if transmitted in the clear.

A lens onto request authentication.

Example (note the use of TLS):

let opts = defaults Control.Lens.& Lens.auth Control.Lens.?~ basicAuth "user" "pass"
getWith opts "https://httpbin.org/basic-auth/user/pass"
 

Basic authentication. This consists of a plain username and password.

Example (note the use of TLS):

let opts = defaults & auth ?~ basicAuth "user" "pass"
getWith opts "https://httpbin.org/basic-auth/user/pass"
 

Note here the use of the Control.Lens.?~ setter to turn an Auth into a Maybe Auth, to make the type of the RHS compatible with the auth lens.

>>> let opts = defaults & auth ?~ basicAuth "user" "pass">>> r <- getWith opts "https://httpbin.org/basic-auth/user/pass">>> r ^? responseBody . key "authenticated"Just (Bool True)

OAuth1 authentication. This consists of a consumer token, a consumer secret, a token and a token secret

An OAuth2 bearer token. This is treated by many services as the equivalent of a username and password.

Example (note the use of TLS):

let opts = defaults & auth ?~ oauth2Bearer "1234abcd"
getWith opts "https://public-api.wordpress.com/rest/v1/me/"
 

A not-quite-standard OAuth2 bearer token (that seems to be used only by GitHub). This will be treated by whatever services accept it as the equivalent of a username and password.

Example (note the use of TLS):

let opts = defaults & auth ?~ oauth2Token "abcd1234"
getWith opts "https://api.github.com/user"
 

AWS v4 request signature.

Example (note the use of TLS):

let opts = defaults & auth ?~ 'awsAuth AWSv4' "key" "secret"
getWith opts "https://dynamodb.us-west-2.amazonaws.com"
 

AWS v4 request signature.

Example (note the use of TLS):

let opts = defaults & auth ?~ awsFullAuth AWSv4 "key" "secret" (Just ("service", "region"))
getWith opts "https://dynamodb.us-west-2.amazonaws.com"
 

AWS v4 request signature using a AWS STS Session Token.

Example (note the use of TLS):

let opts = defaults
           & auth
           ?~ 'awsAuth AWSv4' "key" "secret" "stsSessionToken"
getWith opts "https://dynamodb.us-west-2.amazonaws.com"
 

Define a HTTP proxy, consisting of a hostname and port number.

A lens onto proxy configuration.

Example:

let opts = defaults Control.Lens.& proxy Control.Lens.?~ httpProxy "localhost" 8000
getWith opts "http://httpbin.org/get"
 

Note here the use of the Control.Lens.?~ setter to turn a Proxy into a Maybe Proxy, to make the type of the RHS compatible with the proxy lens.

Proxy configuration.

Example:

let opts = defaults & proxy ?~ httpProxy "localhost" 8000
getWith opts "http://httpbin.org/get"
 

Note here the use of the Control.Lens.?~ setter to turn a Proxy into a Maybe Proxy, to make the type of the RHS compatible with the proxy lens.

A key/value pair for an application/x-www-form-urlencoded POST request body.

A type that can be rendered as the value portion of a key/value pair for use in an application/x-www-form-urlencoded POST body. Intended for use with the FormParam type.

The instances for String, strict Text, and lazy Text are all encoded using UTF-8 before being URL-encoded.

The instance for Maybe gives an empty string on Nothing, and otherwise uses the contained type's instance.

A lens onto the name of the input element associated with part of a multipart form upload.

A lens onto the filename associated with part of a multipart form upload.

A lens onto the content-type associated with part of a multipart form upload.

A lens onto the code that fetches the data associated with part of a multipart form upload.

Make a Part whose content is a strict ByteString.

The Part does not have a file name or content type associated with it.

Make a Part whose content is a lazy ByteString.

The Part does not have a file name or content type associated with it.

Make a Part whose content is a strict Text, encoded as UTF-8.

The Part does not have a file name or content type associated with it.

Make a Part whose content is a String, encoded as UTF-8.

The Part does not have a file name or content type associated with it.

Make a Part from a file.

The entire file will reside in memory at once. If you want constant memory usage, use partFileSource.

The FilePath supplied will be used as the file name of the Part. If you do not want to reveal this name to the server, you must remove it prior to uploading.

The Part does not have a content type associated with it.

Stream a Part from a file.

The FilePath supplied will be used as the file name of the Part. If you do not want to reveal this name to the server, you must remove it prior to uploading.

The Part does not have a content type associated with it.

An element of a Link header.

A lens onto the URL portion of a Link element.

A lens onto the parameters of a Link element.

The error type used by asJSON and asValue if a failure occurs when parsing a response body as JSON.

Convert the body of an HTTP response from JSON to a suitable Haskell type.

In this example, we use asJSON in the IO monad, where it will throw a JSONError exception if conversion to the desired type fails.

 {-# LANGUAGE DeriveGeneric #-}
import GHC.Generics (Generic)

 {- This Haskell type corresponds to the structure of a
   response body from httpbin.org. -}

data GetBody = GetBody {
    headers :: Data.Map.Map Text Text
  , args :: Data.Map.Map Text Text
  , origin :: Text
  , url :: Text
  } deriving (Show, Generic)

 -- Get GHC to derive a FromJSON instance for us.
instance FromJSON GetBody

 {- The fact that we want a GetBody below will be inferred by our
   use of the "headers" accessor function. -}

foo = do
  r <- asJSON =<< get "http://httpbin.org/get"
  print (headers (r Control.Lens.^. responseBody))
 

If we use asJSON in the Either monad, it will return Left with a JSONError payload if conversion fails, and Right with a Response whose responseBody is the converted value on success.

Convert the body of an HTTP response from JSON to a Value.

In this example, we use asValue in the IO monad, where it will throw a JSONError exception if the conversion to Value fails.

foo = do
  r <- asValue =<< get "http://httpbin.org/get"
  print (r Control.Lens.^? responseBody . key "headers" . key "User-Agent")