An HTTP Client.
Without a block, an HTTP::Client::Response is returned and the response's body is available as a String by invoking HTTP::Client::Response#body.
require "http/client" response = HTTP::Client.get "http://www.example.com" response.status_code # => 200 response.body.lines.first # => "<!doctype html>"
Parameters can be added to any request with the HTTP::Params#encode method, which converts a Hash or NamedTuple to a URL encoded HTTP query.
require "http/client"
params = HTTP::Params.encode({"author" => "John Doe", "offset" => "20"}) # => author=John+Doe&offset=20
response = HTTP::Client.get "http://www.example.com?" + params
response.status_code # => 200 With a block, an HTTP::Client::Response body is returned and the response's body is available as an IO by invoking HTTP::Client::Response#body_io.
require "http/client"
HTTP::Client.get("http://www.example.com") do |response|
response.status_code # => 200
response.body_io.gets # => "<!doctype html>"
end Similar to the above cases, but creating an instance of an HTTP::Client.
require "http/client" client = HTTP::Client.new "www.example.com" response = client.get "/" response.status_code # => 200 response.body.lines.first # => "<!doctype html>" client.close
If compress isn't set to false, and no Accept-Encoding header is explicitly specified, an HTTP::Client will add an "Accept-Encoding": "gzip, deflate" header, and automatically decompress the response body/body_io.
If a response has a Content-Type header with a charset, that charset is set as the encoding of the returned IO (or used for creating a String for the body). Invalid bytes in the given encoding are silently ignored when reading text content.
Creates a new HTTP client with the given host, port and tls configurations.
Creates a new HTTP client from a URI.
Creates a new HTTP client, yields it to the block, and closes the client afterwards.
Creates a new HTTP client from a URI, yields it to the block and closes the client afterwards.
Executes a DELETE request with form data and yields the response to the block.
Executes a DELETE request with form data and returns a Response.
Executes a DELETE request and yields the response to the block.
Executes a DELETE request.
Executes a request.
Executes a request.
Executes a GET request.
Executes a GET request and yields the response to the block.
Executes a GET request with form data and returns a Response.
Executes a GET request with form data and yields the response to the block.
Executes a HEAD request with form data and yields the response to the block.
Executes a HEAD request with form data and returns a Response.
Executes a HEAD request and yields the response to the block.
Executes a HEAD request.
Executes a OPTIONS request with form data and yields the response to the block.
Executes a OPTIONS request with form data and returns a Response.
Executes a OPTIONS request and yields the response to the block.
Executes a OPTIONS request.
Executes a PATCH request with form data and yields the response to the block.
Executes a PATCH request with form data and returns a Response.
Executes a PATCH request and yields the response to the block.
Executes a PATCH request.
Executes a POST request.
Executes a POST request and yields the response to the block.
Executes a POST request with form data and returns a Response.
Executes a POST request with form data and yields the response to the block.
Executes a PUT request.
Executes a PUT request and yields the response to the block.
Executes a PUT request with form data and yields the response to the block.
Executes a PUT request with form data and returns a Response.
Configures this client to perform basic authentication in every request.
Adds a callback to execute before each request.
Closes this client.
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.
Sets the open timeout with a Time::Span to wait when connecting, before raising an IO::TimeoutError.
Executes a DELETE request with form data and returns a Response.
Executes a DELETE request and yields the response to the block.
Executes a DELETE request with form data and yields the response to the block.
Executes a DELETE request with form data and returns a Response.
Executes a DELETE request with form data and yields the response to the block.
Executes a DELETE request.
This method has no effect right now
This method has no effect right now
Executes a request request and yields an HTTP::Client::Response to the block.
Executes a request.
Executes a request.
Executes a request.
Executes a GET request with form data and yields the response to the block.
Executes a GET request with form data and returns a Response.
Executes a GET request with form data and yields the response to the block.
Executes a GET request with form data and returns a Response.
Executes a GET request and yields the response to the block.
Executes a GET request.
Executes a HEAD request with form data and yields the response to the block.
Executes a HEAD request with form data and returns a Response.
Executes a HEAD request with form data and yields the response to the block.
Executes a HEAD request with form data and returns a Response.
Executes a HEAD request and yields the response to the block.
Executes a HEAD request.
Returns the target host.
Executes a OPTIONS request with form data and yields the response to the block.
Executes a OPTIONS request with form data and returns a Response.
Executes a OPTIONS request with form data and yields the response to the block.
Executes a OPTIONS request with form data and returns a Response.
Executes a OPTIONS request and yields the response to the block.
Executes a OPTIONS request.
Executes a PATCH request with form data and yields the response to the block.
Executes a PATCH request with form data and returns a Response.
Executes a PATCH request with form data and yields the response to the block.
Executes a PATCH request with form data and returns a Response.
Executes a PATCH request and yields the response to the block.
Executes a PATCH request.
Returns the target port.
Executes a POST request.
Executes a POST request and yields the response to the block.
Executes a POST request with form data and returns a Response.
Executes a POST request with form data and yields the response to the block.
Executes a POST request with form data and returns a Response.
Executes a POST request with form data and yields the response to the block.
Executes a PUT request.
Executes a PUT request with form data and returns a Response.
Executes a PUT request with form data and yields the response to the block.
Executes a PUT request with form data and returns a Response.
Executes a PUT request and yields the response to the block.
Executes a PUT request with form data and yields the response to the block.
Sets the number of seconds to wait when reading before raising an IO::TimeoutError.
Sets the read timeout with a Time::Span, to wait when reading before raising an IO::TimeoutError.
Sets the write timeout - if any chunk of request is not written within the provided Time::Span, IO::TimeoutError exception is raised.
Sets the write timeout - if any chunk of request is not written within the number of seconds provided, IO::TimeoutError exception is raised.
Reference
Reference
Object
Object
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 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, yields it to the block, and closes the client afterwards.
require "http/client"
HTTP::Client.new("www.example.com") do |client|
client.get "/"
end 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.
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 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 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. 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 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 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 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 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 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 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. 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 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 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 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. 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 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 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 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. 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 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 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 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"
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.
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 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 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 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 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 #=> "..." This method has no effect right now
Sets the number of seconds to wait when resolving a name, before raising an IO::TimeoutError.
require "http/client"
client = HTTP::Client.new("example.org")
client.dns_timeout = 1.5
begin
response = client.get("/")
rescue IO::TimeoutError
puts "Timeout!"
end This method has no effect right now
Sets the number of seconds to wait when resolving a name with a Time::Span, before raising an IO::TimeoutError.
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 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 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 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 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 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 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 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. 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 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 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 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. 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 #=> "..." Returns the target host.
require "http/client" client = HTTP::Client.new "www.example.com" client.host # => "www.example.com"
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 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 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. 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 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 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 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. 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 #=> "..." 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 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 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 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 provided Time::Span, IO::TimeoutError exception is raised.
Sets the write timeout - if any chunk of request is not written within the number of seconds provided, IO::TimeoutError exception is raised.
© 2012–2020 Manas Technology Solutions.
Licensed under the Apache License, Version 2.0.
https://crystal-lang.org/api/0.35.1/HTTP/Client.html