object

http_client

Request-oriented HTTP client facade built on top of the URL and HTTP transport libraries.

Availability:
logtalk_load(http_client(loader))
Author: Paulo Moura
Version: 1:0:0
Date: 2026-07-09
Compilation flags:
static, context_switching_calls
Imports:
public options
public http_message_helpers
public http_text_helpers
public http_origin_site_helpers
Uses:
http_core
http_multipart
http_websocket_handshake
list
url(Representation)
user
uuid(Representation)
Remarks:
(none)
Inherited public predicates:
 check_option/1  check_options/1  default_option/1  default_options/1  option/2  option/3  valid_option/1  valid_options/1

Public predicates

request/4

Builds a normalized request from the given method, absolute URL, and options, selects a compatible transport, performs a one-shot exchange, and returns the response.

Compilation flags:
static
Template:
request(Method,URL,Response,Options)
Mode and number of proofs:
request(+atom,+atom,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options is a variable or a partial list:
instantiation_error
Options is neither a variable nor a list:
type_error(list,Options)
An element Option of the list Options is neither a variable nor a compound term:
type_error(compound,Option)
An element Option of the list Options is a compound term but not a valid option:
domain_error(option,Option)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Options contains invalid form-data headers:
domain_error(http_client_form_data_headers,Headers)
Options contains invalid form-data properties:
domain_error(http_client_form_data_properties,Properties)
The generated request is not a valid normalized HTTP request term:
domain_error(http_request,Request)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

request/5

Builds a normalized request from the given method, absolute URL, and options, validates it against an open compatible connection or pool handle endpoint, selects a compatible transport, performs one exchange, and returns the response.

Compilation flags:
static
Template:
request(ConnectionOrPool,Method,URL,Response,Options)
Mode and number of proofs:
request(+compound,+atom,+atom,--compound,+list) - one_or_error
Exceptions:
ConnectionOrPool is a variable:
instantiation_error
ConnectionOrPool is not a valid reusable connection or pool handle:
domain_error(http_socket_transport_connection_or_pool,ConnectionOrPool)
ConnectionOrPool is not connected to the requested endpoint:
domain_error(http_client_connection_target,endpoint(EndpointHost,EndpointPort,Host,Port))
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options is a variable or a partial list:
instantiation_error
Options is neither a variable nor a list:
type_error(list,Options)
An element Option of the list Options is neither a variable nor a compound term:
type_error(compound,Option)
An element Option of the list Options is a compound term but not a valid option:
domain_error(option,Option)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Options contains invalid form-data headers:
domain_error(http_client_form_data_headers,Headers)
Options contains invalid form-data properties:
domain_error(http_client_form_data_properties,Properties)
The generated request is not a valid normalized HTTP request term:
domain_error(http_request,Request)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

get/3

Convenience wrapper over request/4 using the get method.

Compilation flags:
static
Template:
get(URL,Response,Options)
Mode and number of proofs:
get(+atom,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

get/4

Convenience wrapper over request/5 using the get method.

Compilation flags:
static
Template:
get(ConnectionOrPool,URL,Response,Options)
Mode and number of proofs:
get(+compound,+atom,--compound,+list) - one_or_error
Exceptions:
ConnectionOrPool is not a valid reusable connection or pool handle:
domain_error(http_socket_transport_connection_or_pool,ConnectionOrPool)
ConnectionOrPool is not connected to the requested endpoint:
domain_error(http_client_connection_target,endpoint(EndpointHost,EndpointPort,Host,Port))
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

head/3

Convenience wrapper over request/4 using the head method.

Compilation flags:
static
Template:
head(URL,Response,Options)
Mode and number of proofs:
head(+atom,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

head/4

Convenience wrapper over request/5 using the head method.

Compilation flags:
static
Template:
head(ConnectionOrPool,URL,Response,Options)
Mode and number of proofs:
head(+compound,+atom,--compound,+list) - one_or_error
Exceptions:
ConnectionOrPool is not a valid reusable connection or pool handle:
domain_error(http_socket_transport_connection_or_pool,ConnectionOrPool)
ConnectionOrPool is not connected to the requested endpoint:
domain_error(http_client_connection_target,endpoint(EndpointHost,EndpointPort,Host,Port))
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

delete/3

Convenience wrapper over request/4 using the delete method.

Compilation flags:
static
Template:
delete(URL,Response,Options)
Mode and number of proofs:
delete(+atom,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

delete/4

Convenience wrapper over request/5 using the delete method.

Compilation flags:
static
Template:
delete(ConnectionOrPool,URL,Response,Options)
Mode and number of proofs:
delete(+compound,+atom,--compound,+list) - one_or_error
Exceptions:
ConnectionOrPool is not a valid reusable connection or pool handle:
domain_error(http_socket_transport_connection_or_pool,ConnectionOrPool)
ConnectionOrPool is not connected to the requested endpoint:
domain_error(http_client_connection_target,endpoint(EndpointHost,EndpointPort,Host,Port))
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

post/4

Convenience wrapper over request/4 using the post method and the given request body.

Compilation flags:
static
Template:
post(URL,Body,Response,Options)
Mode and number of proofs:
post(+atom,+compound,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Body is invalid for the generated normalized HTTP request:
domain_error(http_body,Body)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

post/5

Convenience wrapper over request/5 using the post method and the given request body.

Compilation flags:
static
Template:
post(ConnectionOrPool,URL,Body,Response,Options)
Mode and number of proofs:
post(+compound,+atom,+compound,--compound,+list) - one_or_error
Exceptions:
ConnectionOrPool is not a valid reusable connection or pool handle:
domain_error(http_socket_transport_connection_or_pool,ConnectionOrPool)
ConnectionOrPool is not connected to the requested endpoint:
domain_error(http_client_connection_target,endpoint(EndpointHost,EndpointPort,Host,Port))
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Body is invalid for the generated normalized HTTP request:
domain_error(http_body,Body)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

put/4

Convenience wrapper over request/4 using the put method and the given request body.

Compilation flags:
static
Template:
put(URL,Body,Response,Options)
Mode and number of proofs:
put(+atom,+compound,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Body is invalid for the generated normalized HTTP request:
domain_error(http_body,Body)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

put/5

Convenience wrapper over request/5 using the put method and the given request body.

Compilation flags:
static
Template:
put(ConnectionOrPool,URL,Body,Response,Options)
Mode and number of proofs:
put(+compound,+atom,+compound,--compound,+list) - one_or_error
Exceptions:
ConnectionOrPool is not a valid reusable connection or pool handle:
domain_error(http_socket_transport_connection_or_pool,ConnectionOrPool)
ConnectionOrPool is not connected to the requested endpoint:
domain_error(http_client_connection_target,endpoint(EndpointHost,EndpointPort,Host,Port))
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Body is invalid for the generated normalized HTTP request:
domain_error(http_body,Body)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

patch/4

Convenience wrapper over request/4 using the patch method and the given request body.

Compilation flags:
static
Template:
patch(URL,Body,Response,Options)
Mode and number of proofs:
patch(+atom,+compound,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Body is invalid for the generated normalized HTTP request:
domain_error(http_body,Body)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

patch/5

Convenience wrapper over request/5 using the patch method and the given request body.

Compilation flags:
static
Template:
patch(ConnectionOrPool,URL,Body,Response,Options)
Mode and number of proofs:
patch(+compound,+atom,+compound,--compound,+list) - one_or_error
Exceptions:
ConnectionOrPool is not a valid reusable connection or pool handle:
domain_error(http_socket_transport_connection_or_pool,ConnectionOrPool)
ConnectionOrPool is not connected to the requested endpoint:
domain_error(http_client_connection_target,endpoint(EndpointHost,EndpointPort,Host,Port))
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Body is invalid for the generated normalized HTTP request:
domain_error(http_body,Body)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

query/4

Convenience wrapper over request/4 using the query method and the given request body.

Compilation flags:
static
Template:
query(URL,Body,Response,Options)
Mode and number of proofs:
query(+atom,+compound,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Body is invalid for the generated normalized HTTP request:
domain_error(http_body,Body)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

query/5

Convenience wrapper over request/5 using the query method and the given request body.

Compilation flags:
static
Template:
query(ConnectionOrPool,URL,Body,Response,Options)
Mode and number of proofs:
query(+compound,+atom,+compound,--compound,+list) - one_or_error
Exceptions:
ConnectionOrPool is not a valid reusable connection or pool handle:
domain_error(http_socket_transport_connection_or_pool,ConnectionOrPool)
ConnectionOrPool is not connected to the requested endpoint:
domain_error(http_client_connection_target,endpoint(EndpointHost,EndpointPort,Host,Port))
URL is a variable:
instantiation_error
URL is not a supported absolute HTTP URL:
domain_error(http_client_url,URL)
URL uses an unsupported HTTP scheme:
domain_error(http_client_scheme,Scheme)
Options contains an invalid HTTP client request option:
domain_error(http_client_request_option,Option)
Body is invalid for the generated normalized HTTP request:
domain_error(http_body,Body)
The delegated socket exchange rejects the response stream:
domain_error(http_response_stream,Error)

open_websocket/4

Builds a WebSocket opening-handshake request from the given absolute WebSocket URL and options, selects a compatible transport, opens a reusable socket connection, validates the server 101 response, and returns both the connection handle and the response.

Compilation flags:
static
Template:
open_websocket(URL,Connection,Response,Options)
Mode and number of proofs:
open_websocket(+atom,--compound,--compound,+list) - one_or_error
Exceptions:
URL is a variable:
instantiation_error
URL is not a supported absolute WebSocket URL:
domain_error(http_client_websocket_url,URL)
URL uses an unsupported WebSocket scheme:
domain_error(http_client_websocket_scheme,Scheme)
Options is a variable or a partial list:
instantiation_error
Options is neither a variable nor a list:
type_error(list,Options)
An element Option of the list Options is neither a variable nor a compound term:
type_error(compound,Option)
An element Option of the list Options is a compound term but not a valid option:
domain_error(option,Option)
Options contains an invalid WebSocket client option:
domain_error(http_client_websocket_option,Option)
Options contains an invalid WebSocket HTTP version:
domain_error(http_client_websocket_version,Version)
Options contains reserved WebSocket headers:
domain_error(http_client_websocket_headers,Headers)
The WebSocket server rejects the version:
domain_error(http_client_websocket_version_rejection,Response)
The WebSocket server rejects authentication:
domain_error(http_client_websocket_authentication_rejection,Response)
The WebSocket server redirects the opening handshake:
domain_error(http_client_websocket_redirection_rejection,Response)
The WebSocket server rejects the opening handshake:
domain_error(http_client_websocket_rejection,Response)
The WebSocket server response is not a valid opening handshake response:
domain_error(http_client_websocket_response,Response)

Protected predicates

(no local declarations; see entity ancestors if any)

Private predicates

(no local declarations; see entity ancestors if any)

Operators

(none)