HTTP::Client

Creates a new HTTP client with the given host, port and tls configurations. If no port is given, the default one will be used depending on the tls arguments: 80 for if tls is false, 443 if tls is truthy. If tls is true a new OpenSSL::SSL::Context::Client will be used, else the given one. In any case the active context can be accessed through tls.

Creates a new HTTP client bound to an existing IO. host and port can be specified and they will be used to conform the Host header on each request. Instances created with this constructor cannot be reconnected. Once close is called explicitly or if the connection doesn't support keep-alive, the next call to make a request will raise an exception.

Creates a new HTTP client from a URI. Parses the host, port, and tls configuration from the URI provided. Port defaults to 80 if not specified unless using the https protocol, which defaults to port 443 and sets tls to true.

require "http/client"
require "uri"

uri = URI.parse("https://secure.example.com")
client = HTTP::Client.new(uri)

client.tls? # => #<OpenSSL::SSL::Context::Client>
client.get("/")

This constructor will ignore any path or query segments in the URI as those will need to be passed to the client when a request is made.

If tls is given it will be used, if not a new TLS context will be created. If tls is given and uri is a HTTP URI, ArgumentError is raised. In any case the active context can be accessed through tls.

This constructor will raise an exception if any scheme but HTTP or HTTPS is used.

Creates a new HTTP client from a URI, yields it to the block and closes the client afterwards. Parses the host, port, and tls configuration from the URI provided. Port defaults to 80 if not specified unless using the https protocol, which defaults to port 443 and sets tls to true.

require "http/client"
require "uri"

uri = URI.parse("https://secure.example.com")
HTTP::Client.new(uri) do |client|
  client.tls? # => #<OpenSSL::SSL::Context::Client>
  client.get("/")
end

This constructor will ignore any path or query segments in the URI as those will need to be passed to the client when a request is made.

If tls is given it will be used, if not a new TLS context will be created. If tls is given and uri is a HTTP URI, ArgumentError is raised. In any case the active context can be accessed through tls.

This constructor will raise an exception if any scheme but HTTP or HTTPS is used.

Creates a new HTTP client, yields it to the block, and closes the client afterwards.

require "http/client"

HTTP::Client.new("www.example.com") do |client|
  client.get "/"
end

Executes a DELETE request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

response = HTTP::Client.delete("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a DELETE request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

HTTP::Client.delete("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a DELETE request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

response = HTTP::Client.delete "http://www.example.com", form: "foo=bar"

Executes a DELETE request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

HTTP::Client.delete("http://www.example.com", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a request. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

response = HTTP::Client.exec "GET", "http://www.example.com"
response.body # => "..."

Executes a request. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

HTTP::Client.exec("GET", "http://www.example.com") do |response|
  response.body_io.gets # => "..."
end

Executes a GET request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

response = HTTP::Client.get("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a GET request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

HTTP::Client.get("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a GET request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

response = HTTP::Client.get "http://www.example.com", form: "foo=bar"

Executes a GET request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

HTTP::Client.get("http://www.example.com", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a HEAD request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

response = HTTP::Client.head("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a HEAD request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

HTTP::Client.head("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a HEAD request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

response = HTTP::Client.head "http://www.example.com", form: "foo=bar"

Executes a HEAD request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

HTTP::Client.head("http://www.example.com", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a OPTIONS request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

response = HTTP::Client.options("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a OPTIONS request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

HTTP::Client.options("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a OPTIONS request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

response = HTTP::Client.options "http://www.example.com", form: "foo=bar"

Executes a OPTIONS request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

HTTP::Client.options("http://www.example.com", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a PATCH request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

response = HTTP::Client.patch("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a PATCH request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

HTTP::Client.patch("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a PATCH request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

response = HTTP::Client.patch "http://www.example.com", form: "foo=bar"

Executes a PATCH request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

HTTP::Client.patch("http://www.example.com", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a POST request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

response = HTTP::Client.post("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a POST request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

HTTP::Client.post("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a POST request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

response = HTTP::Client.post "http://www.example.com", form: "foo=bar"

Executes a POST request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

HTTP::Client.post("http://www.example.com", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a PUT request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

response = HTTP::Client.put("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a PUT request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

HTTP::Client.put("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a PUT request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

response = HTTP::Client.put "http://www.example.com", form: "foo=bar"

Executes a PUT request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

HTTP::Client.put("http://www.example.com", form: "foo=bar") do |response|
  response.body_io.gets
end

Configures this client to perform basic authentication in every request.

Adds a callback to execute before each request. This is usually used to set an authorization header. Any number of callbacks can be added.

require "http/client"

client = HTTP::Client.new("www.example.com")
client.before_request do |request|
  request.headers["Authorization"] = "XYZ123"
end
client.get "/"

Closes this client. If used again, a new connection will be opened.

Whether automatic compression/decompression is enabled.

Whether automatic compression/decompression is enabled.

Sets the number of seconds to wait when connecting, before raising an IO::TimeoutError.

require "http/client"

client = HTTP::Client.new("example.org")
client.connect_timeout = 1.5
begin
  response = client.get("/")
rescue IO::TimeoutError
  puts "Timeout!"
end

Sets the open timeout with a Time::Span to wait when connecting, before raising an IO::TimeoutError.

require "http/client"

client = HTTP::Client.new("example.org")
client.connect_timeout = 5.minutes
begin
  response = client.get("/")
rescue IO::TimeoutError
  puts "Timeout!"
end

Executes a DELETE request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new("www.example.com")
response = client.delete("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a DELETE request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new("www.example.com")
client.delete("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a DELETE request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.delete "/", form: "foo=bar"

Executes a DELETE request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.delete("/", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a DELETE request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.delete "/", form: {"foo" => "bar"}

Executes a DELETE request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.delete("/", form: {"foo" => "bar"}) do |response|
  response.body_io.gets
end

Sets the number of seconds to wait when resolving a name, before raising an IO::TimeoutError.

NOTE: dns_timeout is currently only supported on Windows.

require "http/client"

client = HTTP::Client.new("example.org")
client.dns_timeout = 1.5
begin
  response = client.get("/")
rescue IO::TimeoutError
  puts "Timeout!"
end

Sets the number of seconds to wait when resolving a name with a Time::Span, before raising an IO::TimeoutError.

NOTE: dns_timeout is currently only supported on Windows.

require "http/client"

client = HTTP::Client.new("example.org")
client.dns_timeout = 1.5.seconds
begin
  response = client.get("/")
rescue IO::TimeoutError
  puts "Timeout!"
end

Executes a request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.exec "GET", "/"
response.body # => "..."

Executes a request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.exec HTTP::Request.new("GET", "/")
response.body # => "..."

Executes a request. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new "www.example.com"
client.exec("GET", "/") do |response|
  response.body_io.gets # => "..."
end

Executes a request and yields an HTTP::Client::Response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new "www.example.com"
client.exec(HTTP::Request.new("GET", "/")) do |response|
  response.body_io.gets # => "..."
end

Executes a GET request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new("www.example.com")
response = client.get("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a GET request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new("www.example.com")
client.get("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a GET request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.get "/", form: "foo=bar"

Executes a GET request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.get("/", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a GET request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.get "/", form: {"foo" => "bar"}

Executes a GET request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.get("/", form: {"foo" => "bar"}) do |response|
  response.body_io.gets
end

Executes a HEAD request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new("www.example.com")
response = client.head("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a HEAD request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new("www.example.com")
client.head("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a HEAD request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.head "/", form: "foo=bar"

Executes a HEAD request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.head("/", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a HEAD request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.head "/", form: {"foo" => "bar"}

Executes a HEAD request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.head("/", form: {"foo" => "bar"}) do |response|
  response.body_io.gets
end

Returns the target host.

require "http/client"

client = HTTP::Client.new "www.example.com"
client.host # => "www.example.com"

Executes a OPTIONS request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new("www.example.com")
response = client.options("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a OPTIONS request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new("www.example.com")
client.options("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a OPTIONS request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.options "/", form: "foo=bar"

Executes a OPTIONS request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.options("/", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a OPTIONS request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.options "/", form: {"foo" => "bar"}

Executes a OPTIONS request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.options("/", form: {"foo" => "bar"}) do |response|
  response.body_io.gets
end

Executes a PATCH request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new("www.example.com")
response = client.patch("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a PATCH request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new("www.example.com")
client.patch("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a PATCH request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.patch "/", form: "foo=bar"

Executes a PATCH request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.patch("/", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a PATCH request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.patch "/", form: {"foo" => "bar"}

Executes a PATCH request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.patch("/", form: {"foo" => "bar"}) do |response|
  response.body_io.gets
end

Returns the target port.

require "http/client"

client = HTTP::Client.new "www.example.com"
client.port # => 80

Executes a POST request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new("www.example.com")
response = client.post("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a POST request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new("www.example.com")
client.post("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a POST request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.post "/", form: "foo=bar"

Executes a POST request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.post("/", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a POST request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.post "/", form: {"foo" => "bar"}

Executes a POST request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.post("/", form: {"foo" => "bar"}) do |response|
  response.body_io.gets
end

Executes a PUT request. The response will have its body as a String, accessed via HTTP::Client::Response#body.

require "http/client"

client = HTTP::Client.new("www.example.com")
response = client.put("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!")
response.body #=> "..."

Executes a PUT request and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io.

require "http/client"

client = HTTP::Client.new("www.example.com")
client.put("/", headers: HTTP::Headers{"User-Agent" => "AwesomeApp"}, body: "Hello!") do |response|
  response.body_io.gets #=> "..."
end

Executes a PUT request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.put "/", form: "foo=bar"

Executes a PUT request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.put("/", form: "foo=bar") do |response|
  response.body_io.gets
end

Executes a PUT request with form data and returns a Response. The "Content-Type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
response = client.put "/", form: {"foo" => "bar"}

Executes a PUT request with form data and yields the response to the block. The response will have its body as an IO accessed via HTTP::Client::Response#body_io. The "Content-type" header is set to "application/x-www-form-urlencoded".

require "http/client"

client = HTTP::Client.new "www.example.com"
client.put("/", form: {"foo" => "bar"}) do |response|
  response.body_io.gets
end

Sets the number of seconds to wait when reading before raising an IO::TimeoutError.

require "http/client"

client = HTTP::Client.new("example.org")
client.read_timeout = 1.5
begin
  response = client.get("/")
rescue IO::TimeoutError
  puts "Timeout!"
end

Sets the read timeout with a Time::Span, to wait when reading before raising an IO::TimeoutError.

require "http/client"

client = HTTP::Client.new("example.org")
client.read_timeout = 5.minutes
begin
  response = client.get("/")
rescue IO::TimeoutError
  puts "Timeout!"
end

Sets the write timeout - if any chunk of request is not written within the number of seconds provided, IO::TimeoutError exception is raised.

Sets the write timeout - if any chunk of request is not written within the provided Time::Span, IO::TimeoutError exception is raised.

This macro allows injecting code to be run before and after the execution of the request. It should return the yielded value. It must be called with 1 block argument that will be used to pass the HTTP::Request.

class HTTP::Client
  def_around_exec do |request|
    # do something before exec
    res = yield
    # do something after exec
    res
  end
end