---
product: Chilkat
product_version: 11.7.0
language: wc
language_label: Unicode C
class: Http
license: bundle
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/wc_CkHttpWRef.html
---
# Chilkat Http — Unicode C — v11.7.0

> Chilkat 11.7.0 · language=wc · class=Http
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/Http.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/guide.md`.

## Purpose

**HTTPS client for REST API calls, GET/POST/PUT/DELETE/PATCH requests, uploads, and downloads.**

`Chilkat.Http` is a comprehensive HTTP and HTTPS client class for applications that need to call REST APIs, download files, upload data, submit forms, send JSON or XML, stream large responses, manage cookies and redirects, authenticate with modern or legacy schemes, use TLS client certificates, work through proxies, and troubleshoot HTTP communication in detail.

**REST and API requests**

Send GET, POST, PUT, PATCH, DELETE, and custom HTTP requests with headers, query parameters, JSON, XML, form data, or raw request bodies.

**Uploads and downloads**

Download to memory, files, streams, `BinData`, or `StringBuilder`, and upload files, forms, multipart content, or application data.

**Authentication**

Use Basic, Digest, NTLM, Negotiate, Bearer tokens, OAuth2 access tokens, AWS signatures, and other service-specific authentication patterns.

**TLS, proxies, and networking**

Configure HTTPS, client certificates, TLS behavior, HTTP proxies, SOCKS proxies, proxy authentication, custom timeouts, and network interface preferences.

**Cookies, redirects, and sessions**

Manage cookies, follow redirects, preserve session state, control request headers, and inspect response headers and status codes.

**S3-compatible storage**

Use built-in helpers for Amazon S3 and S3-compatible object storage operations such as upload, download, delete, copy, and listing workflows.

**Common pattern:** Configure authentication, headers, TLS, proxy, and timeout settings first; send the request with the method that matches the desired input/output form; then inspect the response status, headers, body, and `LastErrorText` when troubleshooting server or network behavior.

For an extended overview, see [Http Class Overview](https://www.chilkatsoft.com/http_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```c
HCkHttpW instance = CkHttpW_Create();
// ...
CkHttpW_Dispose(instance);
```

`HCkHttpW CkHttpW_Create(void);`

Creates an instance of the HCkHttpW object and returns a handle ("void \*" pointer). The handle is passed in the 1st argument for the functions listed on this page.

`void CkHttpW_Dispose(HCkHttpW handle);`

Objects created by calling CkHttpW_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function. Also, any handle returned by a Chilkat "C" function must also be freed by the application by calling the appropriate Dispose method, such as CkHttpW_Dispose.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Unicode C.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `void CkHttpW_getDebugLogFilePath(HCkHttpW cHandle, HCkString retval); void CkHttpW_putDebugLogFilePath(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_debugLogFilePath(HCkHttpW cHandle);` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `void CkHttpW_getLastErrorHtml(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastErrorHtml(HCkHttpW cHandle);` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `void CkHttpW_getLastErrorText(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastErrorText(HCkHttpW cHandle);` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `void CkHttpW_getLastErrorXml(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastErrorXml(HCkHttpW cHandle);` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `BOOL CkHttpW_getLastMethodSuccess(HCkHttpW cHandle); void CkHttpW_putLastMethodSuccess(HCkHttpW cHandle, BOOL newVal);` | read/write | Indicates the success or failure of the most recent method call: `TRUE` means success, `FALSE` means failure. |
| `VerboseLogging` | `BOOL CkHttpW_getVerboseLogging(HCkHttpW cHandle); void CkHttpW_putVerboseLogging(HCkHttpW cHandle, BOOL newVal);` | read/write | If set to `TRUE`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `void CkHttpW_getVersion(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_version(HCkHttpW cHandle);` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `AbortCurrent` | property, read/write | `BOOL CkHttpW_getAbortCurrent(HCkHttpW cHandle); void CkHttpW_putAbortCurrent(HCkHttpW cHandle, BOOL newVal);` |
| `Accept` | property, read/write | `void CkHttpW_getAccept(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAccept(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_accept(HCkHttpW cHandle);` |
| `AllowGzip` | property, read/write | `BOOL CkHttpW_getAllowGzip(HCkHttpW cHandle); void CkHttpW_putAllowGzip(HCkHttpW cHandle, BOOL newVal);` |
| `AllowHeaderFolding` | property, read/write | `BOOL CkHttpW_getAllowHeaderFolding(HCkHttpW cHandle); void CkHttpW_putAllowHeaderFolding(HCkHttpW cHandle, BOOL newVal);` |
| `AuthSignature` | property, read/write | `void CkHttpW_getAuthSignature(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAuthSignature(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_authSignature(HCkHttpW cHandle);` |
| `AuthToken` | property, read/write | `void CkHttpW_getAuthToken(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAuthToken(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_authToken(HCkHttpW cHandle);` |
| `AutoAddHostHeader` | property, read/write | `BOOL CkHttpW_getAutoAddHostHeader(HCkHttpW cHandle); void CkHttpW_putAutoAddHostHeader(HCkHttpW cHandle, BOOL newVal);` |
| `AwsAccessKey` | property, read/write | `void CkHttpW_getAwsAccessKey(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAwsAccessKey(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_awsAccessKey(HCkHttpW cHandle);` |
| `AwsEndpoint` | property, read/write | `void CkHttpW_getAwsEndpoint(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAwsEndpoint(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_awsEndpoint(HCkHttpW cHandle);` |
| `AwsRegion` | property, read/write | `void CkHttpW_getAwsRegion(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAwsRegion(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_awsRegion(HCkHttpW cHandle);` |
| `AwsSecretKey` | property, read/write | `void CkHttpW_getAwsSecretKey(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAwsSecretKey(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_awsSecretKey(HCkHttpW cHandle);` |
| `AwsSessionToken` | property, read/write | `void CkHttpW_getAwsSessionToken(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAwsSessionToken(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_awsSessionToken(HCkHttpW cHandle);` |
| `AwsSubResources` | property, read/write | `void CkHttpW_getAwsSubResources(HCkHttpW cHandle, HCkString retval); void CkHttpW_putAwsSubResources(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_awsSubResources(HCkHttpW cHandle);` |
| `BandwidthThrottleDown` | property, read/write | `int CkHttpW_getBandwidthThrottleDown(HCkHttpW cHandle); void CkHttpW_putBandwidthThrottleDown(HCkHttpW cHandle, int newVal);` |
| `BandwidthThrottleUp` | property, read/write | `int CkHttpW_getBandwidthThrottleUp(HCkHttpW cHandle); void CkHttpW_putBandwidthThrottleUp(HCkHttpW cHandle, int newVal);` |
| `BasicAuth` | property, read/write | `BOOL CkHttpW_getBasicAuth(HCkHttpW cHandle); void CkHttpW_putBasicAuth(HCkHttpW cHandle, BOOL newVal);` |
| `ClientIpAddress` | property, read/write | `void CkHttpW_getClientIpAddress(HCkHttpW cHandle, HCkString retval); void CkHttpW_putClientIpAddress(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_clientIpAddress(HCkHttpW cHandle);` |
| `ConnectFailReason` | property, read-only | `int CkHttpW_getConnectFailReason(HCkHttpW cHandle);` |
| `ConnectTimeout` | property, read/write | `int CkHttpW_getConnectTimeout(HCkHttpW cHandle); void CkHttpW_putConnectTimeout(HCkHttpW cHandle, int newVal);` |
| `CookieDir` | property, read/write | `void CkHttpW_getCookieDir(HCkHttpW cHandle, HCkString retval); void CkHttpW_putCookieDir(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_cookieDir(HCkHttpW cHandle);` |
| `DefaultFreshPeriod` | property, read/write | `int CkHttpW_getDefaultFreshPeriod(HCkHttpW cHandle); void CkHttpW_putDefaultFreshPeriod(HCkHttpW cHandle, int newVal);` |
| `DigestAuth` | property, read/write | `BOOL CkHttpW_getDigestAuth(HCkHttpW cHandle); void CkHttpW_putDigestAuth(HCkHttpW cHandle, BOOL newVal);` |
| `EnableSecrets` | property, read/write | `BOOL CkHttpW_getEnableSecrets(HCkHttpW cHandle); void CkHttpW_putEnableSecrets(HCkHttpW cHandle, BOOL newVal);` |
| `FetchFromCache` | property, read/write | `BOOL CkHttpW_getFetchFromCache(HCkHttpW cHandle); void CkHttpW_putFetchFromCache(HCkHttpW cHandle, BOOL newVal);` |
| `FinalRedirectUrl` | property, read-only | `void CkHttpW_getFinalRedirectUrl(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_finalRedirectUrl(HCkHttpW cHandle);` |
| `FollowRedirects` | property, read/write | `BOOL CkHttpW_getFollowRedirects(HCkHttpW cHandle); void CkHttpW_putFollowRedirects(HCkHttpW cHandle, BOOL newVal);` |
| `FreshnessAlgorithm` | property, read/write | `int CkHttpW_getFreshnessAlgorithm(HCkHttpW cHandle); void CkHttpW_putFreshnessAlgorithm(HCkHttpW cHandle, int newVal);` |
| `HeartbeatMs` | property, read/write | `int CkHttpW_getHeartbeatMs(HCkHttpW cHandle); void CkHttpW_putHeartbeatMs(HCkHttpW cHandle, int newVal);` |
| `IgnoreMustRevalidate` | property, read/write | `BOOL CkHttpW_getIgnoreMustRevalidate(HCkHttpW cHandle); void CkHttpW_putIgnoreMustRevalidate(HCkHttpW cHandle, BOOL newVal);` |
| `IgnoreNoCache` | property, read/write | `BOOL CkHttpW_getIgnoreNoCache(HCkHttpW cHandle); void CkHttpW_putIgnoreNoCache(HCkHttpW cHandle, BOOL newVal);` |
| `KeepResponseBody` | property, read/write | `BOOL CkHttpW_getKeepResponseBody(HCkHttpW cHandle); void CkHttpW_putKeepResponseBody(HCkHttpW cHandle, BOOL newVal);` |
| `LastContentType` | property, read-only | `void CkHttpW_getLastContentType(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastContentType(HCkHttpW cHandle);` |
| `LastFromCache` | property, read-only | `BOOL CkHttpW_getLastFromCache(HCkHttpW cHandle);` |
| `LastHeader` | property, read-only | `void CkHttpW_getLastHeader(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastHeader(HCkHttpW cHandle);` |
| `LastModDate` | property, read-only | `void CkHttpW_getLastModDate(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastModDate(HCkHttpW cHandle);` |
| `LastResponseBody` | property, read-only | `void CkHttpW_getLastResponseBody(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastResponseBody(HCkHttpW cHandle);` |
| `LastResponseHeader` | property, read-only | `void CkHttpW_getLastResponseHeader(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastResponseHeader(HCkHttpW cHandle);` |
| `LastStatus` | property, read-only | `int CkHttpW_getLastStatus(HCkHttpW cHandle);` |
| `LastStatusText` | property, read-only | `void CkHttpW_getLastStatusText(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_lastStatusText(HCkHttpW cHandle);` |
| `LMFactor` | property, read/write | `int CkHttpW_getLMFactor(HCkHttpW cHandle); void CkHttpW_putLMFactor(HCkHttpW cHandle, int newVal);` |
| `Login` | property, read/write | `void CkHttpW_getLogin(HCkHttpW cHandle, HCkString retval); void CkHttpW_putLogin(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_login(HCkHttpW cHandle);` |
| `LoginDomain` | property, read/write | `void CkHttpW_getLoginDomain(HCkHttpW cHandle, HCkString retval); void CkHttpW_putLoginDomain(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_loginDomain(HCkHttpW cHandle);` |
| `MaxConnections` | property, read/write | `int CkHttpW_getMaxConnections(HCkHttpW cHandle); void CkHttpW_putMaxConnections(HCkHttpW cHandle, int newVal);` |
| `MaxFreshPeriod` | property, read/write | `int CkHttpW_getMaxFreshPeriod(HCkHttpW cHandle); void CkHttpW_putMaxFreshPeriod(HCkHttpW cHandle, int newVal);` |
| `MaxResponseSize` | property, read/write | `unsigned long CkHttpW_getMaxResponseSize(HCkHttpW cHandle); void CkHttpW_putMaxResponseSize(HCkHttpW cHandle, unsigned long newVal);` |
| `MaxUrlLen` | property, read/write | `int CkHttpW_getMaxUrlLen(HCkHttpW cHandle); void CkHttpW_putMaxUrlLen(HCkHttpW cHandle, int newVal);` |
| `MinFreshPeriod` | property, read/write | `int CkHttpW_getMinFreshPeriod(HCkHttpW cHandle); void CkHttpW_putMinFreshPeriod(HCkHttpW cHandle, int newVal);` |
| `NegotiateAuth` | property, read/write | `BOOL CkHttpW_getNegotiateAuth(HCkHttpW cHandle); void CkHttpW_putNegotiateAuth(HCkHttpW cHandle, BOOL newVal);` |
| `NtlmAuth` | property, read/write | `BOOL CkHttpW_getNtlmAuth(HCkHttpW cHandle); void CkHttpW_putNtlmAuth(HCkHttpW cHandle, BOOL newVal);` |
| `NumCacheLevels` | property, read/write | `int CkHttpW_getNumCacheLevels(HCkHttpW cHandle); void CkHttpW_putNumCacheLevels(HCkHttpW cHandle, int newVal);` |
| `NumCacheRoots` | property, read-only | `int CkHttpW_getNumCacheRoots(HCkHttpW cHandle);` |
| `OAuth1` | property, read/write | `BOOL CkHttpW_getOAuth1(HCkHttpW cHandle); void CkHttpW_putOAuth1(HCkHttpW cHandle, BOOL newVal);` |
| `OAuthBodyHash` | property, read/write | `BOOL CkHttpW_getOAuthBodyHash(HCkHttpW cHandle); void CkHttpW_putOAuthBodyHash(HCkHttpW cHandle, BOOL newVal);` |
| `OAuthCallback` | property, read/write | `void CkHttpW_getOAuthCallback(HCkHttpW cHandle, HCkString retval); void CkHttpW_putOAuthCallback(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_oAuthCallback(HCkHttpW cHandle);` |
| `OAuthConsumerKey` | property, read/write | `void CkHttpW_getOAuthConsumerKey(HCkHttpW cHandle, HCkString retval); void CkHttpW_putOAuthConsumerKey(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_oAuthConsumerKey(HCkHttpW cHandle);` |
| `OAuthConsumerSecret` | property, read/write | `void CkHttpW_getOAuthConsumerSecret(HCkHttpW cHandle, HCkString retval); void CkHttpW_putOAuthConsumerSecret(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_oAuthConsumerSecret(HCkHttpW cHandle);` |
| `OAuthRealm` | property, read/write | `void CkHttpW_getOAuthRealm(HCkHttpW cHandle, HCkString retval); void CkHttpW_putOAuthRealm(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_oAuthRealm(HCkHttpW cHandle);` |
| `OAuthSigMethod` | property, read/write | `void CkHttpW_getOAuthSigMethod(HCkHttpW cHandle, HCkString retval); void CkHttpW_putOAuthSigMethod(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_oAuthSigMethod(HCkHttpW cHandle);` |
| `OAuthToken` | property, read/write | `void CkHttpW_getOAuthToken(HCkHttpW cHandle, HCkString retval); void CkHttpW_putOAuthToken(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_oAuthToken(HCkHttpW cHandle);` |
| `OAuthTokenSecret` | property, read/write | `void CkHttpW_getOAuthTokenSecret(HCkHttpW cHandle, HCkString retval); void CkHttpW_putOAuthTokenSecret(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_oAuthTokenSecret(HCkHttpW cHandle);` |
| `OAuthVerifier` | property, read/write | `void CkHttpW_getOAuthVerifier(HCkHttpW cHandle, HCkString retval); void CkHttpW_putOAuthVerifier(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_oAuthVerifier(HCkHttpW cHandle);` |
| `Password` | property, read/write | `void CkHttpW_getPassword(HCkHttpW cHandle, HCkString retval); void CkHttpW_putPassword(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_password(HCkHttpW cHandle);` |
| `PercentDoneScale` | property, read/write | `int CkHttpW_getPercentDoneScale(HCkHttpW cHandle); void CkHttpW_putPercentDoneScale(HCkHttpW cHandle, int newVal);` |
| `PreferIpv6` | property, read/write | `BOOL CkHttpW_getPreferIpv6(HCkHttpW cHandle); void CkHttpW_putPreferIpv6(HCkHttpW cHandle, BOOL newVal);` |
| `ProxyAuthMethod` | property, read/write | `void CkHttpW_getProxyAuthMethod(HCkHttpW cHandle, HCkString retval); void CkHttpW_putProxyAuthMethod(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_proxyAuthMethod(HCkHttpW cHandle);` |
| `ProxyDirectTls` | property, read/write | `BOOL CkHttpW_getProxyDirectTls(HCkHttpW cHandle); void CkHttpW_putProxyDirectTls(HCkHttpW cHandle, BOOL newVal);` |
| `ProxyDomain` | property, read/write | `void CkHttpW_getProxyDomain(HCkHttpW cHandle, HCkString retval); void CkHttpW_putProxyDomain(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_proxyDomain(HCkHttpW cHandle);` |
| `ProxyLogin` | property, read/write | `void CkHttpW_getProxyLogin(HCkHttpW cHandle, HCkString retval); void CkHttpW_putProxyLogin(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_proxyLogin(HCkHttpW cHandle);` |
| `ProxyLoginDomain` | property, read/write | `void CkHttpW_getProxyLoginDomain(HCkHttpW cHandle, HCkString retval); void CkHttpW_putProxyLoginDomain(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_proxyLoginDomain(HCkHttpW cHandle);` |
| `ProxyPassword` | property, read/write | `void CkHttpW_getProxyPassword(HCkHttpW cHandle, HCkString retval); void CkHttpW_putProxyPassword(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_proxyPassword(HCkHttpW cHandle);` |
| `ProxyPort` | property, read/write | `int CkHttpW_getProxyPort(HCkHttpW cHandle); void CkHttpW_putProxyPort(HCkHttpW cHandle, int newVal);` |
| `ReadTimeout` | property, read/write | `int CkHttpW_getReadTimeout(HCkHttpW cHandle); void CkHttpW_putReadTimeout(HCkHttpW cHandle, int newVal);` |
| `ReceivedCertReq` | property, read-only | `BOOL CkHttpW_getReceivedCertReq(HCkHttpW cHandle);` |
| `RedirectVerb` | property, read/write | `void CkHttpW_getRedirectVerb(HCkHttpW cHandle, HCkString retval); void CkHttpW_putRedirectVerb(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_redirectVerb(HCkHttpW cHandle);` |
| `RequiredContentType` | property, read/write | `void CkHttpW_getRequiredContentType(HCkHttpW cHandle, HCkString retval); void CkHttpW_putRequiredContentType(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_requiredContentType(HCkHttpW cHandle);` |
| `RequireHostnameMatch` | property, read/write | `BOOL CkHttpW_getRequireHostnameMatch(HCkHttpW cHandle); void CkHttpW_putRequireHostnameMatch(HCkHttpW cHandle, BOOL newVal);` |
| `RequireSslCertVerify` | property, read/write | `BOOL CkHttpW_getRequireSslCertVerify(HCkHttpW cHandle); void CkHttpW_putRequireSslCertVerify(HCkHttpW cHandle, BOOL newVal);` |
| `SaveCookies` | property, read/write | `BOOL CkHttpW_getSaveCookies(HCkHttpW cHandle); void CkHttpW_putSaveCookies(HCkHttpW cHandle, BOOL newVal);` |
| `SendBufferSize` | property, read/write | `int CkHttpW_getSendBufferSize(HCkHttpW cHandle); void CkHttpW_putSendBufferSize(HCkHttpW cHandle, int newVal);` |
| `SendCookies` | property, read/write | `BOOL CkHttpW_getSendCookies(HCkHttpW cHandle); void CkHttpW_putSendCookies(HCkHttpW cHandle, BOOL newVal);` |
| `SessionLogFilename` | property, read/write | `void CkHttpW_getSessionLogFilename(HCkHttpW cHandle, HCkString retval); void CkHttpW_putSessionLogFilename(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_sessionLogFilename(HCkHttpW cHandle);` |
| `SniHostname` | property, read/write | `void CkHttpW_getSniHostname(HCkHttpW cHandle, HCkString retval); void CkHttpW_putSniHostname(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_sniHostname(HCkHttpW cHandle);` |
| `SocksHostname` | property, read/write | `void CkHttpW_getSocksHostname(HCkHttpW cHandle, HCkString retval); void CkHttpW_putSocksHostname(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_socksHostname(HCkHttpW cHandle);` |
| `SocksPassword` | property, read/write | `void CkHttpW_getSocksPassword(HCkHttpW cHandle, HCkString retval); void CkHttpW_putSocksPassword(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_socksPassword(HCkHttpW cHandle);` |
| `SocksPort` | property, read/write | `int CkHttpW_getSocksPort(HCkHttpW cHandle); void CkHttpW_putSocksPort(HCkHttpW cHandle, int newVal);` |
| `SocksUsername` | property, read/write | `void CkHttpW_getSocksUsername(HCkHttpW cHandle, HCkString retval); void CkHttpW_putSocksUsername(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_socksUsername(HCkHttpW cHandle);` |
| `SocksVersion` | property, read/write | `int CkHttpW_getSocksVersion(HCkHttpW cHandle); void CkHttpW_putSocksVersion(HCkHttpW cHandle, int newVal);` |
| `SoRcvBuf` | property, read/write | `int CkHttpW_getSoRcvBuf(HCkHttpW cHandle); void CkHttpW_putSoRcvBuf(HCkHttpW cHandle, int newVal);` |
| `SoSndBuf` | property, read/write | `int CkHttpW_getSoSndBuf(HCkHttpW cHandle); void CkHttpW_putSoSndBuf(HCkHttpW cHandle, int newVal);` |
| `SslAllowedCiphers` | property, read/write | `void CkHttpW_getSslAllowedCiphers(HCkHttpW cHandle, HCkString retval); void CkHttpW_putSslAllowedCiphers(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_sslAllowedCiphers(HCkHttpW cHandle);` |
| `SslProtocol` | property, read/write | `void CkHttpW_getSslProtocol(HCkHttpW cHandle, HCkString retval); void CkHttpW_putSslProtocol(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_sslProtocol(HCkHttpW cHandle);` |
| `StreamResponseBodyPath` | property, read/write | `void CkHttpW_getStreamResponseBodyPath(HCkHttpW cHandle, HCkString retval); void CkHttpW_putStreamResponseBodyPath(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_streamResponseBodyPath(HCkHttpW cHandle);` |
| `TlsCipherSuite` | property, read-only | `void CkHttpW_getTlsCipherSuite(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_tlsCipherSuite(HCkHttpW cHandle);` |
| `TlsPinSet` | property, read/write | `void CkHttpW_getTlsPinSet(HCkHttpW cHandle, HCkString retval); void CkHttpW_putTlsPinSet(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_tlsPinSet(HCkHttpW cHandle);` |
| `TlsVersion` | property, read-only | `void CkHttpW_getTlsVersion(HCkHttpW cHandle, HCkString retval); const wchar_t *CkHttpW_tlsVersion(HCkHttpW cHandle);` |
| `UncommonOptions` | property, read/write | `void CkHttpW_getUncommonOptions(HCkHttpW cHandle, HCkString retval); void CkHttpW_putUncommonOptions(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_uncommonOptions(HCkHttpW cHandle);` |
| `UpdateCache` | property, read/write | `BOOL CkHttpW_getUpdateCache(HCkHttpW cHandle); void CkHttpW_putUpdateCache(HCkHttpW cHandle, BOOL newVal);` |
| `UseIEProxy` | property, read/write | `BOOL CkHttpW_getUseIEProxy(HCkHttpW cHandle); void CkHttpW_putUseIEProxy(HCkHttpW cHandle, BOOL newVal);` |
| `UserAgent` | property, read/write | `void CkHttpW_getUserAgent(HCkHttpW cHandle, HCkString retval); void CkHttpW_putUserAgent(HCkHttpW cHandle, const wchar_t *newVal); const wchar_t *CkHttpW_userAgent(HCkHttpW cHandle);` |
| `WasRedirected` | property, read-only | `BOOL CkHttpW_getWasRedirected(HCkHttpW cHandle);` |
| `AddCacheRoot` | method | `void CkHttpW_AddCacheRoot(HCkHttpW cHandle, const wchar_t *dir);` |
| `ClearHeaders` | method | `void CkHttpW_ClearHeaders(HCkHttpW cHandle);` |
| `ClearInMemoryCookies` | method | `void CkHttpW_ClearInMemoryCookies(HCkHttpW cHandle);` |
| `ClearUrlVars` | method | `void CkHttpW_ClearUrlVars(HCkHttpW cHandle);` |
| `CloseAllConnections` | method | `BOOL CkHttpW_CloseAllConnections(HCkHttpW cHandle);` |
| `CreateOcspRequest` | method | `BOOL CkHttpW_CreateOcspRequest(HCkHttpW cHandle, HCkJsonObjectW requestDetails, HCkBinDataW ocspRequest);` |
| `CreateTimestampRequest` | method | `BOOL CkHttpW_CreateTimestampRequest(HCkHttpW cHandle, const wchar_t *hashAlg, const wchar_t *hashVal, const wchar_t *reqPolicyOid, BOOL addNonce, BOOL reqTsaCert, HCkBinDataW timestampToken);` |
| `DnsCacheClear` | method | `void CkHttpW_DnsCacheClear(HCkHttpW cHandle);` |
| `Download` | method | `BOOL CkHttpW_Download(HCkHttpW cHandle, const wchar_t *url, const wchar_t *localFilePath);` |
| `DownloadAppend` | method | `BOOL CkHttpW_DownloadAppend(HCkHttpW cHandle, const wchar_t *url, const wchar_t *appendToPath);` |
| `DownloadBd` | method | `BOOL CkHttpW_DownloadBd(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);` |
| `DownloadHash` | method | `BOOL CkHttpW_DownloadHash(HCkHttpW cHandle, const wchar_t *url, const wchar_t *hashAlgorithm, const wchar_t *encoding, const wchar_t *outStr); const wchar_t *CkHttpW_downloadHash(HCkHttpW cHandle, const wchar_t *url, const wchar_t *hashAlgorithm, const wchar_t *encoding);` |
| `DownloadSb` | method | `BOOL CkHttpW_DownloadSb(HCkHttpW cHandle, const wchar_t *url, const wchar_t *charset, HCkStringBuilderW sb);` |
| `ExtractMetaRefreshUrl` | method | `BOOL CkHttpW_ExtractMetaRefreshUrl(HCkHttpW cHandle, const wchar_t *htmlContent, const wchar_t *outStr); const wchar_t *CkHttpW_extractMetaRefreshUrl(HCkHttpW cHandle, const wchar_t *htmlContent);` |
| `G_SvcOauthAccessToken` | method | `BOOL CkHttpW_G_SvcOauthAccessToken(HCkHttpW cHandle, const wchar_t *iss, const wchar_t *scope, const wchar_t *subEmail, int numSec, HCkCertW cert, const wchar_t *outStr); const wchar_t *CkHttpW_g_SvcOauthAccessToken(HCkHttpW cHandle, const wchar_t *iss, const wchar_t *scope, const wchar_t *subEmail, int numSec, HCkCertW cert);` |
| `G_SvcOauthAccessToken2` | method | `BOOL CkHttpW_G_SvcOauthAccessToken2(HCkHttpW cHandle, HCkHashtableW claimParams, int numSec, HCkCertW cert, const wchar_t *outStr); const wchar_t *CkHttpW_g_SvcOauthAccessToken2(HCkHttpW cHandle, HCkHashtableW claimParams, int numSec, HCkCertW cert);` |
| `GenTimeStamp` | method | `BOOL CkHttpW_GenTimeStamp(HCkHttpW cHandle, const wchar_t *outStr); const wchar_t *CkHttpW_genTimeStamp(HCkHttpW cHandle);` |
| `GetCacheRoot` | method | `BOOL CkHttpW_GetCacheRoot(HCkHttpW cHandle, int index, const wchar_t *outStr); const wchar_t *CkHttpW_getCacheRoot(HCkHttpW cHandle, int index);` |
| `GetCookieXml` | method | `BOOL CkHttpW_GetCookieXml(HCkHttpW cHandle, const wchar_t *domain, const wchar_t *outStr); const wchar_t *CkHttpW_getCookieXml(HCkHttpW cHandle, const wchar_t *domain);` |
| `GetDomain` | method | `BOOL CkHttpW_GetDomain(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr); const wchar_t *CkHttpW_getDomain(HCkHttpW cHandle, const wchar_t *url);` |
| `GetLastJsonData` | method | `void CkHttpW_GetLastJsonData(HCkHttpW cHandle, HCkJsonObjectW json);` |
| `GetRequestHeader` | method | `BOOL CkHttpW_GetRequestHeader(HCkHttpW cHandle, const wchar_t *name, const wchar_t *outStr); const wchar_t *CkHttpW_getRequestHeader(HCkHttpW cHandle, const wchar_t *name);` |
| `GetServerCert` | method | `BOOL CkHttpW_GetServerCert(HCkHttpW cHandle, const wchar_t *domain, int port, HCkCertW cert);` |
| `GetUrlPath` | method | `BOOL CkHttpW_GetUrlPath(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr); const wchar_t *CkHttpW_getUrlPath(HCkHttpW cHandle, const wchar_t *url);` |
| `HasRequestHeader` | method | `BOOL CkHttpW_HasRequestHeader(HCkHttpW cHandle, const wchar_t *name);` |
| `HttpBd` | method | `BOOL CkHttpW_HttpBd(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkBinDataW bd, const wchar_t *contentType, HCkHttpResponseW response);` |
| `HttpFile` | method | `BOOL CkHttpW_HttpFile(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, const wchar_t *localFilePath, const wchar_t *contentType, HCkHttpResponseW response);` |
| `HttpJson` | method | `BOOL CkHttpW_HttpJson(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkJsonObjectW json, const wchar_t *contentType, HCkHttpResponseW response);` |
| `HttpNoBody` | method | `BOOL CkHttpW_HttpNoBody(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkHttpResponseW response);` |
| `HttpParams` | method | `BOOL CkHttpW_HttpParams(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkJsonObjectW json, HCkHttpResponseW response);` |
| `HttpReq` | method | `BOOL CkHttpW_HttpReq(HCkHttpW cHandle, const wchar_t *url, HCkHttpRequestW request, HCkHttpResponseW response);` |
| `HttpSb` | method | `BOOL CkHttpW_HttpSb(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkStringBuilderW sb, const wchar_t *charset, const wchar_t *contentType, HCkHttpResponseW response);` |
| `HttpSReq` | method | `BOOL CkHttpW_HttpSReq(HCkHttpW cHandle, const wchar_t *domain, int port, BOOL ssl, HCkHttpRequestW request, HCkHttpResponseW response);` |
| `HttpStr` | method | `BOOL CkHttpW_HttpStr(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, const wchar_t *bodyStr, const wchar_t *charset, const wchar_t *contentType, HCkHttpResponseW response);` |
| `LoadTaskCaller` | method | `BOOL CkHttpW_LoadTaskCaller(HCkHttpW cHandle, HCkTaskW task);` |
| `OcspCheck` | method | `int CkHttpW_OcspCheck(HCkHttpW cHandle, const wchar_t *domain, int port);` |
| `ParseOcspReply` | method | `int CkHttpW_ParseOcspReply(HCkHttpW cHandle, HCkBinDataW ocspReply, HCkJsonObjectW replyData);` |
| `QuickDeleteStr` | method | `BOOL CkHttpW_QuickDeleteStr(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr); const wchar_t *CkHttpW_quickDeleteStr(HCkHttpW cHandle, const wchar_t *url);` |
| `QuickGetBd` | method | `BOOL CkHttpW_QuickGetBd(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);` |
| `QuickGetSb` | method | `BOOL CkHttpW_QuickGetSb(HCkHttpW cHandle, const wchar_t *url, HCkStringBuilderW sbContent);` |
| `QuickGetStr` | method | `BOOL CkHttpW_QuickGetStr(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr); const wchar_t *CkHttpW_quickGetStr(HCkHttpW cHandle, const wchar_t *url);` |
| `RemoveRequestHeader` | method | `void CkHttpW_RemoveRequestHeader(HCkHttpW cHandle, const wchar_t *name);` |
| `RenderGet` | method | `BOOL CkHttpW_RenderGet(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr); const wchar_t *CkHttpW_renderGet(HCkHttpW cHandle, const wchar_t *url);` |
| `ResumeDownload` | method | `BOOL CkHttpW_ResumeDownload(HCkHttpW cHandle, const wchar_t *url, const wchar_t *targetFilename);` |
| `ResumeDownloadBd` | method | `BOOL CkHttpW_ResumeDownloadBd(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);` |
| `S3_CreateBucket` | method | `BOOL CkHttpW_S3_CreateBucket(HCkHttpW cHandle, const wchar_t *bucketPath);` |
| `S3_DeleteBucket` | method | `BOOL CkHttpW_S3_DeleteBucket(HCkHttpW cHandle, const wchar_t *bucketPath);` |
| `S3_DeleteObject` | method | `BOOL CkHttpW_S3_DeleteObject(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName);` |
| `S3_DeleteObjects` | method | `BOOL CkHttpW_S3_DeleteObjects(HCkHttpW cHandle, const wchar_t *bucketName, HCkStringTableW objectNames, HCkJsonObjectW jsonResponse);` |
| `S3_DownloadBd` | method | `BOOL CkHttpW_S3_DownloadBd(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, HCkBinDataW bd);` |
| `S3_DownloadFile` | method | `BOOL CkHttpW_S3_DownloadFile(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, const wchar_t *localFilePath);` |
| `S3_DownloadString` | method | `BOOL CkHttpW_S3_DownloadString(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, const wchar_t *charset, const wchar_t *outStr); const wchar_t *CkHttpW_s3_DownloadString(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, const wchar_t *charset);` |
| `S3_FileExists` | method | `int CkHttpW_S3_FileExists(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName);` |
| `S3_GenPresignedUrl` | method | `BOOL CkHttpW_S3_GenPresignedUrl(HCkHttpW cHandle, const wchar_t *httpVerb, BOOL useHttps, const wchar_t *bucketName, const wchar_t *path, int numSecondsValid, const wchar_t *awsService, const wchar_t *outStr); const wchar_t *CkHttpW_s3_GenPresignedUrl(HCkHttpW cHandle, const wchar_t *httpVerb, BOOL useHttps, const wchar_t *bucketName, const wchar_t *path, int numSecondsValid, const wchar_t *awsService);` |
| `S3_ListBucketObjects` | method | `BOOL CkHttpW_S3_ListBucketObjects(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *outStr); const wchar_t *CkHttpW_s3_ListBucketObjects(HCkHttpW cHandle, const wchar_t *bucketPath);` |
| `S3_ListBuckets` | method | `BOOL CkHttpW_S3_ListBuckets(HCkHttpW cHandle, const wchar_t *outStr); const wchar_t *CkHttpW_s3_ListBuckets(HCkHttpW cHandle);` |
| `S3_UploadBd` | method | `BOOL CkHttpW_S3_UploadBd(HCkHttpW cHandle, HCkBinDataW bd, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);` |
| `S3_UploadFile` | method | `BOOL CkHttpW_S3_UploadFile(HCkHttpW cHandle, const wchar_t *localFilePath, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);` |
| `S3_UploadString` | method | `BOOL CkHttpW_S3_UploadString(HCkHttpW cHandle, const wchar_t *objectContent, const wchar_t *charset, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);` |
| `SetAuthPrivateKey` | method | `BOOL CkHttpW_SetAuthPrivateKey(HCkHttpW cHandle, const wchar_t *publicKeyId, HCkPrivateKeyW privKey);` |
| `SetAuthTokenSb` | method | `BOOL CkHttpW_SetAuthTokenSb(HCkHttpW cHandle, HCkStringBuilderW sb);` |
| `SetClientAssertionKey` | method | `BOOL CkHttpW_SetClientAssertionKey(HCkHttpW cHandle, HCkPrivateKeyW privKey, const wchar_t *kid);` |
| `SetCookieXml` | method | `BOOL CkHttpW_SetCookieXml(HCkHttpW cHandle, const wchar_t *domain, const wchar_t *cookieXml);` |
| `SetDPoPKey` | method | `BOOL CkHttpW_SetDPoPKey(HCkHttpW cHandle, HCkPrivateKeyW privKey);` |
| `SetOAuthRsaKey` | method | `BOOL CkHttpW_SetOAuthRsaKey(HCkHttpW cHandle, HCkPrivateKeyW privKey);` |
| `SetRequestHeader` | method | `void CkHttpW_SetRequestHeader(HCkHttpW cHandle, const wchar_t *headerFieldName, const wchar_t *headerFieldValue);` |
| `SetSecurePassword` | method | `BOOL CkHttpW_SetSecurePassword(HCkHttpW cHandle, HCkSecureStringW password);` |
| `SetSslCertRequirement` | method | `void CkHttpW_SetSslCertRequirement(HCkHttpW cHandle, const wchar_t *reqName, const wchar_t *reqValue);` |
| `SetSslClientCert` | method | `BOOL CkHttpW_SetSslClientCert(HCkHttpW cHandle, HCkCertW cert);` |
| `SetSslClientCertPem` | method | `BOOL CkHttpW_SetSslClientCertPem(HCkHttpW cHandle, const wchar_t *pemDataOrPath, const wchar_t *pemPassword);` |
| `SetSslClientCertPfx` | method | `BOOL CkHttpW_SetSslClientCertPfx(HCkHttpW cHandle, const wchar_t *pfxPath, const wchar_t *pfxPassword);` |
| `SetUrlVar` | method | `BOOL CkHttpW_SetUrlVar(HCkHttpW cHandle, const wchar_t *name, const wchar_t *value);` |
| `SharePointOnlineAuth` | method | `BOOL CkHttpW_SharePointOnlineAuth(HCkHttpW cHandle, const wchar_t *siteUrl, const wchar_t *username, HCkSecureStringW password, HCkJsonObjectW extraInfo);` |
| `SleepMs` | method | `void CkHttpW_SleepMs(HCkHttpW cHandle, int millisec);` |
| `UrlDecode` | method | `BOOL CkHttpW_UrlDecode(HCkHttpW cHandle, const wchar_t *str, const wchar_t *outStr); const wchar_t *CkHttpW_urlDecode(HCkHttpW cHandle, const wchar_t *str);` |
| `UrlEncode` | method | `BOOL CkHttpW_UrlEncode(HCkHttpW cHandle, const wchar_t *str, const wchar_t *outStr); const wchar_t *CkHttpW_urlEncode(HCkHttpW cHandle, const wchar_t *str);` |
| `VerifyTimestampReply` | method | `int CkHttpW_VerifyTimestampReply(HCkHttpW cHandle, HCkBinDataW timestampReply, HCkCertW tsaCert);` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### Http.AbortCurrent

`Chilkat 11.7.0 · wc · Http · AbortCurrent · property · read/write · since 9.5.0.58`

```c
BOOL CkHttpW_getAbortCurrent(HCkHttpW cHandle);
void CkHttpW_putAbortCurrent(HCkHttpW cHandle, BOOL newVal);
```

When set to `TRUE`, causes the currently running method to abort. Methods that always finish quickly (i.e.have no length file operations or network communications) are not affected. If no method is running, then this property is automatically reset to `FALSE` when the next method is called. When the abort occurs, this property is reset to `FALSE`. Both synchronous and asynchronous method calls can be aborted. (A synchronous method call could be aborted by setting this property from a separate thread.)

### Http.Accept

`Chilkat 11.7.0 · wc · Http · Accept · property · read/write`

```c
void CkHttpW_getAccept(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAccept(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_accept(HCkHttpW cHandle);
```

**Full documentation for this property (same in every language):** [Chilkat HTTP Default and Auto-Generated Headers](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/http_default_headers.md)

This property sets the `Accept` header for all HTTP requests, except those sent by the `HttpReq` and `HttpSReq` methods that use headers from an `HttpRequest` object.

By default, it is set to `*/*`.

Setting this property is the same as calling `SetRequestHeader` with `Accept` as the header field name.

The **`Accept` HTTP header** is sent by the client (your application) to tell the server **which content types (MIME types) it can handle in the response**.

For example, the following means only a JSON response is accepted:

```
Accept: application/json
```

### Http.AllowGzip

`Chilkat 11.7.0 · wc · Http · AllowGzip · property · read/write`

```c
BOOL CkHttpW_getAllowGzip(HCkHttpW cHandle);
void CkHttpW_putAllowGzip(HCkHttpW cHandle, BOOL newVal);
```

**Full documentation for this property (same in every language):** [Chilkat HTTP Default and Auto-Generated Headers](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/http_default_headers.md)

If `TRUE` then the `Accept-Encoding: gzip` is automatically added for all HTTP requests, except those made using the `HttpReq` and `HttpSReq` methods that use headers from an HttpRequest object.

The default value is `TRUE`.

The **`Accept-Encoding` HTTP header** is sent by the client to tell the server **which compression algorithms it supports for the response body**.

Example:

```
Accept-Encoding: gzip, deflate
```

This means the client can handle responses compressed with **gzip** or **deflate**.

If this property is set to `FALSE`, then the `Accept-Encoding` header is added, but the value is empty, like this:

```
Accept-Encoding:
```

It means the client explicitly does not accept any content codings (no compression, no transformations).

- An **absent** `Accept-Encoding` header means the client will accept any encoding (server chooses, often `gzip`).
- An **empty** `Accept-Encoding` header means **only the “identity” encoding** (i.e., uncompressed) is acceptable.

The `SetRequestHeader` method can be called with `Accept-Encoding` as the header field name to explicitly set the `Accept-Encoding` header. Note: **Chilkat does not accept Brotli** responses. Do not include `br` in the list of encodings for this header.

The `RemoveRequestHeader` can be called to explicit omit the `Accept-Encoding` header field from HTTP requests.

### Http.AllowHeaderFolding

`Chilkat 11.7.0 · wc · Http · AllowHeaderFolding · property · read/write · since 9.5.0.63`

```c
BOOL CkHttpW_getAllowHeaderFolding(HCkHttpW cHandle);
void CkHttpW_putAllowHeaderFolding(HCkHttpW cHandle, BOOL newVal);
```

When set to `FALSE`, MIME header folding is not applied to request headers automatically. By default, this setting is `TRUE`. This property exists for rare instances when a server cannot properly handle folded MIME headers.

**MIME header folding** allows long header lines to be split across multiple lines for readability.

A folded line begins with **whitespace (space or tab)**, which signals continuation.

**Unfolded (single line):**

```
Subject: This is a very long subject line that needs to be wrapped across lines
```

**Folded (wrapped for transport):**

```
Subject: This is a very long subject line
 that needs to be wrapped across lines
```

When received, the folded version is **unfolded back into a single line** by removing the CRLF + leading whitespace.

### Http.AuthSignature

`Chilkat 11.7.0 · wc · Http · AuthSignature · property · read/write · since 9.5.0.89`

```c
void CkHttpW_getAuthSignature(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAuthSignature(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_authSignature(HCkHttpW cHandle);
```

This property can be set to a JSON string containing the required information to add an `HTTP Signature` in the following format:

```
Authorization: Signature
  keyId="my-key-1",
  algorithm="hmac-sha256",
  headers="(request-target) host date",
  signature="Base64OfSignature"
```

See the linked example below for details.

### Http.AuthToken

`Chilkat 11.7.0 · wc · Http · AuthToken · property · read/write · since 9.5.0.67`

```c
void CkHttpW_getAuthToken(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAuthToken(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_authToken(HCkHttpW cHandle);
```

Applications can set this property to the `OAuth2` `access_token` value to be sent in the `Authorization: Bearer {access_token}` header for all requests. For `OAuth1.0a` tokens, use the `OAuthToken` property instead.

Starting from `Chilkat v10.1.2`, this method can also accept a `JSON string` containing details needed for automatic OAuth2 access token retrieval via the `Client Credentials` flow. The JSON must include the `client secret`, `client ID`, `token endpoint`, and `scope(s)`. See the example below for guidance. This feature is compatible with any OAuth2 provider that supports the client credentials flow.

### Http.AutoAddHostHeader

`Chilkat 11.7.0 · wc · Http · AutoAddHostHeader · property · read/write`

```c
BOOL CkHttpW_getAutoAddHostHeader(HCkHttpW cHandle);
void CkHttpW_putAutoAddHostHeader(HCkHttpW cHandle, BOOL newVal);
```

When set to `TRUE` (the default), the `Host` header is automatically added to all requests. The domain for the `Host` header is taken from the URL passed in a method's arguments.

The **`Host` HTTP header** specifies the **hostname (and optional port)** of the server the client is trying to reach.

Example:

```
Host: www.example.com
```

It’s required in HTTP/1.1 so a server can distinguish between multiple sites (virtual hosts) on the same IP address.

### Http.AwsAccessKey

`Chilkat 11.7.0 · wc · Http · AwsAccessKey · property · read/write`

```c
void CkHttpW_getAwsAccessKey(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAwsAccessKey(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_awsAccessKey(HCkHttpW cHandle);
```

The AWS Access Key to be used with the Amazon S3 methods listed below.

### Http.AwsEndpoint

`Chilkat 11.7.0 · wc · Http · AwsEndpoint · property · read/write`

```c
void CkHttpW_getAwsEndpoint(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAwsEndpoint(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_awsEndpoint(HCkHttpW cHandle);
```

Specify the regional endpoint (domain) for `Amazon S3` method calls. The default is `s3.amazonaws.com`, but you can use any valid Amazon S3 endpoint, such as `s3-eu-west-1.amazonaws.com`, or endpoints from other **S3-API compatible services**.

### Http.AwsRegion

`Chilkat 11.7.0 · wc · Http · AwsRegion · property · read/write · since 9.5.0.56`

```c
void CkHttpW_getAwsRegion(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAwsRegion(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_awsRegion(HCkHttpW cHandle);
```

The AWS S3 region (e.g., `us-east-1`, `us-west-2`, `eu-west-1`, `eu-central-1`) defaults to `us-east-1`. It is relevant only when the `AwsSignatureVersion` property is set to 4 and ignored when set to 2.

### Http.AwsSecretKey

`Chilkat 11.7.0 · wc · Http · AwsSecretKey · property · read/write`

```c
void CkHttpW_getAwsSecretKey(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAwsSecretKey(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_awsSecretKey(HCkHttpW cHandle);
```

The AWS Secret Key to be used with the Amazon S3 methods listed below.

### Http.AwsSessionToken

`Chilkat 11.7.0 · wc · Http · AwsSessionToken · property · read/write · since 9.5.0.95`

```c
void CkHttpW_getAwsSessionToken(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAwsSessionToken(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_awsSessionToken(HCkHttpW cHandle);
```

This is the AWS session token for temporary security credentials.

When you call **`AssumeRole`** with AWS STS, you get **temporary security credentials** consisting of:

- **Access key ID**
- **Secret access key**
- **Session token**

The **session token** is an extra credential that must be included with the access key and secret key when signing requests. It proves the credentials came from STS and are valid for the limited session duration.

In short: **The AWS session token is a required component of temporary STS credentials, used alongside the key pair to authenticate API calls.**

### Http.AwsSubResources

`Chilkat 11.7.0 · wc · Http · AwsSubResources · property · read/write`

```c
void CkHttpW_getAwsSubResources(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putAwsSubResources(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_awsSubResources(HCkHttpW cHandle);
```

This property can be used to specify **sub-resources** to be included in the Amazon S3 methods listed below. For example, set the property to `acl&versionId=value` to request the acl for a specific version of an object.

In Amazon S3, **sub-resources** are special query parameters you can append to an S3 object or bucket URL to access or manage **specific properties or features** beyond the main resource itself.

Examples:

- **Bucket sub-resources:** `?logging`, `?website`, `?lifecycle`, `?policy`
- **Object sub-resources:** `?acl`, `?torrent`, `?restore`, `?tagging`

So:

- **Resource** = the bucket or object itself (e.g., `mybucket/photo.jpg`)
- **Sub-resource** = a specific aspect or configuration of it, accessed with a query string (e.g., `mybucket?logging` or `photo.jpg?acl`).

In short: **S3 sub-resources let you operate on metadata/configuration of a bucket or object, not the content itself.**

### Http.BandwidthThrottleDown

`Chilkat 11.7.0 · wc · Http · BandwidthThrottleDown · property · read/write · since 9.5.0.49`

```c
int CkHttpW_getBandwidthThrottleDown(HCkHttpW cHandle);
void CkHttpW_putBandwidthThrottleDown(HCkHttpW cHandle, int newVal);
```

If set to a non-zero value, this **limits the download bandwidth** to the specified maximum number of bytes per second. The default value is `0`.

### Http.BandwidthThrottleUp

`Chilkat 11.7.0 · wc · Http · BandwidthThrottleUp · property · read/write · since 9.5.0.49`

```c
int CkHttpW_getBandwidthThrottleUp(HCkHttpW cHandle);
void CkHttpW_putBandwidthThrottleUp(HCkHttpW cHandle, int newVal);
```

If set to a non-zero value, this property **limits the upload bandwidth** to the specified maximum number of bytes per second. The default is `0`.

### Http.BasicAuth

`Chilkat 11.7.0 · wc · Http · BasicAuth · property · read/write`

```c
BOOL CkHttpW_getBasicAuth(HCkHttpW cHandle);
void CkHttpW_putBasicAuth(HCkHttpW cHandle, BOOL newVal);
```

To enable HTTP basic authentication, set this property to `TRUE`. The default value is `FALSE`.

Then basic authentication is enabled, Chilkat uses the `Login` and `Password` properties to include the `Authorization: Basic {base64}` header in all requests.

**HTTP Basic Authentication** is a simple authentication scheme where the client sends a username and password encoded in **Base64** in the `Authorization` header.

Example:

```
Authorization: Basic dXNlcjpwYXNzd29yZA==
```

Here `dXNlcjpwYXNzd29yZA==` is the Base64 of `user:password`.

### Http.ClientIpAddress

`Chilkat 11.7.0 · wc · Http · ClientIpAddress · property · read/write`

```c
void CkHttpW_getClientIpAddress(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putClientIpAddress(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_clientIpAddress(HCkHttpW cHandle);
```

A computer can have **multiple network interfaces** (e.g., Ethernet, Wi-Fi, VPN, virtual adapters). Each interface can have one or more **IP addresses** (IPv4 and/or IPv6).

If multiple IPs exist (say, `192.168.1.10` on Wi-Fi and `10.0.0.5` on Ethernet), the application can bind explicitly to either one, determining which interface and address the socket will use for communication.

This property can be set to explicitly bind the communications socket to an IP address.

The default value is the empty string, which means the application does not bind to a specific local IP before connecting and the OS network stack automatically picks the default source IP.

### Http.ConnectFailReason

`Chilkat 11.7.0 · wc · Http · ConnectFailReason · property · read-only · since 9.5.0.56`

```c
int CkHttpW_getConnectFailReason(HCkHttpW cHandle);
```

This property will be set to the status of the last HTTP connection made (or failed to be made) by any HTTP method.

Possible values are:

```
0 = success

Normal (non-TLS) sockets:
1 = empty hostname
2 = DNS lookup failed
3 = DNS timeout
4 = Aborted by application.
5 = Internal failure.
6 = Connect Timed Out
7 = Connect Rejected (or failed for some other reason)
50 = HTTP proxy authentication failure.
98 = Async operation in progress.
99 = Product is not unlocked.

SSL/TLS:
100 = TLS internal error.
101 = Failed to send client hello.
102 = Unexpected handshake message.
103 = Failed to read server hello.
104 = No server certificate.
105 = Unexpected TLS protocol version.
106 = Server certificate verify failed (the server certificate is expired or the cert's signature verification failed).
107 = Unacceptable TLS protocol version.
108 = App-defined server certificate requirements failure.
109 = Failed to read handshake messages.
110 = Failed to send client certificate handshake message.
111 = Failed to send client key exchange handshake message.
112 = Client certificate's private key not accessible.
113 = Failed to send client cert verify handshake message.
114 = Failed to send change cipher spec handshake message.
115 = Failed to send finished handshake message.
116 = Server's Finished message is invalid.
125 = Peer tried to connect using older SSL 2.0 protocol version.
126 = TLS Pin Set Mismatch.
127 = TLS 1.3 handshake error.
```

### Http.ConnectTimeout

`Chilkat 11.7.0 · wc · Http · ConnectTimeout · property · read/write`

```c
int CkHttpW_getConnectTimeout(HCkHttpW cHandle);
void CkHttpW_putConnectTimeout(HCkHttpW cHandle, int newVal);
```

Determines the maximum time, **in seconds**, to wait for an HTTP server to accept a TCP connection before timing out. The **default value is 30 seconds**.

Note: A **TLS connection** always starts with a normal TCP connection (e.g., client connects to server on port 443). Once TCP is established, the client and server perform a TLS handshake: they exchange cryptographic messages to authenticate, agree on encryption keys, and set up a secure channel.

The `ReadTimeout` property applies to TLS handshake communications. When establishing a TLS connection, the `ConnectTimeout` governs the initial TCP connection, followed by the `ReadTimeout`.

### Http.CookieDir

`Chilkat 11.7.0 · wc · Http · CookieDir · property · read/write`

```c
void CkHttpW_getCookieDir(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putCookieDir(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_cookieDir(HCkHttpW cHandle);
```

Designates a directory path for automatic cookie storage (such as `"c:/myCookieDir"` or `"/Users/example/myCookieDir"`) when the `SaveCookies` property is set to `TRUE`. Cookies are saved in XML files, with one file per domain. Alternatively, set the value to `memory` to cache cookies in memory.

The **default value is the empty string**, which means cookies are not saved regardless of the `SaveCookies` setting.

### Http.DefaultFreshPeriod

`Chilkat 11.7.0 · wc · Http · DefaultFreshPeriod · property · read/write`

```c
int CkHttpW_getDefaultFreshPeriod(HCkHttpW cHandle);
void CkHttpW_putDefaultFreshPeriod(HCkHttpW cHandle, int newVal);
```

Sets the default freshness period (in minutes) for cached documents when the `FreshnessAlgorithm` property is set to 0. The default value is 10080 (1 week).

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.DigestAuth

`Chilkat 11.7.0 · wc · Http · DigestAuth · property · read/write`

```c
BOOL CkHttpW_getDigestAuth(HCkHttpW cHandle);
void CkHttpW_putDigestAuth(HCkHttpW cHandle, BOOL newVal);
```

Setting this property to `TRUE` causes the HTTP component to use digest authentication. The default value is `FALSE`.

HTTP **Digest Authentication** is a challenge–response mechanism where the server sends a nonce (a unique random value) to the client. The client must hash the username, password, nonce, and request details (method, URI) into a digest using MD5 (or similar). The server performs the same calculation to verify.

Unlike **Basic Auth**, the password is never sent in clear text—only the hash is transmitted—making it more secure against eavesdropping.

### Http.EnableSecrets

`Chilkat 11.7.0 · wc · Http · EnableSecrets · property · read/write · since 11.5.0`

```c
BOOL CkHttpW_getEnableSecrets(HCkHttpW cHandle);
void CkHttpW_putEnableSecrets(HCkHttpW cHandle, BOOL newVal);
```

**Full documentation for this property (same in every language):** [More Detailed Information About EnableSecrets](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/secret_specification_strings.md)

This property that automatic resolution of credentials from the operating system’s secure storage.

When set to `TRUE`, the supported properties and methods (listed below) can accept a **secret specification string** (beginning with `!!`) in place of a literal value. Chilkat detects this format and retrieves the corresponding secret from:

- **Windows Credential Manager** (Windows)
- **Apple Keychain** (macOS)

Secrets are identified using a structured string format: `!![appName|]service[|domain]|username`

Applies to `AwsAccessKey` , `AwsEndpoint` , `AwsRegion` , `AwsSessionToken` , `AwsSecretKey` , `ProxyPassword` , `SocksPassword` , `Password` .

This feature allows applications to avoid embedding sensitive data directly in code by securely resolving credentials at runtime.

The default value is `FALSE`

### Http.FetchFromCache

`Chilkat 11.7.0 · wc · Http · FetchFromCache · property · read/write`

```c
BOOL CkHttpW_getFetchFromCache(HCkHttpW cHandle);
void CkHttpW_putFetchFromCache(HCkHttpW cHandle, BOOL newVal);
```

Set to `TRUE` to enable fetching pages from cache whenever possible. **The default value is `FALSE`.** Only HTTP GET requests are cached. HTTP responses containing `Set-Cookie` headers are never cached. A page is retrieved from the disk cache if it exists and is deemed fresh by the `FreshnessAlgorithm` property. If the cached page is stale, the HTTP component will send a revalidate request and update the cache based on the response.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.FinalRedirectUrl

`Chilkat 11.7.0 · wc · Http · FinalRedirectUrl · property · read-only`

```c
void CkHttpW_getFinalRedirectUrl(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_finalRedirectUrl(HCkHttpW cHandle);
```

If the `WasRedirected` property indicates an HTTP GET was redirected, and the `FollowRedirects` property is set to `TRUE`, this property will hold the final redirect URL. This property will also contain the redirect URL for `301/302` responses, even if `FollowRedirects` is not `TRUE`.

### Http.FollowRedirects

`Chilkat 11.7.0 · wc · Http · FollowRedirects · property · read/write`

```c
BOOL CkHttpW_getFollowRedirects(HCkHttpW cHandle);
void CkHttpW_putFollowRedirects(HCkHttpW cHandle, BOOL newVal);
```

When set to `TRUE`, `301`, `302`, `303`, `307`, and `308` redirects are automatically followed. The default setting is `TRUE`.

To determine if a redirect occurred, check the `WasRedirected` property. The final URL after redirection is available in the `FinalRedirectUrl` property.

### Http.FreshnessAlgorithm

`Chilkat 11.7.0 · wc · Http · FreshnessAlgorithm · property · read/write`

```c
int CkHttpW_getFreshnessAlgorithm(HCkHttpW cHandle);
void CkHttpW_putFreshnessAlgorithm(HCkHttpW cHandle, int newVal);
```

To determine the freshness of a cached HTTP GET response, the freshness algorithm is employed. By default, it uses the `LM-factor` algorithm, which is activated when the `FreshnessAlgorithm` is set to `1`. The `LMFactor` property, ranging from 1 to 100, specifies the percentage of the time since the last modification date of the HTML page that the page remains fresh. For instance, if the LMFactor is 50 and the page was last modified 10 days ago, it will expire after 5 days (50% of 10 days). This applies only to HTTP responses without explicit expiration information. If the FreshnessAlgorithm is set to `0`, a constant expiry period, defined by the `DefaultFreshPeriod` property, is applied.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.HeartbeatMs

`Chilkat 11.7.0 · wc · Http · HeartbeatMs · property · read/write`

```c
int CkHttpW_getHeartbeatMs(HCkHttpW cHandle);
void CkHttpW_putHeartbeatMs(HCkHttpW cHandle, int newVal);
```

**Full documentation for this property (same in every language):** [Event Callback Examples](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/event_callback_examples.md)

The interval in milliseconds between each `AbortCheck` event callback, which enables an application to abort certain method calls before they complete. **By default, HeartbeatMs is set to** `0`**, meaning no AbortCheck event callbacks will trigger.**

### Http.IgnoreMustRevalidate

`Chilkat 11.7.0 · wc · Http · IgnoreMustRevalidate · property · read/write`

```c
BOOL CkHttpW_getIgnoreMustRevalidate(HCkHttpW cHandle);
void CkHttpW_putIgnoreMustRevalidate(HCkHttpW cHandle, BOOL newVal);
```

If an HTTP response includes the `Cache-Control: must-revalidate` header, it indicates that the server requires the client to revalidate the page with the server rather than serving it directly from the cache. However, if this property is set to `TRUE`, the page will be served directly from the cache without revalidation until it expires. The defautl value of this property is `FALSE`.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.IgnoreNoCache

`Chilkat 11.7.0 · wc · Http · IgnoreNoCache · property · read/write`

```c
BOOL CkHttpW_getIgnoreNoCache(HCkHttpW cHandle);
void CkHttpW_putIgnoreNoCache(HCkHttpW cHandle, BOOL newVal);
```

Some HTTP responses include headers indicating the page should not be cached. Chilkat HTTP will follow these instructions unless this property is set to `TRUE`. The default value of this property is `FALSE`.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.KeepResponseBody

`Chilkat 11.7.0 · wc · Http · KeepResponseBody · property · read/write · since 9.5.0.55`

```c
BOOL CkHttpW_getKeepResponseBody(HCkHttpW cHandle);
void CkHttpW_putKeepResponseBody(HCkHttpW cHandle, BOOL newVal);
```

If set to `TRUE`, the response body, if it is text, is stored in the `LastResponseBody` property for methods **not** returning an `HttpResponse` object. By default, this property is `FALSE`.

Note: Many methods provide an `HttpResponse` object as their final output argument.

### Http.LastContentType

`Chilkat 11.7.0 · wc · Http · LastContentType · property · read-only`

```c
void CkHttpW_getLastContentType(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_lastContentType(HCkHttpW cHandle);
```

The `Content-Type` header value from the most recent HTTP response received.

### Http.LastFromCache

`Chilkat 11.7.0 · wc · Http · LastFromCache · property · read-only · since 9.5.0.91`

```c
BOOL CkHttpW_getLastFromCache(HCkHttpW cHandle);
```

`TRUE` if the last GET was fetched from cache.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.LastHeader

`Chilkat 11.7.0 · wc · Http · LastHeader · property · read-only`

```c
void CkHttpW_getLastHeader(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_lastHeader(HCkHttpW cHandle);
```

Contains the text of the last HTTP header sent by any method.

An **HTTP request** begins with a **start line** (called the \*status line\*), which contains the protocol version, status code, and reason phrase (e.g., `HTTP/1.1 200 OK`).

After that comes the **header section**, made up of key–value pairs (like `Content-Type: text/html`).

This property contains both the start line and the header section. For example:

```
POST /echo_request_body.asp HTTP/1.1
Host: chilkatsoft.com
Accept: */*
Accept-Encoding: gzip
Content-Type: application/json
Content-Length: 26
```

### Http.LastModDate

`Chilkat 11.7.0 · wc · Http · LastModDate · property · read-only`

```c
void CkHttpW_getLastModDate(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_lastModDate(HCkHttpW cHandle);
```

The `Last-Modified` header value from the most recent HTTP response received.

### Http.LastResponseBody

`Chilkat 11.7.0 · wc · Http · LastResponseBody · property · read-only · since 9.5.0.55`

```c
void CkHttpW_getLastResponseBody(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_lastResponseBody(HCkHttpW cHandle);
```

The response body from the last HTTP request is saved in this property only if the `KeepResponseBody` property is set to TRUE. This applies to methods that don't return an `HttpResponse` object.

### Http.LastResponseHeader

`Chilkat 11.7.0 · wc · Http · LastResponseHeader · property · read-only`

```c
void CkHttpW_getLastResponseHeader(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_lastResponseHeader(HCkHttpW cHandle);
```

Returns the most recent full response header for methods that do not use an `HttpResponse` object. For example:

```
Content-Type: application/json
Last-Modified: Sun, 20 Aug 2023 11:36:27 GMT
Accept-Ranges: bytes
ETag: "34c27f8e5ad3d91:0"
Server: Microsoft-IIS/10.0
X-Powered-By: ASP.NET
Date: Sat, 30 Aug 2025 14:35:55 GMT
Content-Length: 22
```

### Http.LastStatus

`Chilkat 11.7.0 · wc · Http · LastStatus · property · read-only`

```c
int CkHttpW_getLastStatus(HCkHttpW cHandle);
```

Contains the most recent **response status code** for methods that don't utilize an `HttpResponse` object.

### Http.LastStatusText

`Chilkat 11.7.0 · wc · Http · LastStatusText · property · read-only · since 9.5.0.69`

```c
void CkHttpW_getLastStatusText(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_lastStatusText(HCkHttpW cHandle);
```

Contains the latest **response status text** for methods that don't use an `HttpResponse` object. The response status text appears after the status code in the first line of an HTTP response. For example, in the HTTP response below, the status text is `OK`:

```
HTTP/1.1 200 OK
Content-Type: application/json
Last-Modified: Sun, 20 Aug 2023 11:36:27 GMT
Accept-Ranges: bytes
ETag: "34c27f8e5ad3d91:0"
Server: Microsoft-IIS/10.0
X-Powered-By: ASP.NET
Date: Sat, 30 Aug 2025 14:35:55 GMT
Content-Length: 22

{ "hello": "world" }
```

### Http.LMFactor

`Chilkat 11.7.0 · wc · Http · LMFactor · property · read/write`

```c
int CkHttpW_getLMFactor(HCkHttpW cHandle);
void CkHttpW_putLMFactor(HCkHttpW cHandle, int newVal);
```

The LMFactor is an integer between 1 and 100 that specifies the percentage of time from an HTTP page's last-modified date to be used as the freshness period. The **default is 25**. For instance, if a page's last-modified date is 4 weeks ago and LMFactor is set to 25, the page will remain fresh in the cache for 1 week (25% of 4 weeks).

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.Login

`Chilkat 11.7.0 · wc · Http · Login · property · read/write`

```c
void CkHttpW_getLogin(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putLogin(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_login(HCkHttpW cHandle);
```

This is the login string to be used with HTTP `basic`, `digest`, or `NTLM` authentication.

### Http.LoginDomain

`Chilkat 11.7.0 · wc · Http · LoginDomain · property · read/write`

```c
void CkHttpW_getLoginDomain(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putLoginDomain(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_loginDomain(HCkHttpW cHandle);
```

The optional domain name to be used with NTLM authentication.

In **NTLM HTTP authentication**, the **login domain** is the Windows domain that contains the user account.

The client sends it in the NTLM messages (e.g., `DOMAIN\Username`) so the server knows which domain controller to contact to verify the credentials. If no domain is given, the server may fall back to checking local machine accounts.

### Http.MaxConnections

`Chilkat 11.7.0 · wc · Http · MaxConnections · property · read/write`

```c
int CkHttpW_getMaxConnections(HCkHttpW cHandle);
void CkHttpW_putMaxConnections(HCkHttpW cHandle, int newVal);
```

This class automatically manages simultaneous open HTTP connections. If the maximum number of connections is reached, the least recently active connection is automatically closed. The default value is `10`.

An **HTTP connection** can remain open if the client and server use **persistent connections** (e.g., `Connection: keep-alive` in HTTP/1.1).

This allows multiple requests and responses to be sent over the same TLS connection instead of opening a new one each time.

**Reasons:**

- Reduces latency (no repeated TLS handshakes).
- Improves efficiency for sending many requests.

Also see: `CloseAllConnections`

### Http.MaxFreshPeriod

`Chilkat 11.7.0 · wc · Http · MaxFreshPeriod · property · read/write`

```c
int CkHttpW_getMaxFreshPeriod(HCkHttpW cHandle);
void CkHttpW_putMaxFreshPeriod(HCkHttpW cHandle, int newVal);
```

Sets a time limit for how long a document can remain fresh in the cache, measured in minutes, with a default value of 525,600 minutes (equivalent to 1 year).

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.MaxResponseSize

`Chilkat 11.7.0 · wc · Http · MaxResponseSize · property · read/write`

```c
unsigned long CkHttpW_getMaxResponseSize(HCkHttpW cHandle);
void CkHttpW_putMaxResponseSize(HCkHttpW cHandle, unsigned long newVal);
```

Specify the maximum HTTP response size the program will accept. The `default value of 0 means` there is `no size limit`. This safeguard helps prevent receiving excessively large responses that could hang or crash the application.

### Http.MaxUrlLen

`Chilkat 11.7.0 · wc · Http · MaxUrlLen · property · read/write`

```c
int CkHttpW_getMaxUrlLen(HCkHttpW cHandle);
void CkHttpW_putMaxUrlLen(HCkHttpW cHandle, int newVal);
```

Limit the length of URLs (including URL parameters) in HTTP requests by setting this property. The default value is `2000` characters.

### Http.MinFreshPeriod

`Chilkat 11.7.0 · wc · Http · MinFreshPeriod · property · read/write`

```c
int CkHttpW_getMinFreshPeriod(HCkHttpW cHandle);
void CkHttpW_putMinFreshPeriod(HCkHttpW cHandle, int newVal);
```

Sets the minimum time a document stays fresh in the cache, with a **default of 30 minutes**.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.NegotiateAuth

`Chilkat 11.7.0 · wc · Http · NegotiateAuth · property · read/write`

```c
BOOL CkHttpW_getNegotiateAuth(HCkHttpW cHandle);
void CkHttpW_putNegotiateAuth(HCkHttpW cHandle, BOOL newVal);
```

Set this property equal to `TRUE` for Negotiate authentication.

Note: The NegotiateAuth property is only available for the Microsoft Windows operating system.

### Http.NtlmAuth

`Chilkat 11.7.0 · wc · Http · NtlmAuth · property · read/write`

```c
BOOL CkHttpW_getNtlmAuth(HCkHttpW cHandle);
void CkHttpW_putNtlmAuth(HCkHttpW cHandle, BOOL newVal);
```

Setting this property to `TRUE` causes the HTTP component to use NTLM authentication (also known as IWA -- or Integrated Windows Authentication) when authentication with an HTTP server. The default value is `FALSE`.

### Http.NumCacheLevels

`Chilkat 11.7.0 · wc · Http · NumCacheLevels · property · read/write`

```c
int CkHttpW_getNumCacheLevels(HCkHttpW cHandle);
void CkHttpW_putNumCacheLevels(HCkHttpW cHandle, int newVal);
```

This setting determines the directory levels used under each cache root. The **default value is 0**, meaning cached HTML pages are stored directly in the cache root directory.

- **Level 0**: Cached pages are stored in the cache root directory.
- **Level 1**: Cached pages go into one of 255 subdirectories (0 to 255) under the cache root.
- **Level 2**: Two levels of subdirectories (0-255/0-255) are created under each cache root.

The HTTP class automatically creates these subdirectories as needed. Multiple directory levels help prevent issues caused by having too many files in a single directory.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.NumCacheRoots

`Chilkat 11.7.0 · wc · Http · NumCacheRoots · property · read-only`

```c
int CkHttpW_getNumCacheRoots(HCkHttpW cHandle);
```

Specifies the number of established cache roots used by the HTTP cache to distribute the disk cache across multiple directories. Each cache root is an absolute directory path, set using the `AddCacheRoot` method.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.OAuth1

`Chilkat 11.7.0 · wc · Http · OAuth1 · property · read/write`

```c
BOOL CkHttpW_getOAuth1(HCkHttpW cHandle);
void CkHttpW_putOAuth1(HCkHttpW cHandle, BOOL newVal);
```

If `TRUE` then causes an OAuth Authorization header to be added to any request sent by the HTTP object. For example:

```
Authorization: OAuth realm="http://sp.example.com/",
                oauth_consumer_key="0685bd9184jfhq22",
                oauth_token="ad180jjd733klru7",
                oauth_signature_method="HMAC-SHA1",
                oauth_signature="wOJIO9A2W5mFwDgiDvZbTSMK%2FPY%3D",
                oauth_timestamp="137131200",
                oauth_nonce="4572616e48616d6d65724c61686176",
                oauth_version="1.0"
```

The information used to compute the OAuth Authorization header is obtained from the other OAuth\* properties, such as OAuthConsumerKey, OAuthConsumerSecret, OAuthRealm, etc.

### Http.OAuthBodyHash

`Chilkat 11.7.0 · wc · Http · OAuthBodyHash · property · read/write · since 9.5.0.91`

```c
BOOL CkHttpW_getOAuthBodyHash(HCkHttpW cHandle);
void CkHttpW_putOAuthBodyHash(HCkHttpW cHandle, BOOL newVal);
```

When set to `TRUE`, the `oauth_body_hash`, which contains the `SHA-256` hash of the HTTP request body, is automatically included in the `OAuth1.0a Authorization header`.

For example:

```
Authorization: OAuth oauth_consumer_key="***", 
  oauth_nonce="A2E91C3B53E0BD7FBF71F441336679E358DDCEEE",
  oauth_body_hash="a5kPTsDwUwmBjC0voNlAAvM6YoaRS5X7sTO49jl3/h8=",
  oauth_timestamp="1756324932",
  oauth_signature_method="RSA-SHA256",
  oauth_version="1.0",
  oauth_signature="****"
```

This property is only used when the `OAuth1` property equals `TRUE`.

### Http.OAuthCallback

`Chilkat 11.7.0 · wc · Http · OAuthCallback · property · read/write · since 9.5.0.53`

```c
void CkHttpW_getOAuthCallback(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putOAuthCallback(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_oAuthCallback(HCkHttpW cHandle);
```

The `OAuth 1.0a` callback URL. Defaults to `oob`.

This property is only used when the `OAuth1` property equals `TRUE`.

### Http.OAuthConsumerKey

`Chilkat 11.7.0 · wc · Http · OAuthConsumerKey · property · read/write`

```c
void CkHttpW_getOAuthConsumerKey(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putOAuthConsumerKey(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_oAuthConsumerKey(HCkHttpW cHandle);
```

The `OAuth1.0a` consumer key to be used in the `oauth_consumer_key` parameter of the `Authorization` header.

This property is only used when the `OAuth1` property equals `TRUE`.

### Http.OAuthConsumerSecret

`Chilkat 11.7.0 · wc · Http · OAuthConsumerSecret · property · read/write`

```c
void CkHttpW_getOAuthConsumerSecret(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putOAuthConsumerSecret(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_oAuthConsumerSecret(HCkHttpW cHandle);
```

The consumer secret to be used in computing the contents of the `OAuth1.0a` `Authorization` header.

This property is only used when the `OAuth1` property equals `TRUE`.

### Http.OAuthRealm

`Chilkat 11.7.0 · wc · Http · OAuthRealm · property · read/write`

```c
void CkHttpW_getOAuthRealm(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putOAuthRealm(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_oAuthRealm(HCkHttpW cHandle);
```

The OAuth1.0a `realm` to be used in the `Authorization` header.

The OAuth 1.0a realm parameter is an optional, descriptive string in the Authorization header that indicates the protected resources’ scope. It is **not required**, not included in the signature, and **rarely used** in real-world APIs. Most modern OAuth 1.0a integrations ignore it completely.

This property is only used when the `OAuth1` property equals `TRUE`.

### Http.OAuthSigMethod

`Chilkat 11.7.0 · wc · Http · OAuthSigMethod · property · read/write`

```c
void CkHttpW_getOAuthSigMethod(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putOAuthSigMethod(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_oAuthSigMethod(HCkHttpW cHandle);
```

Specify the `oauth_signature_method` parameter in the `OAuth 1.0a Authorization header`. The default method is `HMAC-SHA1`, but it can be set to `HMAC-SHA256`, `RSA-SHA1`, or `RSA-SHA256`. For `RSA` methods, provide an RSA private key using the `SetOAuthRsaKey` method.

This property is only used when the `OAuth1` property equals `TRUE`.

Note that RSA-SHA256 is supported from Chilkat v9.5.0.56 onwards.

### Http.OAuthToken

`Chilkat 11.7.0 · wc · Http · OAuthToken · property · read/write`

```c
void CkHttpW_getOAuthToken(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putOAuthToken(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_oAuthToken(HCkHttpW cHandle);
```

The value to be used for the `oauth_token` parameter in the `OAuth1.0a` `Authorization` header.

This property is only used when the `OAuth1` property equals `TRUE`.

### Http.OAuthTokenSecret

`Chilkat 11.7.0 · wc · Http · OAuthTokenSecret · property · read/write`

```c
void CkHttpW_getOAuthTokenSecret(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putOAuthTokenSecret(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_oAuthTokenSecret(HCkHttpW cHandle);
```

The `OAuth1.0a` token secret to be used in computing the Authorization header.

This property is only used when the `OAuth1` property equals `TRUE`.

### Http.OAuthVerifier

`Chilkat 11.7.0 · wc · Http · OAuthVerifier · property · read/write`

```c
void CkHttpW_getOAuthVerifier(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putOAuthVerifier(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_oAuthVerifier(HCkHttpW cHandle);
```

The value to be used for the verifier to be used in the `oauth_verifier` parameter of the `OAuth1.0a` `Authorization` header.

This property is only used when the `OAuth1` property equals `TRUE`.

### Http.Password

`Chilkat 11.7.0 · wc · Http · Password · property · read/write`

```c
void CkHttpW_getPassword(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putPassword(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_password(HCkHttpW cHandle);
```

The HTTP password for pages requiring a login/password. Chilkat HTTP can do Basic, Digest, and NTLM HTTP authentication. (NTLM is also known as SPA (or Windows Integrated Authentication). To use Basic authentication, the BasicAuth property must be set equal to `TRUE`. It is not necessary to set the NtlmAuth or DigestAuth properties beforehand if NTLM or Digest authentication is needed. However, it is most efficient to pre-set these properties when the type of authentication is known in advance.

**Note:** When the Login and Password properties are set, and the type of authentication is specified by setting one of the following properties equal to `TRUE` (BasicAuth, DigestAuth, NtlmAuth), Chilkat will automatically add the `Authorization: ...` header in the correct format.

### Http.PercentDoneScale

`Chilkat 11.7.0 · wc · Http · PercentDoneScale · property · read/write · since 9.5.0.49`

```c
int CkHttpW_getPercentDoneScale(HCkHttpW cHandle);
void CkHttpW_putPercentDoneScale(HCkHttpW cHandle, int newVal);
```

This property is only valid in programming environment and languages that allow for event callbacks.

Sets the value to be defined as 100% complete for the purpose of PercentDone event callbacks. The defaut value of 100 means that at most 100 event PercentDone callbacks will occur in a method that (1) is event enabled and (2) is such that it is possible to measure progress as a percentage completed. This property may be set to larger numbers to get more fine-grained PercentDone callbacks. For example, setting this property equal to 1000 will provide callbacks with .1 percent granularity. For example, a value of 453 would indicate 45.3% competed. This property is clamped to a minimum value of 10, and a maximum value of 100000.

### Http.PreferIpv6

`Chilkat 11.7.0 · wc · Http · PreferIpv6 · property · read/write`

```c
BOOL CkHttpW_getPreferIpv6(HCkHttpW cHandle);
void CkHttpW_putPreferIpv6(HCkHttpW cHandle, BOOL newVal);
```

If `TRUE`, then use IPv6 over IPv4 when both are supported for a particular domain. The default value of this property is `FALSE`, which will choose IPv4 over IPv6.

### Http.ProxyAuthMethod

`Chilkat 11.7.0 · wc · Http · ProxyAuthMethod · property · read/write`

```c
void CkHttpW_getProxyAuthMethod(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putProxyAuthMethod(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_proxyAuthMethod(HCkHttpW cHandle);
```

Set this to `basic` if you know in advance that Basic authentication is to be used for the HTTP proxy. Otherwise leave this property unset. Note: It is not necessary to set this property. The HTTP component will automatically handle proxy authentication for any of the supported authentication methods: NTLM, Digest, or Basic. Setting this property equal to `basic` prevents the 407 response which is automatically handled internal to Chilkat and never seen by your application.

**Note:** If NTLM authentication does not succeed, set the Global.DefaultNtlmVersion property equal to 1 and then retry.

### Http.ProxyDirectTls

`Chilkat 11.7.0 · wc · Http · ProxyDirectTls · property · read/write · since 9.5.0.83`

```c
BOOL CkHttpW_getProxyDirectTls(HCkHttpW cHandle);
void CkHttpW_putProxyDirectTls(HCkHttpW cHandle, BOOL newVal);
```

Set to `TRUE` if the proxy server expects a direct TLS connection. (This is where the initial connection to the HTTP proxy server is TLS. See [Squid Direct TLS Connection](https://wiki.squid-cache.org/Features/HTTPS). The default value of this property is `FALSE`.

### Http.ProxyDomain

`Chilkat 11.7.0 · wc · Http · ProxyDomain · property · read/write`

```c
void CkHttpW_getProxyDomain(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putProxyDomain(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_proxyDomain(HCkHttpW cHandle);
```

The domain name of a proxy host if an HTTP proxy is used. This can also be set to an IP address.

### Http.ProxyLogin

`Chilkat 11.7.0 · wc · Http · ProxyLogin · property · read/write`

```c
void CkHttpW_getProxyLogin(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putProxyLogin(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_proxyLogin(HCkHttpW cHandle);
```

If an HTTP proxy is used and it requires authentication, this property specifies the HTTP proxy login.

### Http.ProxyLoginDomain

`Chilkat 11.7.0 · wc · Http · ProxyLoginDomain · property · read/write`

```c
void CkHttpW_getProxyLoginDomain(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putProxyLoginDomain(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_proxyLoginDomain(HCkHttpW cHandle);
```

The NTLM authentication domain (optional) if NTLM authentication is used.

### Http.ProxyPassword

`Chilkat 11.7.0 · wc · Http · ProxyPassword · property · read/write`

```c
void CkHttpW_getProxyPassword(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putProxyPassword(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_proxyPassword(HCkHttpW cHandle);
```

If an HTTP proxy is used and it requires authentication, this property specifies the HTTP proxy password.

### Http.ProxyPort

`Chilkat 11.7.0 · wc · Http · ProxyPort · property · read/write`

```c
int CkHttpW_getProxyPort(HCkHttpW cHandle);
void CkHttpW_putProxyPort(HCkHttpW cHandle, int newVal);
```

The port number of a proxy server if an HTTP proxy is used.

### Http.ReadTimeout

`Chilkat 11.7.0 · wc · Http · ReadTimeout · property · read/write`

```c
int CkHttpW_getReadTimeout(HCkHttpW cHandle);
void CkHttpW_putReadTimeout(HCkHttpW cHandle, int newVal);
```

The amount of time in seconds to wait before timing out when reading from an HTTP server. The ReadTimeout is the amount of time that needs to elapse while no additional data is forthcoming. During a long download, if the data stream halts for more than this amount, it will timeout. Otherwise, there is no limit on the length of time for the entire download.

The default value is 60 seconds. Note: Prior to v9.5.0.76, the default was 20 seconds.

### Http.ReceivedCertReq

`Chilkat 11.7.0 · wc · Http · ReceivedCertReq · property · read-only · since 9.5.0.92`

```c
BOOL CkHttpW_getReceivedCertReq(HCkHttpW cHandle);
```

Indicates whether the last HTTPS connection received a TLS CertificateRequest handshake message indicating that the server may require a client certificate.

### Http.RedirectVerb

`Chilkat 11.7.0 · wc · Http · RedirectVerb · property · read/write`

```c
void CkHttpW_getRedirectVerb(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putRedirectVerb(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_redirectVerb(HCkHttpW cHandle);
```

Indicates the HTTP verb, such as GET, POST, PUT, etc. to be used for a redirect when the FollowRedirects property is set to `TRUE`. The default value of this property is `GET`. This will produce the same behavior as a web browser (such as FireFox). If this property is set to the empty string, then it will cause the same verb as the original HTTP request to be used.

**Note:** Prior to version 9.5.0.44, the default value of this property was the empty string.

### Http.RequiredContentType

`Chilkat 11.7.0 · wc · Http · RequiredContentType · property · read/write`

```c
void CkHttpW_getRequiredContentType(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putRequiredContentType(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_requiredContentType(HCkHttpW cHandle);
```

If set, then any HTTP response to any POST or GET, including downloads, will be rejected if the content-type in the response header does not match this setting. If the content-type does not match, only the header of the HTTP response is read, the connection to the HTTP server is closed, and the remainder of the response is never read.

This property is empty (zero-length string) by default.

Some typical content-types are `text/html`, `text/xml`, `image/gif`, `image/jpeg`, `application/zip`, `application/msword`, `application/pdf`, etc.

### Http.RequireHostnameMatch

`Chilkat 11.7.0 · wc · Http · RequireHostnameMatch · property · read/write · since 11.0.0`

```c
BOOL CkHttpW_getRequireHostnameMatch(HCkHttpW cHandle);
void CkHttpW_putRequireHostnameMatch(HCkHttpW cHandle, BOOL newVal);
```

**Full documentation for this property (same in every language):** [Explaining the SNI Hostname in TLS](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/tls_sni_hostname.md)

If `TRUE`, then the hostname/domain in the URL must match at least one of the entries in the server certificate's SAN. A SAN (Subject Alternative Name) field in an SSL/TLS certificate contains a list of additional domain names, subdomains, IP addresses, or other identifiers that the certificate is valid for.

In actuality, it is the SNI hostname in the TLS handshake that must match a SAN entry. By default, Chilkat uses the hostname from the URL as the SNI hostname. An application can explicitly set the SNI hostname via the `SniHostname` property, which would be typical if connecting via an IP address. See the example below.

Starting in v11.7.0, a wildcard SAN entry is matched as RFC 9525 (formerly RFC 6125) specifies. The wildcard must be the entire left-most label (`*.example.com`) and stands for exactly one label: `*.example.com` matches `www.example.com`, but not `a.b.example.com` and not the bare `example.com`. (Earlier versions matched the bare domain, and accepted a wildcard in any position.) A wildcard is not accepted directly under a top-level domain or a country-code second level such as `co.uk`, and never matches an IP address.

The default value is `FALSE`.

### Http.RequireSslCertVerify

`Chilkat 11.7.0 · wc · Http · RequireSslCertVerify · property · read/write`

```c
BOOL CkHttpW_getRequireSslCertVerify(HCkHttpW cHandle);
void CkHttpW_putRequireSslCertVerify(HCkHttpW cHandle, BOOL newVal);
```

If `TRUE`, then the HTTP client will verify the server's SSL certificate. The certificate is expired, or if the cert's signature is invalid, the connection is not allowed. The default value of this property is `FALSE`.

### Http.SaveCookies

`Chilkat 11.7.0 · wc · Http · SaveCookies · property · read/write`

```c
BOOL CkHttpW_getSaveCookies(HCkHttpW cHandle);
void CkHttpW_putSaveCookies(HCkHttpW cHandle, BOOL newVal);
```

If this property is `TRUE`, cookies are automatically persisted to XML files in the directory specified by the CookiesDir property (or in memory if CookieDir = `memory`). Both CookiesDir and SaveCookies must be set for cookies to be persisted.

### Http.SendBufferSize

`Chilkat 11.7.0 · wc · Http · SendBufferSize · property · read/write`

```c
int CkHttpW_getSendBufferSize(HCkHttpW cHandle);
void CkHttpW_putSendBufferSize(HCkHttpW cHandle, int newVal);
```

The buffer size to be used with the underlying TCP/IP socket for sending. The default value is 65535.

### Http.SendCookies

`Chilkat 11.7.0 · wc · Http · SendCookies · property · read/write`

```c
BOOL CkHttpW_getSendCookies(HCkHttpW cHandle);
void CkHttpW_putSendCookies(HCkHttpW cHandle, BOOL newVal);
```

If `TRUE`, then cookies previously persisted to the CookiesDir are automatically added to all HTTP requests. Only cookies matching the domain and path are added.

### Http.SessionLogFilename

`Chilkat 11.7.0 · wc · Http · SessionLogFilename · property · read/write`

```c
void CkHttpW_getSessionLogFilename(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putSessionLogFilename(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_sessionLogFilename(HCkHttpW cHandle);
```

Enables file-based session logging. If set to a filename (or relative/absolute filepath), then the exact HTTP requests and responses are logged to a file. The file is created if it does not already exist, otherwise it is appended.

### Http.SniHostname

`Chilkat 11.7.0 · wc · Http · SniHostname · property · read/write · since 9.5.0.82`

```c
void CkHttpW_getSniHostname(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putSniHostname(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_sniHostname(HCkHttpW cHandle);
```

**Full documentation for this property (same in every language):** [Explaining the SNI Hostname in TLS](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/tls_sni_hostname.md)

Sets the SNI hostname for the TLS ClientHello. This property is usually necessary only when the domain is specified by an IP address and an SNI hostname is required. By default Chilkat uses the hostname in the URL for the SNI hostname in the TLS ClientHello extension automatically.

### Http.SocksHostname

`Chilkat 11.7.0 · wc · Http · SocksHostname · property · read/write`

```c
void CkHttpW_getSocksHostname(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putSocksHostname(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_socksHostname(HCkHttpW cHandle);
```

The SOCKS4/SOCKS5 hostname or IPv4 address (in dotted decimal notation). This property is only used if the SocksVersion property is set to 4 or 5).

### Http.SocksPassword

`Chilkat 11.7.0 · wc · Http · SocksPassword · property · read/write`

```c
void CkHttpW_getSocksPassword(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putSocksPassword(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_socksPassword(HCkHttpW cHandle);
```

The SOCKS5 password (if required). The SOCKS4 protocol does not include the use of a password, so this does not apply to SOCKS4.

### Http.SocksPort

`Chilkat 11.7.0 · wc · Http · SocksPort · property · read/write`

```c
int CkHttpW_getSocksPort(HCkHttpW cHandle);
void CkHttpW_putSocksPort(HCkHttpW cHandle, int newVal);
```

The SOCKS4/SOCKS5 proxy port. The default value is 1080. This property only applies if a SOCKS proxy is used (if the SocksVersion property is set to 4 or 5).

### Http.SocksUsername

`Chilkat 11.7.0 · wc · Http · SocksUsername · property · read/write`

```c
void CkHttpW_getSocksUsername(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putSocksUsername(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_socksUsername(HCkHttpW cHandle);
```

The SOCKS4/SOCKS5 proxy username. This property is only used if the SocksVersion property is set to 4 or 5).

### Http.SocksVersion

`Chilkat 11.7.0 · wc · Http · SocksVersion · property · read/write`

```c
int CkHttpW_getSocksVersion(HCkHttpW cHandle);
void CkHttpW_putSocksVersion(HCkHttpW cHandle, int newVal);
```

SocksVersion May be set to one of the following integer values:

**0** - No SOCKS proxy is used. This is the default.  
**4** - Connect via a SOCKS4 proxy.  
**5** - Connect via a SOCKS5 proxy.

### Http.SoRcvBuf

`Chilkat 11.7.0 · wc · Http · SoRcvBuf · property · read/write`

```c
int CkHttpW_getSoRcvBuf(HCkHttpW cHandle);
void CkHttpW_putSoRcvBuf(HCkHttpW cHandle, int newVal);
```

Sets the receive buffer size socket option. Normally, this property should be left unchanged. The default value is 4194304.

This property can be increased if download performance seems slow. It is recommended to be a multiple of 4096.

See also:

- [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446)

### Http.SoSndBuf

`Chilkat 11.7.0 · wc · Http · SoSndBuf · property · read/write`

```c
int CkHttpW_getSoSndBuf(HCkHttpW cHandle);
void CkHttpW_putSoSndBuf(HCkHttpW cHandle, int newVal);
```

Sets the send buffer size socket option. Normally, this property should be left unchanged. The default value is 262144.

This property can be increased if upload performance seems slow. It is recommended to be a multiple of 4096. Testing with sizes such as 512K and 1MB is reasonable.

See also:

- [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446)

### Http.SslAllowedCiphers

`Chilkat 11.7.0 · wc · Http · SslAllowedCiphers · property · read/write · since 9.5.0.48`

```c
void CkHttpW_getSslAllowedCiphers(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putSslAllowedCiphers(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_sslAllowedCiphers(HCkHttpW cHandle);
```

Provides a means for setting a list of ciphers that are allowed for SSL/TLS connections. The default (empty string) indicates that all implemented ciphers are possible. The TLS ciphers supported in Chilkat v9.5.0.55 and later are:

```
TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
TLS_DHE_RSA_WITH_AES_256_CBC_SHA
TLS_RSA_WITH_AES_256_CBC_SHA256
TLS_RSA_WITH_AES_256_GCM_SHA384
TLS_RSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
TLS_DHE_RSA_WITH_AES_128_CBC_SHA
TLS_RSA_WITH_AES_128_CBC_SHA256
TLS_RSA_WITH_AES_128_GCM_SHA256
TLS_RSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA
TLS_RSA_WITH_3DES_EDE_CBC_SHA
TLS_ECDHE_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_RC4_128_MD5
TLS_DHE_RSA_WITH_DES_CBC_SHA
TLS_RSA_WITH_DES_CBC_SHA
```

To restrict SSL/TLS connections to one or more specific ciphers, set this property to a comma-separated list of ciphers such as `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`. The order should be in terms of preference, with the preferred algorithms listed first. (Note that the client cannot specifically choose the algorithm is picked because it is the server that chooses. The client simply provides the server with a list from which to choose.)

The property can also disallow connections with servers having certificates with RSA keys less than a certain size. By default, server certificates having RSA keys of 512 bits or greater are allowed. Add the keyword `rsa1024` to disallow connections with servers having keys smaller than 1024 bits. Add the keyword `rsa2048` to disallow connections with servers having keys smaller than 2048 bits.

**Note:** Prior to Chilkat v9.5.0.55, it was not possible to explicitly list allowed cipher suites. The deprecated means for indicating allowed ciphers was both incomplete and unprecise. For example, the following keywords could be listed to allow matching ciphers: `aes256-cbc`, `aes128-cbc`, `3des-cbc`, and `rc4`. These keywords will still be recognized, but programs should be updated to explicitly list the allowed ciphers.

**secure-renegotiation:** Starting in Chilkat v9.5.0.55, the keyword `secure-renegotiation` may be added to require that all renegotions be done securely (as per RFC 5746).

**best-practices:** Starting in Chilkat v9.5.0.55, this property may be set to the single keyword `best-practices`. This will allow ciphers based on the current best practices. As new versions of Chilkat are released, the best practices may change. Changes will be noted here. The current best practices are:

- If the server uses an RSA key, it must be 1024 bits or greater.
- All renegotations must be secure renegotiations.
- All ciphers using RC4, DES, or 3DES are disallowed.

**Example:** The following string would restrict to 2 specific cipher suites, require RSA keys to be 1024 bits or greater, and require secure renegotiations: `TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024, secure-renegotiation`

### Http.SslProtocol

`Chilkat 11.7.0 · wc · Http · SslProtocol · property · read/write · since 9.5.0.46`

```c
void CkHttpW_getSslProtocol(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putSslProtocol(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_sslProtocol(HCkHttpW cHandle);
```

Selects the SSL/TLS protocol version to be used for connections. Possible values are:

> default  
> TLS 1.3  
> TLS 1.2  
> TLS 1.1  
> TLS 1.0  
> SSL 3.0  
> TLS 1.3 or higher  
> TLS 1.2 or higher  
> TLS 1.1 or higher  
> TLS 1.0 or higher

The default value is `default` which allows for the protocol to be selected dynamically at runtime based on the requirements of the server. Choosing an exact protocol will cause the connection to fail unless that exact protocol is negotiated. It is better to choose `X or higher` than an exact protocol. The `default` is effectively `SSL 3.0 or higher`.

### Http.StreamResponseBodyPath

`Chilkat 11.7.0 · wc · Http · StreamResponseBodyPath · property · read/write · since 9.5.0.49`

```c
void CkHttpW_getStreamResponseBodyPath(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putStreamResponseBodyPath(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_streamResponseBodyPath(HCkHttpW cHandle);
```

Allows for the HTTP response body to be streamed directly into a file. If this property is set, then any method returning an HTTP response object will stream the response body directly to the file path specified. The HTTP response object will still contain the response header. (This property is useful when the HTTP response is too large to fit into memory.)

### Http.TlsCipherSuite

`Chilkat 11.7.0 · wc · Http · TlsCipherSuite · property · read-only · since 9.5.0.49`

```c
void CkHttpW_getTlsCipherSuite(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_tlsCipherSuite(HCkHttpW cHandle);
```

Contains the current or last negotiated TLS cipher suite. If no TLS connection has yet to be established, or if a connection as attempted and failed, then this will be empty. A sample cipher suite string looks like this: TLS_DHE_RSA_WITH_AES_256_CBC_SHA256.

### Http.TlsPinSet

`Chilkat 11.7.0 · wc · Http · TlsPinSet · property · read/write · since 9.5.0.55`

```c
void CkHttpW_getTlsPinSet(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putTlsPinSet(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_tlsPinSet(HCkHttpW cHandle);
```

**Full documentation for this property (same in every language):** [Encodings Supported by Chilkat](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Specifies a set of pins for Public Key Pinning for TLS connections. This property lists the expected SPKI fingerprints for the server certificates. If the server's certificate (sent during the TLS handshake) does not match any of the SPKI fingerprints, then the TLS handshake is aborted and the connection fails. The format of this string property is as follows:

```
hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ...
```

For example, the following string specifies a single sha256 base64-encoded SPKI fingerprint:

```
"sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE="
```

This example specifies two SPKI fingerprints:

```
"sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=, 68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs="
```

Any of the following hash algorithms are allowed:.sha1, sha256, sha384, sha512, md2, md5, haval, ripemd128, ripemd160,ripemd256, or ripemd320.

The following encodings are allowed: base64, hex, and any of the encodings indicated in the link below.

### Http.TlsVersion

`Chilkat 11.7.0 · wc · Http · TlsVersion · property · read-only · since 9.5.0.49`

```c
void CkHttpW_getTlsVersion(HCkHttpW cHandle, HCkString retval);
const wchar_t *CkHttpW_tlsVersion(HCkHttpW cHandle);
```

Contains the current or last negotiated TLS protocol version. If no TLS connection has yet to be established, or if a connection as attempted and failed, then this will be empty. Possible values are `SSL 3.0`, `TLS 1.0`, `TLS 1.1`, `TLS 1.2`, and `TLS 1.3`.

### Http.UncommonOptions

`Chilkat 11.7.0 · wc · Http · UncommonOptions · property · read/write`

```c
void CkHttpW_getUncommonOptions(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putUncommonOptions(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_uncommonOptions(HCkHttpW cHandle);
```

This is a catch-all property to be used for uncommon needs. This property defaults to the empty string and should typically remain empty. Can be set to a list of the following comma separated keywords:

- `QuickDisconnect` - Introduced in v9.5.0.77. In the call to CloseAllConnections, do not disconnect cleanly. Instead just disconnect as quickly as possible.
- `ProtectFromVpn` - Introduced in v9.5.0.80. On Android systems, will bypass any VPN that may be installed or active.
- `TlsNoClientRootCert` - Introduced in v9.5.0.82. Will exclude root CA certs from being included in the client certificate chain that is sent to the server for client-side authentication. This must be set prior to calling SetSslClientCert.
- `AllowEmptyHeaders` - Introduced in v9.5.0.82. If present, an empty value string passed to SetHeaderField will cause the header to be added with an empty value. Otherwise, for historical purposes and backward compatibility, the header field is removed when an empty value string is passed.
- `AnsiLogin` - Introduced in v9.5.0.87. For HTTP basic authentication, the login and password is sent using the utf-8 byte representation. Some servers expect the ANSI byte representation (typically Windows-1252). Use this keyword to send the login/password using ANSI.

### Http.UpdateCache

`Chilkat 11.7.0 · wc · Http · UpdateCache · property · read/write`

```c
BOOL CkHttpW_getUpdateCache(HCkHttpW cHandle);
void CkHttpW_putUpdateCache(HCkHttpW cHandle, BOOL newVal);
```

Set this property to `TRUE` to automatically updated with HTTP GET request responses. **Only HTTP GET requests are cached.** HTTP responses containing `Set-Cookie` headers are never cached. **The default value is `FALSE`**.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.UseIEProxy

`Chilkat 11.7.0 · wc · Http · UseIEProxy · property · read/write`

```c
BOOL CkHttpW_getUseIEProxy(HCkHttpW cHandle);
void CkHttpW_putUseIEProxy(HCkHttpW cHandle, BOOL newVal);
```

If `TRUE`, the proxy address/port used by Internet Explorer will also be used by Chilkat HTTP. Note: This property only pays attention to the proxy address and port, and does not pay attention to additional information such as IE proxy server exceptions.

### Http.UserAgent

`Chilkat 11.7.0 · wc · Http · UserAgent · property · read/write`

```c
void CkHttpW_getUserAgent(HCkHttpW cHandle, HCkString retval);
void CkHttpW_putUserAgent(HCkHttpW cHandle, const wchar_t *newVal);
const wchar_t *CkHttpW_userAgent(HCkHttpW cHandle);
```

This property sets the `User-Agent` header for all HTTP requests, except those sent by the `HttpReq` and `HttpSReq` methods that use headers from an `HttpRequest` object.

By default, it is set to an empty string, meaning no `User-Agent` header is included.

Setting this property is the same as calling `SetRequestHeader` with `User-Agent` as the header field name.

The **`User-Agent` HTTP header** is sent by the client to identify **the software making the request** (browser, app, library, bot, etc.).

Example:

```
MyApp/1.1
```

Note: Some web servers reject requests that do not include a `User-Agent`.

### Http.WasRedirected

`Chilkat 11.7.0 · wc · Http · WasRedirected · property · read-only`

```c
BOOL CkHttpW_getWasRedirected(HCkHttpW cHandle);
```

This shows whether the last HTTP request automatically followed a redirect. For more information on redirection, see the `FollowRedirects` and `FinalRedirectUrl` properties.

## Methods

### Http.AddCacheRoot

`Chilkat 11.7.0 · wc · Http · AddCacheRoot · method`

```c
void CkHttpW_AddCacheRoot(HCkHttpW cHandle, const wchar_t *dir);
```

Disk caching operates similarly to browser caching of web pages, but it focuses on downloading **web pages** rather than handling HTTP requests to a REST API.

To activate disk caching, invoke the method at least once. Use the `AddCacheRoot` method and provide a file path (e.g., `D:\MyHttpCache\`) to set the root directory. To distribute the cache over multiple directories, call `AddCacheRoot` multiple times with different directory paths.

**HTTP GET web page caching** properties and methods include: `NumCacheRoots`, `NumCacheLevels`, `AddCacheRoot`, `FetchFromCache`, `UpdateCache`, `MinFreshPeriod`, `MaxFreshPeriod`, `FreshnessAlgorithm`, `DefaultFreshPeriod`, `LMFactor`, `IgnoreMustRevalidate`, `IgnoreNoCache`, and `LastFromCache`.

### Http.ClearHeaders

`Chilkat 11.7.0 · wc · Http · ClearHeaders · method · since 9.5.0.77`

```c
void CkHttpW_ClearHeaders(HCkHttpW cHandle);
```

Removes all headers set by the `SetRequestHeader` method.

### Http.ClearInMemoryCookies

`Chilkat 11.7.0 · wc · Http · ClearInMemoryCookies · method · since 11.1.0`

```c
void CkHttpW_ClearInMemoryCookies(HCkHttpW cHandle);
```

Clears all in-memory cookies accumulated while the `SaveCookies` property was set to `TRUE` and the `CookieDir` was set to `memory`.

### Http.ClearUrlVars

`Chilkat 11.7.0 · wc · Http · ClearUrlVars · method · since 9.5.0.67`

```c
void CkHttpW_ClearUrlVars(HCkHttpW cHandle);
```

Removes all URL variable values previously set by `SetUrlVar` .

### Http.CloseAllConnections

`Chilkat 11.7.0 · wc · Http · CloseAllConnections · method`

```c
BOOL CkHttpW_CloseAllConnections(HCkHttpW cHandle);
```

Closes all remaining open HTTP connections.

An HTTP object can hold up to 10 connections. If a server response lacks a `Connection: Close` header, the connection stays open and may be reused for subsequent requests to the same host. Connections are identified by their IP address or domain name as specified in the URL. Once the limit of 10 connections is reached, the least recently used connection will be closed to open a new one.

Also see: `MaxConnections` .

Returns TRUE for success, FALSE for failure.

Async variant: `CloseAllConnectionsAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.CreateOcspRequest

`Chilkat 11.7.0 · wc · Http · CreateOcspRequest · method · since 9.5.0.75`

```c
BOOL CkHttpW_CreateOcspRequest(HCkHttpW cHandle, HCkJsonObjectW requestDetails, HCkBinDataW ocspRequest);
```

Generates an OCSP request for one or more certificates using JSON (`requestDetails`) that specifies the request details. **Refer to the examples in the provided links** for guidance on constructing the JSON. **Note:** After creating the OCSP request, send it to the server using `HttpBd` with a `POST` request and a Content-Type of `application/ocsp-request`. Use `ParseOcspReply` to analyze the OCSP response.

Returns TRUE for success, FALSE for failure.

### Http.CreateTimestampRequest

`Chilkat 11.7.0 · wc · Http · CreateTimestampRequest · method · since 9.5.0.75`

```c
BOOL CkHttpW_CreateTimestampRequest(HCkHttpW cHandle, const wchar_t *hashAlg, const wchar_t *hashVal, const wchar_t *reqPolicyOid, BOOL addNonce, BOOL reqTsaCert, HCkBinDataW timestampToken);
```

Creates an RFC 3161 time-stamp request and returns the binary request token in `timestampToken`. The `hashAlg` can be `sha1`, `sha256`, `sha384`, `sha512`, or `md5`, The `hashVal` is the base64 hash of the data to be timestamped. The optional `reqPolicyOid` is the requested policy OID in a format such as `1.3.6.1.4.1.47272.1.2`. The `addNonce` indicates whether to auto-generate and include a nonce in the request. It may be `TRUE` or `FALSE`. The `reqTsaCert` determines whether or not to request the TSA's certificate (`TRUE` = Yes, `FALSE` = No).

**Note:** After creating the timestamp request, send it to the server using `HttpBd` with a `POST` request and a Content-Type of `application/timestamp-query`. Use `VerifyTimestampReply` to analyze and verify the timestamp reply. See the examples linked below.

Returns TRUE for success, FALSE for failure.

### Http.DnsCacheClear

`Chilkat 11.7.0 · wc · Http · DnsCacheClear · method · since 9.5.0.38`

```c
void CkHttpW_DnsCacheClear(HCkHttpW cHandle);
```

This function clears the Chilkat in-memory DNS cache, which stores hostname-to-IP address mappings to avoid repeated DNS lookups.

**Note:**

- The DNS cache is shared across all Chilkat objects, so clearing it will impact all such objects.
- Chilkat's DNS caching respects the TTL (time to live) of DNS records. If the TTL has expired since the initial lookup, Chilkat will perform a new DNS query and update the cache with the latest IP address.

### Http.Download

`Chilkat 11.7.0 · wc · Http · Download · method`

```c
BOOL CkHttpW_Download(HCkHttpW cHandle, const wchar_t *url, const wchar_t *localFilePath);
```

**Full documentation for this method (same in every language):** [HTTP Downloads Explained](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/http_download.md)

Downloads the content at the specified `url` and saves to a local file at `localFilePath`.

The download succeeds if the HTTP response status code is in the 200s. If unsuccessful, no output file is created. If the `KeepResponseBody` property is set to `TRUE`, the server's error response will be available in the `LastResponseBody` property.

The response status code will be available in the `LastStatus` property.

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.DownloadAppend

`Chilkat 11.7.0 · wc · Http · DownloadAppend · method`

```c
BOOL CkHttpW_DownloadAppend(HCkHttpW cHandle, const wchar_t *url, const wchar_t *appendToPath);
```

**Full documentation for this method (same in every language):** [HTTP Downloads Explained](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/http_download.md)

Downloads the content at the specified `url` and appends to the local file at `appendToPath`. The file is created if it does not yet exist.

The download succeeds if the HTTP status code is in the 200s. If unsuccessful, no output file is created. If the `KeepResponseBody` property is set to `TRUE`, the server's error response will be available in the `LastResponseBody` property.

The response status code will be available in the `LastStatus` property.

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadAppendAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.DownloadBd

`Chilkat 11.7.0 · wc · Http · DownloadBd · method · since 9.5.0.63`

```c
BOOL CkHttpW_DownloadBd(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);
```

**Full documentation for this method (same in every language):** [HTTP Downloads Explained](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/http_download.md)

Downloads content from `url` to `binData`, clearing `binData` beforehand. `binData` will only contain the downloaded bytes if the operation is successful.

The download succeeds if the HTTP status code is in the 200s. If unsuccessful, nothing is written to `binData`. If the `KeepResponseBody` property is set to `TRUE`, the server's error response will be available in the `LastResponseBody` property.

The response status code will be available in the `LastStatus` property.

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.DownloadHash

`Chilkat 11.7.0 · wc · Http · DownloadHash · method`

```c
BOOL CkHttpW_DownloadHash(HCkHttpW cHandle, const wchar_t *url, const wchar_t *hashAlgorithm, const wchar_t *encoding, const wchar_t *outStr);
const wchar_t *CkHttpW_downloadHash(HCkHttpW cHandle, const wchar_t *url, const wchar_t *hashAlgorithm, const wchar_t *encoding);
```

**Full documentation for this method (same in every language):** [HTTP Downloads Explained](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/http_download.md)

Fetches the content at `url` and returns the encoded hash using the specified algorithm (`hashAlgorithm`: `sha1`, `sha256`, `sha384`, `sha512`, `md2`, `md5`, `haval`, `ripemd128`, `ripemd160`, `ripemd256`, or `ripemd320`), and returns the hash encoded in the specified encoding (`encoding`: `Base64`, `modBase64`, `Base32`, `UU`, `QP` for quoted-printable, `URL` for URL-encoding, `Hex`, `Q`, `B`, `url_oath`, `url_rfc1738`, `url_rfc2396`, or `url_rfc3986`).

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadHashAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.DownloadSb

`Chilkat 11.7.0 · wc · Http · DownloadSb · method · since 9.5.0.63`

```c
BOOL CkHttpW_DownloadSb(HCkHttpW cHandle, const wchar_t *url, const wchar_t *charset, HCkStringBuilderW sb);
```

**Full documentation for this method (same in every language):** [HTTP Downloads Explained](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/http_download.md)

Downloads the content at the `url` into a Chilkat StringBuilder object. The `charset` tells Chilkat how to interpret the bytes received. The `sb` is appended with the downloaded text data.

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadSbAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.ExtractMetaRefreshUrl

`Chilkat 11.7.0 · wc · Http · ExtractMetaRefreshUrl · method`

```c
BOOL CkHttpW_ExtractMetaRefreshUrl(HCkHttpW cHandle, const wchar_t *htmlContent, const wchar_t *outStr);
const wchar_t *CkHttpW_extractMetaRefreshUrl(HCkHttpW cHandle, const wchar_t *htmlContent);
```

This is a convenience method for extracting the META refresh URL from HTML. For example, if the `htmlContent` contains a META refresh tag, such as:

```
<meta http-equiv="refresh" content="5;URL='https://example.com/'">
```

Then the return value of this method would be `https://example.com/`.

Returns TRUE for success, FALSE for failure.

### Http.G_SvcOauthAccessToken

`Chilkat 11.7.0 · wc · Http · G_SvcOauthAccessToken · method · since 9.5.0.44`

```c
BOOL CkHttpW_G_SvcOauthAccessToken(HCkHttpW cHandle, const wchar_t *iss, const wchar_t *scope, const wchar_t *subEmail, int numSec, HCkCertW cert, const wchar_t *outStr);
const wchar_t *CkHttpW_g_SvcOauthAccessToken(HCkHttpW cHandle, const wchar_t *iss, const wchar_t *scope, const wchar_t *subEmail, int numSec, HCkCertW cert);
```

**Full documentation for this method (same in every language):** [Configuring your Service Account and Project within your Google Workspace Account.](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/google_workspace_setup_smtp_gmail.md)

Obtains a Google API OAuth2 access token for a service account. The `iss` is your service account email address ending in `gserviceaccount.com`. The `scope` should be set to `https://mail.google.com/` for GMail. The `subEmail` is your company email address, e.g. `bob@yourcompany.com`. `numSec` is the number of seconds the access token will remain valid.

Returns TRUE for success, FALSE for failure.

Async variant: `G_SvcOauthAccessTokenAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.G_SvcOauthAccessToken2

`Chilkat 11.7.0 · wc · Http · G_SvcOauthAccessToken2 · method · since 9.5.0.51`

```c
BOOL CkHttpW_G_SvcOauthAccessToken2(HCkHttpW cHandle, HCkHashtableW claimParams, int numSec, HCkCertW cert, const wchar_t *outStr);
const wchar_t *CkHttpW_g_SvcOauthAccessToken2(HCkHttpW cHandle, HCkHashtableW claimParams, int numSec, HCkCertW cert);
```

This method is similar to `G_SvcOauthAccessToken`, but offers greater customization. The first three arguments of G_SvcOauthAccessToken are replaced with `claimParams` to allow for future expansion with name-value parameters. See the example below.

Returns TRUE for success, FALSE for failure.

Async variant: `G_SvcOauthAccessToken2Async` — same arguments, returns a `Task` (see Async variants below).

### Http.GenTimeStamp

`Chilkat 11.7.0 · wc · Http · GenTimeStamp · method`

```c
BOOL CkHttpW_GenTimeStamp(HCkHttpW cHandle, const wchar_t *outStr);
const wchar_t *CkHttpW_genTimeStamp(HCkHttpW cHandle);
```

Returns the current date and time in GMT (UTC) as a string formatted according to RFC 2616: `Day, DD Mon YYYY HH:MM:SS GMT`. For example, `Thu, 21 Aug 2025 11:17:31 GMT`.

Returns TRUE for success, FALSE for failure.

### Http.GetCacheRoot

`Chilkat 11.7.0 · wc · Http · GetCacheRoot · method`

```c
BOOL CkHttpW_GetCacheRoot(HCkHttpW cHandle, int index, const wchar_t *outStr);
const wchar_t *CkHttpW_getCacheRoot(HCkHttpW cHandle, int index);
```

Returns the Nth cache root, with indexing starting at 0. Cache roots are established by calling `AddCacheRoot` one or more times. The number of established cache roots is in the `NumCacheRoots` property.

Returns TRUE for success, FALSE for failure.

### Http.GetCookieXml

`Chilkat 11.7.0 · wc · Http · GetCookieXml · method`

```c
BOOL CkHttpW_GetCookieXml(HCkHttpW cHandle, const wchar_t *domain, const wchar_t *outStr);
const wchar_t *CkHttpW_getCookieXml(HCkHttpW cHandle, const wchar_t *domain);
```

Returns cookies in XML format for a specified domain. Cookies are saved only if the `SaveCookies` property is set to `TRUE`. If the `CookieDir` property is set to `memory,` cookies are stored in-memory.

Returns TRUE for success, FALSE for failure.

### Http.GetDomain

`Chilkat 11.7.0 · wc · Http · GetDomain · method`

```c
BOOL CkHttpW_GetDomain(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr);
const wchar_t *CkHttpW_getDomain(HCkHttpW cHandle, const wchar_t *url);
```

Utility method to extract the domain name from a URL. For instance, passing in `https://chilkatsoft.com/refdoc/csharp.asp` will return `chilkatsoft.com`.

Returns TRUE for success, FALSE for failure.

### Http.GetLastJsonData

`Chilkat 11.7.0 · wc · Http · GetLastJsonData · method · since 11.0.0`

```c
void CkHttpW_GetLastJsonData(HCkHttpW cHandle, HCkJsonObjectW json);
```

Offers details about the most recent method called on this object instance, although some methods may not supply any information.

### Http.GetRequestHeader

`Chilkat 11.7.0 · wc · Http · GetRequestHeader · method`

```c
BOOL CkHttpW_GetRequestHeader(HCkHttpW cHandle, const wchar_t *name, const wchar_t *outStr);
const wchar_t *CkHttpW_getRequestHeader(HCkHttpW cHandle, const wchar_t *name);
```

Returns the value of a header field previously set by calling `SetRequestHeader`.

Returns TRUE for success, FALSE for failure.

### Http.GetServerCert

`Chilkat 11.7.0 · wc · Http · GetServerCert · method · since 11.0.0`

```c
BOOL CkHttpW_GetServerCert(HCkHttpW cHandle, const wchar_t *domain, int port, HCkCertW cert);
```

Establishes an SSL/TLS connection with a web server to acquire its SSL certificate without retrieving any data, then disconnects.

Returns TRUE for success, FALSE for failure.

Async variant: `GetServerCertAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.GetUrlPath

`Chilkat 11.7.0 · wc · Http · GetUrlPath · method`

```c
BOOL CkHttpW_GetUrlPath(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr);
const wchar_t *CkHttpW_getUrlPath(HCkHttpW cHandle, const wchar_t *url);
```

Returns the path part of a URL. For example, the path part of `https://example.com/folder/page?lang=en&sort=asc#section2` is `/folder/page`.

Returns TRUE for success, FALSE for failure.

### Http.HasRequestHeader

`Chilkat 11.7.0 · wc · Http · HasRequestHeader · method`

```c
BOOL CkHttpW_HasRequestHeader(HCkHttpW cHandle, const wchar_t *name);
```

Returns `TRUE` if the header field specified by `name` is included in all HTTP requests, except those sent by the `HttpReq` or `HttpSReq` methods.

### Http.HttpBd

`Chilkat 11.7.0 · wc · Http · HttpBd · method · since 11.0.0`

```c
BOOL CkHttpW_HttpBd(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkBinDataW bd, const wchar_t *contentType, HCkHttpResponseW response);
```

Sends an HTTP request to `url` using the specified HTTP `verb` (e.g., `POST`, `PUT`, `PATCH`). The body of the request is defined by `bd`, and the Content-Type header is set by `contentType`, with possible values like `application/octet-stream`, `application/pdf`, `image/jpeg`, or `application/zip`. The HTTP response is returned in `response`.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.HttpFile

`Chilkat 11.7.0 · wc · Http · HttpFile · method · since 11.0.0`

```c
BOOL CkHttpW_HttpFile(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, const wchar_t *localFilePath, const wchar_t *contentType, HCkHttpResponseW response);
```

Sends an HTTP request to `url` using the specified HTTP `verb` (e.g., `POST`, `PUT`, `PATCH`). The body of the request is streamed directly from `localFilePath`, and the Content-Type header is set by `contentType`, with possible values like `application/octet-stream`, `application/pdf`, `image/jpeg`, or `application/zip`. The HTTP response is returned in `response`.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpFileAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.HttpJson

`Chilkat 11.7.0 · wc · Http · HttpJson · method · since 11.0.0`

```c
BOOL CkHttpW_HttpJson(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkJsonObjectW json, const wchar_t *contentType, HCkHttpResponseW response);
```

Sends an HTTP request to `url` using the specified method in `verb` (e.g., POST, PUT, PATCH). The request body contains the JSON from `json`, with the content type set by `contentType`, such as `application/json` or `application/jsonrequest.` The HTTP response is returned in `response`.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpJsonAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.HttpNoBody

`Chilkat 11.7.0 · wc · Http · HttpNoBody · method · since 11.0.0`

```c
BOOL CkHttpW_HttpNoBody(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkHttpResponseW response);
```

Sends an HTTP request to `url` using the specified HTTP `verb`. The request body is empty. Verbs like `GET`, `HEAD`, and `DELETE` usually do not include a body. No `Content-Type` header is included because there is no content in the body of the request. The HTTP response is returned in `response`.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpNoBodyAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.HttpParams

`Chilkat 11.7.0 · wc · Http · HttpParams · method · since 11.0.0`

```c
BOOL CkHttpW_HttpParams(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkJsonObjectW json, HCkHttpResponseW response);
```

Sends an HTTP `verb` request to `url` with query parameters from `json`. The request has an empty body, and therefore, no `Content-Type` header is included. Typically, verbs such as `GET`, `HEAD`, and `DELETE` do not require a body. Applications generally call this method with `url`, while passing query parameters separately in `json`. See the example below. The HTTP response is returned in `response`.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpParamsAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.HttpReq

`Chilkat 11.7.0 · wc · Http · HttpReq · method · since 11.0.0`

```c
BOOL CkHttpW_HttpReq(HCkHttpW cHandle, const wchar_t *url, HCkHttpRequestW request, HCkHttpResponseW response);
```

Sends an HTTP request to `url` where the content of the request is defined by `request`. The path and query part of target is taken from the `url` instead of the path property within `request`.

```
scheme   host       path             query    
┌────┐  ┌─────────┐┌──────────────┐ ┌────────┐ 
https://example.com/docs/index.html?search=test
```

The HTTP response is returned in `response`.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpReqAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.HttpSb

`Chilkat 11.7.0 · wc · Http · HttpSb · method · since 11.0.0`

```c
BOOL CkHttpW_HttpSb(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkStringBuilderW sb, const wchar_t *charset, const wchar_t *contentType, HCkHttpResponseW response);
```

Sends an HTTP request to `url` using the specified `verb` (e.g., `POST`, `PUT`, `PATCH`). The request body contains the text passed in `sb`, and the content type is specified by `contentType` (e.g., `text/xml`, `application/json`). The `charset` defines the text encoding, such as `utf-8` or `iso-8859-1`. The HTTP response is returned in `response`.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpSbAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.HttpSReq

`Chilkat 11.7.0 · wc · Http · HttpSReq · method · since 11.0.0`

```c
BOOL CkHttpW_HttpSReq(HCkHttpW cHandle, const wchar_t *domain, int port, BOOL ssl, HCkHttpRequestW request, HCkHttpResponseW response);
```

Sends an HTTP request to web server at `domain`:`port` using TLS if `ssl` equals `TRUE`. The content of the request, including the path part of the URL, query params, additional headers, and request body is defined by `request`.

Note: The `domain` should include only the domain (host), not the complete URL. The path and query params are defined in the `request` object.

```
scheme   host       path             query    
┌────┐  ┌─────────┐┌──────────────┐ ┌────────┐ 
https://example.com/docs/index.html?search=test
```

`response` contains the HTTP response.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpSReqAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.HttpStr

`Chilkat 11.7.0 · wc · Http · HttpStr · method · since 11.0.0`

```c
BOOL CkHttpW_HttpStr(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, const wchar_t *bodyStr, const wchar_t *charset, const wchar_t *contentType, HCkHttpResponseW response);
```

Sends an HTTP request to `url` using the specified verb (e.g., `POST`, `PUT`, `PATCH`). The request body contains the text passed in `bodyStr`, and the content type is specified by `contentType` (e.g., `text/xml`, `application/json`). The `charset` defines the text encoding, such as `utf-8` or `iso-8859-1`. The HTTP response is returned in `response`.

This method returns `FALSE` for HTTP response status codes of `400` or higher, but the response object is still provided in `response`. If `response`'s status code is `0`, it indicates no response was received due to a communication error or another issue. In such cases, check the LastErrorText property for details.

Returns TRUE for success, FALSE for failure.

Async variant: `HttpStrAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.LoadTaskCaller

`Chilkat 11.7.0 · wc · Http · LoadTaskCaller · method · since 9.5.0.80`

```c
BOOL CkHttpW_LoadTaskCaller(HCkHttpW cHandle, HCkTaskW task);
```

Loads the caller of the task's async method.

Returns TRUE for success, FALSE for failure.

### Http.OcspCheck

`Chilkat 11.7.0 · wc · Http · OcspCheck · method · since 9.5.0.84`

```c
int CkHttpW_OcspCheck(HCkHttpW cHandle, const wchar_t *domain, int port);
```

Gets the server certificate at a domain:port and then sends an OCSP request to the certificate's OCSP URL to determine if the certificate has been revoked. Returns the OCSP status, which has one of the following values:

- -1: Unable to check. See the contents of the LastErrorText property for more informaiton.
- 0: Good
- 1: Revoked
- 2: Unknown

Async variant: `OcspCheckAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.ParseOcspReply

`Chilkat 11.7.0 · wc · Http · ParseOcspReply · method · since 9.5.0.75`

```c
int CkHttpW_ParseOcspReply(HCkHttpW cHandle, HCkBinDataW ocspReply, HCkJsonObjectW replyData);
```

Parses an OCSP reply. Returns the following possible integer values:

- -1: The `ocspReply` does not contain a valid OCSP reply.
- 0: Successful - Response has valid confirmations..
- 1: Malformed request - Illegal confirmation request.
- 2: Internal error - Internal error in issuer.
- 3: Try later - Try again later.
- 4: Not used - This value is never returned.
- 5: Sig required - Must sign the request.
- 6: Unauthorized - Request unauthorized.

The binaryOCSP reply is provided in `ocspReply`. The `replyData` is populated with data parsed from `ocspReply`.

OCSP requests are created by calling `CreateOcspRequest` .

### Http.QuickDeleteStr

`Chilkat 11.7.0 · wc · Http · QuickDeleteStr · method`

```c
BOOL CkHttpW_QuickDeleteStr(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr);
const wchar_t *CkHttpW_quickDeleteStr(HCkHttpW cHandle, const wchar_t *url);
```

This function sends an HTTP `DELETE` request to a specified URL and returns the response body as a string.

The HTTP response code is stored in the `LastStatus` property, while additional response details are available in properties such as `LastResponseHeader` , `LastResponseBody` , `LastModDate` , and `LastContentType` .

Returns TRUE for success, FALSE for failure.

Async variant: `QuickDeleteStrAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.QuickGetBd

`Chilkat 11.7.0 · wc · Http · QuickGetBd · method · since 9.5.0.64`

```c
BOOL CkHttpW_QuickGetBd(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);
```

This function sends an HTTP `GET` request to a specified URL, which can include query parameters, and returns the binary response body in `binData`.

The HTTP response code is stored in the `LastStatus` property. Additional response details can be found in properties like `LastResponseHeader` , `LastModDate` , and `LastContentType` .

A response code of 400 or higher indicates a failure. If the error response is text-based and the `KeepResponseBody` property is `TRUE`, it will be available in the `LastResponseBody` property.

Returns TRUE for success, FALSE for failure.

Async variant: `QuickGetBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.QuickGetSb

`Chilkat 11.7.0 · wc · Http · QuickGetSb · method · since 9.5.0.64`

```c
BOOL CkHttpW_QuickGetSb(HCkHttpW cHandle, const wchar_t *url, HCkStringBuilderW sbContent);
```

This function sends an HTTP `GET` request to a specified URL, which can include query parameters, and returns the text response body in `sbContent`. The existing content of `sbContent`, if any, is cleared and replaced with the downloaded content.

The response status code is stored in the `LastStatus` property. Additional response details can be found in properties like `LastResponseHeader` , `LastModDate` , and `LastContentType` .

If the response status code is >= 400, then this method returns `FALSE`, but the body of the HTTP response is still returned in `sbContent`. This allows for the application to examine the response body for cases where an error is returned, but the expected content is not received.

Returns TRUE for success, FALSE for failure.

Async variant: `QuickGetSbAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.QuickGetStr

`Chilkat 11.7.0 · wc · Http · QuickGetStr · method`

```c
BOOL CkHttpW_QuickGetStr(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr);
const wchar_t *CkHttpW_quickGetStr(HCkHttpW cHandle, const wchar_t *url);
```

This function sends an HTTP `GET` request to a specified URL, which can include query parameters, and returns the text response body.

The response status code is stored in the `LastStatus` property. Additional response details can be found in properties like `LastResponseHeader` , `LastModDate` , and `LastContentType` .

A response code of 400 or higher indicates a failure. If the error response is text-based and the `KeepResponseBody` property is `TRUE`, it will be available in the `LastResponseBody` property.

Returns TRUE for success, FALSE for failure.

Async variant: `QuickGetStrAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.RemoveRequestHeader

`Chilkat 11.7.0 · wc · Http · RemoveRequestHeader · method`

```c
void CkHttpW_RemoveRequestHeader(HCkHttpW cHandle, const wchar_t *name);
```

Eliminates a header field from being included in all HTTP requests, except for those sent by the `HttpReq` and `HttpSReq` methods, which rely on header fields provided in an `HttpRequest` object via method arguments.

### Http.RenderGet

`Chilkat 11.7.0 · wc · Http · RenderGet · method`

```c
BOOL CkHttpW_RenderGet(HCkHttpW cHandle, const wchar_t *url, const wchar_t *outStr);
const wchar_t *CkHttpW_renderGet(HCkHttpW cHandle, const wchar_t *url);
```

Builds the GET request that would be sent if a method such as `QuickGetStr` was called. Instead of sending the request, it returns the HTTP request that would have been sent.

Returns TRUE for success, FALSE for failure.

### Http.ResumeDownload

`Chilkat 11.7.0 · wc · Http · ResumeDownload · method`

```c
BOOL CkHttpW_ResumeDownload(HCkHttpW cHandle, const wchar_t *url, const wchar_t *targetFilename);
```

Resumes downloading content from `url` and saves it to a partially completed local file at `targetFilename`. If the file at `targetFilename` doesn't exist or is empty, this method functions the same as `Download` .

The download succeeds if the HTTP response status code is in the 200s. If unsuccessful, no output file is created. If the `KeepResponseBody` property is set to `TRUE`, the server's error response will be available in the `LastResponseBody` property.

The response status code will be available in the `LastStatus` property.

Returns TRUE for success, FALSE for failure.

Async variant: `ResumeDownloadAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.ResumeDownloadBd

`Chilkat 11.7.0 · wc · Http · ResumeDownloadBd · method · since 9.5.0.75`

```c
BOOL CkHttpW_ResumeDownloadBd(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);
```

Resumes a download from where it left off, determined by the number of bytes in `binData`. This method can be called multiple times until the download is complete.

The download succeeds if the HTTP response status code is in the 200s. If unsuccessful, no output file is created. If the `KeepResponseBody` property is set to `TRUE`, the server's error response will be available in the `LastResponseBody` property.

The response status code will be available in the `LastStatus` property.

Returns TRUE for success, FALSE for failure.

Async variant: `ResumeDownloadBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_CreateBucket

`Chilkat 11.7.0 · wc · Http · S3_CreateBucket · method`

```c
BOOL CkHttpW_S3_CreateBucket(HCkHttpW cHandle, const wchar_t *bucketPath);
```

Creates a new Amazon S3 bucket.

**Note:** You can add `x-amz-*` headers, including metadata, to any S3 request by using `SetRequestHeader` for each header. This applies to all S3 methods, even if not explicitly mentioned.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_CreateBucketAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_DeleteBucket

`Chilkat 11.7.0 · wc · Http · S3_DeleteBucket · method`

```c
BOOL CkHttpW_S3_DeleteBucket(HCkHttpW cHandle, const wchar_t *bucketPath);
```

Deletes an Amazon S3 bucket.

**Note:** Ensure the `AwsEndpoint` property is set to the correct region if the bucket is outside `us-east-1`, for example, `eu-central-1`. For S3-compatible services like `Wasabi`, always set the `AwsEndpoint` , such as `s3.wasabisys.com` or `s3.eu-central-1.wasabisys.com`.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_DeleteBucketAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_DeleteObject

`Chilkat 11.7.0 · wc · Http · S3_DeleteObject · method`

```c
BOOL CkHttpW_S3_DeleteObject(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName);
```

Deletes a remote file (object) on the Amazon S3 service.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_DeleteObjectAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_DeleteObjects

`Chilkat 11.7.0 · wc · Http · S3_DeleteObjects · method · since 11.0.0`

```c
BOOL CkHttpW_S3_DeleteObjects(HCkHttpW cHandle, const wchar_t *bucketName, HCkStringTableW objectNames, HCkJsonObjectW jsonResponse);
```

Deletes several objects from a bucket with a single request. `objectNames` includes the object names (or `keys`) to be deleted. To delete a specific object version, add a versionId to the object name, like this: `SampleDocument.txt; VersionId=OYcLXagmS.WaD..oyH4KRguB95_YhLs7`. If successful, `jsonResponse` will contain the JSON response.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_DeleteObjectsAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_DownloadBd

`Chilkat 11.7.0 · wc · Http · S3_DownloadBd · method · since 9.5.0.76`

```c
BOOL CkHttpW_S3_DownloadBd(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, HCkBinDataW bd);
```

Downloads a file from the Amazon S3 service into `bd`.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_DownloadBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_DownloadFile

`Chilkat 11.7.0 · wc · Http · S3_DownloadFile · method`

```c
BOOL CkHttpW_S3_DownloadFile(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, const wchar_t *localFilePath);
```

Downloads a file from the Amazon S3 service.

**Note:** Ensure the `AwsEndpoint` property is set to the correct region if the bucket is outside `us-east-1`, for example, `eu-central-1`. For S3-compatible services like `Wasabi`, always set the `AwsEndpoint` , such as `s3.wasabisys.com` or `s3.eu-central-1.wasabisys.com`.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_DownloadFileAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_DownloadString

`Chilkat 11.7.0 · wc · Http · S3_DownloadString · method`

```c
BOOL CkHttpW_S3_DownloadString(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, const wchar_t *charset, const wchar_t *outStr);
const wchar_t *CkHttpW_s3_DownloadString(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, const wchar_t *charset);
```

Downloads a text file (object) from the Amazon S3 service and returns the content as a string. The `charset` specifies the character encoding, such as `utf-8`, of the remote text object.

**Note:** Ensure the `AwsEndpoint` property is set to the correct region if the bucket is outside `us-east-1`, for example, `eu-central-1`. For S3-compatible services like `Wasabi`, always set the `AwsEndpoint` , such as `s3.wasabisys.com` or `s3.eu-central-1.wasabisys.com`.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_DownloadStringAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_FileExists

`Chilkat 11.7.0 · wc · Http · S3_FileExists · method`

```c
int CkHttpW_S3_FileExists(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName);
```

Checks the existence of a remote file, returning:

- 1 if the file exists
- 0 if the file does not exist
- -1 if the check failed
- 2 if in asynchronous mode, indicating the background task started successfully

**Note:** Ensure the `AwsEndpoint` property is set to the correct region if the bucket is outside `us-east-1`, for example, `eu-central-1`. For S3-compatible services like `Wasabi`, always set the `AwsEndpoint` , such as `s3.wasabisys.com` or `s3.eu-central-1.wasabisys.com`.

Async variant: `S3_FileExistsAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_GenPresignedUrl

`Chilkat 11.7.0 · wc · Http · S3_GenPresignedUrl · method · since 9.5.0.83`

```c
BOOL CkHttpW_S3_GenPresignedUrl(HCkHttpW cHandle, const wchar_t *httpVerb, BOOL useHttps, const wchar_t *bucketName, const wchar_t *path, int numSecondsValid, const wchar_t *awsService, const wchar_t *outStr);
const wchar_t *CkHttpW_s3_GenPresignedUrl(HCkHttpW cHandle, const wchar_t *httpVerb, BOOL useHttps, const wchar_t *bucketName, const wchar_t *path, int numSecondsValid, const wchar_t *awsService);
```

This method generates a temporary pre-signed URL for Amazon S3. Before calling this method, ensure the following properties are set to valid values: `AwsSecretKey` , `AwsAccessKey` , and `AwsRegion` . If the endpoint differs from `s3.amazonaws.com`, set the `AwsEndpoint` property accordingly.

`httpVerb` is the HTTP verb (e.g., `GET`, `PUT`, `POST`, `DELETE`). `awsService` is the name of the AWS service (e.g., `s3`, `s3-accelerate`). If `useHttps` is `TRUE`, the returned URL will start with `https://`; otherwise, it will start with `http://`.

The generated URL has this format:

```
https://<AwsEndpoint>/<bucket_name>/<path>
?X-Amz-Algorithm=AWS4-HMAC-SHA256
&X-Amz-Credential=<AwsAccessKey>/<currentDate>/<AwsRegion>/<awsService>/aws4_request
&X-Amz-Date=<currentDateTime>
&X-Amz-Expires=<numSecondsValid>
&X-Amz-SignedHeaders=host
&X-Amz-Signature=<signature-value>
```

Returns TRUE for success, FALSE for failure.

### Http.S3_ListBucketObjects

`Chilkat 11.7.0 · wc · Http · S3_ListBucketObjects · method`

```c
BOOL CkHttpW_S3_ListBucketObjects(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *outStr);
const wchar_t *CkHttpW_s3_ListBucketObjects(HCkHttpW cHandle, const wchar_t *bucketPath);
```

Retrieve an XML-formatted list of objects in an Amazon S3 bucket, similar to a directory listing.

`bucketPath` can include URL-encoded parameters. For example, to list objects in a bucket named `ChilkatABC` with a max-keys value of `2000` and a marker of `xyz`, pass the following string as `bucketPath` to the S3_ListBucketObjects method: `ChilkatABC?max-keys=2000&marker=xyz`

This method recognizes all parameters listed in the AWS documentation for bucket object listing: `delimiter`, `marker`, `max-keys`, and `prefix`. For further details, refer to Amazon's AWS online documentation.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_ListBucketObjectsAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_ListBuckets

`Chilkat 11.7.0 · wc · Http · S3_ListBuckets · method`

```c
BOOL CkHttpW_S3_ListBuckets(HCkHttpW cHandle, const wchar_t *outStr);
const wchar_t *CkHttpW_s3_ListBuckets(HCkHttpW cHandle);
```

Retrieves the XML listing of the buckets for an Amazon S3 account.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_ListBucketsAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_UploadBd

`Chilkat 11.7.0 · wc · Http · S3_UploadBd · method · since 9.5.0.76`

```c
BOOL CkHttpW_S3_UploadBd(HCkHttpW cHandle, HCkBinDataW bd, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);
```

Uploads the contents of `bd` as a file to the Amazon S3 service.

Note: `x-amz-*` headers, including metadata, can be added to any S3 request by adding each header with a call to `SetRequestHeader` . This applies to all S3 methods, even if not explicitly stated.

**Note:** Ensure the `AwsEndpoint` property is set to the correct region if the bucket is outside `us-east-1`, for example, `eu-central-1`. For S3-compatible services like `Wasabi`, always set the `AwsEndpoint` , such as `s3.wasabisys.com` or `s3.eu-central-1.wasabisys.com`.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_UploadBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_UploadFile

`Chilkat 11.7.0 · wc · Http · S3_UploadFile · method`

```c
BOOL CkHttpW_S3_UploadFile(HCkHttpW cHandle, const wchar_t *localFilePath, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);
```

Uploads a file to the Amazon S3 service.

Note: `x-amz-*` headers, including metadata, can be added to any S3 request by adding each header with a call to `SetRequestHeader` . This applies to all S3 methods, even if not explicitly stated.

**Note:** Ensure the `AwsEndpoint` property is set to the correct region if the bucket is outside `us-east-1`, for example, `eu-central-1`. For S3-compatible services like `Wasabi`, always set the `AwsEndpoint` , such as `s3.wasabisys.com` or `s3.eu-central-1.wasabisys.com`.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_UploadFileAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.S3_UploadString

`Chilkat 11.7.0 · wc · Http · S3_UploadString · method`

```c
BOOL CkHttpW_S3_UploadString(HCkHttpW cHandle, const wchar_t *objectContent, const wchar_t *charset, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);
```

Uploads the content of `objectContent` as a file to Amazon S3. `charset` specifies the string's character encoding (byte representation).

Note: `x-amz-*` headers, including metadata, can be added to any S3 request by adding each header with a call to `SetRequestHeader` . This applies to all S3 methods, even if not explicitly stated.

**Note:** Ensure the `AwsEndpoint` property is set to the correct region if the bucket is outside `us-east-1`, for example, `eu-central-1`. For S3-compatible services like `Wasabi`, always set the `AwsEndpoint` , such as `s3.wasabisys.com` or `s3.eu-central-1.wasabisys.com`.

Returns TRUE for success, FALSE for failure.

Async variant: `S3_UploadStringAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.SetAuthPrivateKey

`Chilkat 11.7.0 · wc · Http · SetAuthPrivateKey · method · since 9.5.0.89`

```c
BOOL CkHttpW_SetAuthPrivateKey(HCkHttpW cHandle, const wchar_t *publicKeyId, HCkPrivateKeyW privKey);
```

Sets the private key to be used with some forms of authentication. For example, this is used automatically add the Authorization header (Signature) for `Amazon Pay` requests.

Returns TRUE for success, FALSE for failure.

### Http.SetAuthTokenSb

`Chilkat 11.7.0 · wc · Http · SetAuthTokenSb · method · since 9.5.0.95`

```c
BOOL CkHttpW_SetAuthTokenSb(HCkHttpW cHandle, HCkStringBuilderW sb);
```

Sets the `AuthToken` property. The `sb` contains the OAuth2 access token to be used.

Returns TRUE for success, FALSE for failure.

### Http.SetClientAssertionKey

`Chilkat 11.7.0 · wc · Http · SetClientAssertionKey · method · since 11.7.0`

```c
BOOL CkHttpW_SetClientAssertionKey(HCkHttpW cHandle, HCkPrivateKeyW privKey, const wchar_t *kid);
```

Sets the private key for `private_key_jwt` client authentication (RFC 7523) in the OAuth2 client credentials flow of the `AuthToken` property. When the `AuthToken` is set to JSON with the client credentials, Chilkat creates a new `client_assertion` JWT, signed with this key, for each token request, and sends it with `client_assertion_type` set to `urn:ietf:params:oauth:client-assertion-type:jwt-bearer`. The JWT has the claims `iss` and `sub` (the `client_id` from the JSON), `aud` (the `token_endpoint`), `iat`, `exp` (5 minutes after `iat`) and a unique `jti`.

*kid* is the key ID, which is put in the JWT header. Pass an empty string if the authorization server does not need one. The key can be an EC key on the P-256, P-384 or P-521 curve (the JWT is signed with ES256, ES384 or ES512), an RSA key of 2048 bits or more (RS256), or an Ed25519 key (EdDSA). For example, load a key in JWK format with `PrivateKey.LoadJwk` and pass its `kid`.

This is typically used with `SetDPoPKey`, when the authorization server requires both a client assertion and DPoP. The same key may be passed to both methods if the server allows it. A `client_assertion` or `client_assertion_type` member in the `AuthToken` JSON is ignored once this key is set. The JSON must include the `client_id`.

Returns TRUE for success, FALSE for failure.

### Http.SetCookieXml

`Chilkat 11.7.0 · wc · Http · SetCookieXml · method`

```c
BOOL CkHttpW_SetCookieXml(HCkHttpW cHandle, const wchar_t *domain, const wchar_t *cookieXml);
```

This method restores cookies for a specified domain. It requires that the cookies, previously obtained using the `GetCookieXml` method, are stored in a persistent storage like a database or file. An application can then restore these cookies using this method.

Returns TRUE for success, FALSE for failure.

### Http.SetDPoPKey

`Chilkat 11.7.0 · wc · Http · SetDPoPKey · method · since 11.4.0`

```c
BOOL CkHttpW_SetDPoPKey(HCkHttpW cHandle, HCkPrivateKeyW privKey);
```

Sets the private key for automatically adding the DPoP header to HTTP requests. Chilkat will generate a JWT (a DPoP proof) for each request and include the `DPoP` header. Ensure the `AuthToken` property is also set.

The key can be an EC key on the P-256, P-384 or P-521 curve (the proof is signed with ES256, ES384 or ES512), an RSA key of 2048 bits or more (RS256), or an Ed25519 key (EdDSA). Before v11.7.0, only EC keys were accepted.

Returns TRUE for success, FALSE for failure.

### Http.SetOAuthRsaKey

`Chilkat 11.7.0 · wc · Http · SetOAuthRsaKey · method · since 9.5.0.39`

```c
BOOL CkHttpW_SetOAuthRsaKey(HCkHttpW cHandle, HCkPrivateKeyW privKey);
```

Sets the RSA key to be used with `OAuth 1.0a` authentication when the `OAuthSigMethod` is `RSA-SHA256` or `RSA-SHA1`.

Returns TRUE for success, FALSE for failure.

### Http.SetRequestHeader

`Chilkat 11.7.0 · wc · Http · SetRequestHeader · method`

```c
void CkHttpW_SetRequestHeader(HCkHttpW cHandle, const wchar_t *headerFieldName, const wchar_t *headerFieldValue);
```

Adds a header field to be included in all HTTP requests, except for those sent by the `HttpReq` and `HttpSReq` methods, which rely on header fields provided in an `HttpRequest` object via method arguments. If the header field already exists, it is replaced.

Use the `RemoveRequestHeader` method to delete a specific header. Setting a header field to an empty string will also remove it, unless the `AllowEmptyHeaders` option in `UncommonOptions` is used.

Avoid setting the `Authorization` header manually. Instead, use the appropriate authorization properties such as `Password` , `AuthToken` , `AuthSignature` , `BasicAuth` , `DigestAuth` , `NtlmAuth` , `OAuth1` , `OAuthToken` , etc.

To add cookies, use the `Cookie` header field format: `Cookie: name1=value1; name2=value2; name3=value3`.

Do not manually set the `Content-Length` header. Chilkat will automatically calculate and include `Content-Length` when sending the HTTP request.

### Http.SetSecurePassword

`Chilkat 11.7.0 · wc · Http · SetSecurePassword · method · since 9.5.0.76`

```c
BOOL CkHttpW_SetSecurePassword(HCkHttpW cHandle, HCkSecureStringW password);
```

Equivalent to setting the `Password` property but offers a more secure method by using a secure string object.

Returns TRUE for success, FALSE for failure.

### Http.SetSslCertRequirement

`Chilkat 11.7.0 · wc · Http · SetSslCertRequirement · method · since 9.5.0.84`

```c
void CkHttpW_SetSslCertRequirement(HCkHttpW cHandle, const wchar_t *reqName, const wchar_t *reqValue);
```

Enforces a requirement on the server's certificate. The `reqName` can be one of the following:

- SubjectDN
- SubjectCN
- IssuerDN
- IssuerCN
- SAN

The `reqName` specifies the part of the certificate, and the `reqValue` is the value that it must match exactly or with a wildcard (\*), for example `"*.example.com"`. If the server's certificate does not match, the SSL / TLS connection is aborted.

### Http.SetSslClientCert

`Chilkat 11.7.0 · wc · Http · SetSslClientCert · method`

```c
BOOL CkHttpW_SetSslClientCert(HCkHttpW cHandle, HCkCertW cert);
```

Facilitates the use of a client-side certificate for a TLS connection, enabling mutual authentication. In a standard TLS connection, the server alone presents a certificate during the handshake to verify its identity. With mutual TLS (mTLS), the client also presents a trusted certificate, allowing the server to authenticate the client's identity. This process enhances security by adding a layer of verification beyond just usernames, passwords, or tokens.

Returns TRUE for success, FALSE for failure.

### Http.SetSslClientCertPem

`Chilkat 11.7.0 · wc · Http · SetSslClientCertPem · method`

```c
BOOL CkHttpW_SetSslClientCertPem(HCkHttpW cHandle, const wchar_t *pemDataOrPath, const wchar_t *pemPassword);
```

This is identical to the `SetSslClientCert` method, but it allows the certificate with a private key to be in PEM format.

Returns TRUE for success, FALSE for failure.

### Http.SetSslClientCertPfx

`Chilkat 11.7.0 · wc · Http · SetSslClientCertPfx · method`

```c
BOOL CkHttpW_SetSslClientCertPfx(HCkHttpW cHandle, const wchar_t *pfxPath, const wchar_t *pfxPassword);
```

This is identical to the `SetSslClientCert` method, but enables you to provide a certificate with private key directly from a .pfx or .p12 file.

Returns TRUE for success, FALSE for failure.

### Http.SetUrlVar

`Chilkat 11.7.0 · wc · Http · SetUrlVar · method · since 9.5.0.67`

```c
BOOL CkHttpW_SetUrlVar(HCkHttpW cHandle, const wchar_t *name, const wchar_t *value);
```

Sets a variable's value for URL substitutions used in any method. Variables are formatted as `{$varName}` in URLs, such as: `https://graph.microsoft.com/v1.0/users/{$id}`.

Call `ClearUrlVars` to unset all URL variables.

Returns TRUE for success, FALSE for failure.

### Http.SharePointOnlineAuth

`Chilkat 11.7.0 · wc · Http · SharePointOnlineAuth · method · since 9.5.0.73`

```c
BOOL CkHttpW_SharePointOnlineAuth(HCkHttpW cHandle, const wchar_t *siteUrl, const wchar_t *username, HCkSecureStringW password, HCkJsonObjectW extraInfo);
```

This method authenticates with `SharePoint Online` and if successful, sets a cookie which is used for all following SharePoint HTTP requests. Before using this method, ensure you configure the `CookieDir` property to either `memory` or a specific directory path to store the authentication cookie, which will then be automatically used for subsequent HTTP requests.

Using this method automatically sets the `SaveCookies` and `SendCookies` properties to `TRUE`, as these settings are necessary for SharePoint Online authentication.

To use the method, provide the following arguments:

- `siteUrl`: The URL, e.g., https://yourdomain.sharepoint.com/
- `username`: An email address, e.g., username@yourdomain.com
- `password`: The Sharepoint password.
- `extraInfo`: Can be an empty JSON object. Reserved for additional information if needed in the future.

Returns TRUE for success, FALSE for failure.

Async variant: `SharePointOnlineAuthAsync` — same arguments, returns a `Task` (see Async variants below).

### Http.SleepMs

`Chilkat 11.7.0 · wc · Http · SleepMs · method`

```c
void CkHttpW_SleepMs(HCkHttpW cHandle, int millisec);
```

This method makes the calling process sleep for a specified number of milliseconds.

### Http.UrlDecode

`Chilkat 11.7.0 · wc · Http · UrlDecode · method`

```c
BOOL CkHttpW_UrlDecode(HCkHttpW cHandle, const wchar_t *str, const wchar_t *outStr);
const wchar_t *CkHttpW_urlDecode(HCkHttpW cHandle, const wchar_t *str);
```

URL decodes a string.

Returns TRUE for success, FALSE for failure.

### Http.UrlEncode

`Chilkat 11.7.0 · wc · Http · UrlEncode · method`

```c
BOOL CkHttpW_UrlEncode(HCkHttpW cHandle, const wchar_t *str, const wchar_t *outStr);
const wchar_t *CkHttpW_urlEncode(HCkHttpW cHandle, const wchar_t *str);
```

URL encodes a string.

Returns TRUE for success, FALSE for failure.

### Http.VerifyTimestampReply

`Chilkat 11.7.0 · wc · Http · VerifyTimestampReply · method · since 9.5.0.75`

```c
int CkHttpW_VerifyTimestampReply(HCkHttpW cHandle, HCkBinDataW timestampReply, HCkCertW tsaCert);
```

Verifies a timestamp reply received from a timestamp authority (TSA). Returns the following possible integer values:

- -1: The `timestampReply` does not contain a valid timestamp reply.
- -2: The `timestampReply` is a valid timestamp reply, but failed verification using the public key of the `tsaCert`.
- 0: Granted and verified.
- 1: Granted and verified, with mods (see RFC 3161)
- 2: Rejected.
- 3: Waiting.
- 4: Revocation Warning
- 5: Revocation Notification

If the timestamp reply (`timestampReply`) is known to be from a trusted source, then the `tsaCert` may be empty. If `tsaCert` is empty (never loaded with a certificate), then the verification will use the certificate embedded in the timestamp reply.

The `CreateTimestampRequest` method is used to create a timestamp request.

## Events and callbacks

This binding delivers progress information through callbacks (AbortCheck, PercentDone, ProgressInfo, TaskCompleted) rather than events. See `guide.md` for how to attach them in Unicode C.

## Async variants

Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on.

```c
HCkTaskW CkHttpW_CloseAllConnectionsAsync(HCkHttpW cHandle);
HCkTaskW CkHttpW_DownloadAsync(HCkHttpW cHandle, const wchar_t *url, const wchar_t *localFilePath);
HCkTaskW CkHttpW_DownloadAppendAsync(HCkHttpW cHandle, const wchar_t *url, const wchar_t *appendToPath);
HCkTaskW CkHttpW_DownloadBdAsync(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);
HCkTaskW CkHttpW_DownloadHashAsync(HCkHttpW cHandle, const wchar_t *url, const wchar_t *hashAlgorithm, const wchar_t *encoding);
HCkTaskW CkHttpW_DownloadSbAsync(HCkHttpW cHandle, const wchar_t *url, const wchar_t *charset, HCkStringBuilderW sb);
HCkTaskW CkHttpW_G_SvcOauthAccessTokenAsync(HCkHttpW cHandle, const wchar_t *iss, const wchar_t *scope, const wchar_t *subEmail, int numSec, HCkCertW cert);
HCkTaskW CkHttpW_G_SvcOauthAccessToken2Async(HCkHttpW cHandle, HCkHashtableW claimParams, int numSec, HCkCertW cert);
HCkTaskW CkHttpW_GetServerCertAsync(HCkHttpW cHandle, const wchar_t *domain, int port, HCkCertW cert);
HCkTaskW CkHttpW_HttpBdAsync(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkBinDataW bd, const wchar_t *contentType, HCkHttpResponseW response);
HCkTaskW CkHttpW_HttpFileAsync(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, const wchar_t *localFilePath, const wchar_t *contentType, HCkHttpResponseW response);
HCkTaskW CkHttpW_HttpJsonAsync(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkJsonObjectW json, const wchar_t *contentType, HCkHttpResponseW response);
HCkTaskW CkHttpW_HttpNoBodyAsync(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkHttpResponseW response);
HCkTaskW CkHttpW_HttpParamsAsync(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkJsonObjectW json, HCkHttpResponseW response);
HCkTaskW CkHttpW_HttpReqAsync(HCkHttpW cHandle, const wchar_t *url, HCkHttpRequestW request, HCkHttpResponseW response);
HCkTaskW CkHttpW_HttpSbAsync(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, HCkStringBuilderW sb, const wchar_t *charset, const wchar_t *contentType, HCkHttpResponseW response);
HCkTaskW CkHttpW_HttpSReqAsync(HCkHttpW cHandle, const wchar_t *domain, int port, BOOL ssl, HCkHttpRequestW request, HCkHttpResponseW response);
HCkTaskW CkHttpW_HttpStrAsync(HCkHttpW cHandle, const wchar_t *verb, const wchar_t *url, const wchar_t *bodyStr, const wchar_t *charset, const wchar_t *contentType, HCkHttpResponseW response);
HCkTaskW CkHttpW_OcspCheckAsync(HCkHttpW cHandle, const wchar_t *domain, int port);
HCkTaskW CkHttpW_QuickDeleteStrAsync(HCkHttpW cHandle, const wchar_t *url);
HCkTaskW CkHttpW_QuickGetBdAsync(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);
HCkTaskW CkHttpW_QuickGetSbAsync(HCkHttpW cHandle, const wchar_t *url, HCkStringBuilderW sbContent);
HCkTaskW CkHttpW_QuickGetStrAsync(HCkHttpW cHandle, const wchar_t *url);
HCkTaskW CkHttpW_ResumeDownloadAsync(HCkHttpW cHandle, const wchar_t *url, const wchar_t *targetFilename);
HCkTaskW CkHttpW_ResumeDownloadBdAsync(HCkHttpW cHandle, const wchar_t *url, HCkBinDataW binData);
HCkTaskW CkHttpW_S3_CreateBucketAsync(HCkHttpW cHandle, const wchar_t *bucketPath);
HCkTaskW CkHttpW_S3_DeleteBucketAsync(HCkHttpW cHandle, const wchar_t *bucketPath);
HCkTaskW CkHttpW_S3_DeleteObjectAsync(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName);
HCkTaskW CkHttpW_S3_DeleteObjectsAsync(HCkHttpW cHandle, const wchar_t *bucketName, HCkStringTableW objectNames, HCkJsonObjectW jsonResponse);
HCkTaskW CkHttpW_S3_DownloadBdAsync(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, HCkBinDataW bd);
HCkTaskW CkHttpW_S3_DownloadFileAsync(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, const wchar_t *localFilePath);
HCkTaskW CkHttpW_S3_DownloadStringAsync(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName, const wchar_t *charset);
HCkTaskW CkHttpW_S3_FileExistsAsync(HCkHttpW cHandle, const wchar_t *bucketPath, const wchar_t *objectName);
HCkTaskW CkHttpW_S3_ListBucketObjectsAsync(HCkHttpW cHandle, const wchar_t *bucketPath);
HCkTaskW CkHttpW_S3_ListBucketsAsync(HCkHttpW cHandle);
HCkTaskW CkHttpW_S3_UploadBdAsync(HCkHttpW cHandle, HCkBinDataW bd, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);
HCkTaskW CkHttpW_S3_UploadFileAsync(HCkHttpW cHandle, const wchar_t *localFilePath, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);
HCkTaskW CkHttpW_S3_UploadStringAsync(HCkHttpW cHandle, const wchar_t *objectContent, const wchar_t *charset, const wchar_t *contentType, const wchar_t *bucketPath, const wchar_t *objectName);
HCkTaskW CkHttpW_SharePointOnlineAuthAsync(HCkHttpW cHandle, const wchar_t *siteUrl, const wchar_t *username, HCkSecureStringW password, HCkJsonObjectW extraInfo);
```

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `AcceptCharset` | property | before 11.6.1 | `SetRequestHeader` |
| `AcceptLanguage` | property | before 11.6.1 | `SetRequestHeader` |
| `AwsSignatureVersion` | property | before 11.6.1 | — |
| `Connection` | property | before 11.6.1 | `SetRequestHeader` |
| `MimicFireFox` | property | before 11.6.1 | — |
| `MimicIE` | property | before 11.6.1 | — |
| `Referer` | property | before 11.6.1 | `SetRequestHeader` |
| `GetHead` | method | before 11.6.1 | `HttpNoBody` |
| `GetServerSslCert` | method | before 11.6.1 | `GetServerCert` |
| `LastJsonData` | method | before 11.6.1 | — |
| `PBinary` | method | before 11.6.1 | `HttpBinary` |
| `PBinaryBd` | method | before 11.6.1 | `HttpBd` |
| `PFile` | method | before 11.6.1 | `HttpFile` |
| `PostBinary` | method | before 11.6.1 | `HttpBinary` |
| `PostJson` | method | before 11.6.1 | `HttpStr` |
| `PostJson2` | method | before 11.6.1 | `HttpStr` |
| `PostJson3` | method | before 11.6.1 | `HttpJson` |
| `PostUrlEncoded` | method | before 11.6.1 | `HttpReq` |
| `PostXml` | method | before 11.6.1 | `HttpStr` |
| `PText` | method | before 11.6.1 | `HttpStr` |
| `PTextSb` | method | before 11.6.1 | `HttpSb` |
| `PutBinary` | method | before 11.6.1 | `HttpBinary` |
| `PutText` | method | before 11.6.1 | `HttpStr` |
| `QuickGet` | method | before 11.6.1 | — |
| `QuickGetObj` | method | before 11.6.1 | `HttpNoBody` |
| `QuickPutStr` | method | before 11.6.1 | `HttpNoBody` |
| `QuickRequest` | method | before 11.6.1 | `HttpNoBody` |
| `QuickRequestParams` | method | before 11.6.1 | `HttpParams` |
| `S3_DeleteMultipleObjects` | method | before 11.6.1 | `S3_DeleteObjects` |
| `S3_DownloadBytes` | method | before 11.6.1 | — |
| `S3_GenerateUrl` | method | before 11.6.1 | `S3_GenPresignedUrl` |
| `S3_GenerateUrlV4` | method | before 11.6.1 | `S3_GenPresignedUrl` |
| `S3_UploadBytes` | method | before 11.6.1 | — |
| `SynchronousRequest` | method | before 11.6.1 | `HttpSReq` |
| `XmlRpc` | method | before 11.6.1 | `HttpStr` |
| `XmlRpcPut` | method | before 11.6.1 | `HttpStr` |

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/BinData.md), [`Cert`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/Cert.md), [`Hashtable`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/Hashtable.md), [`HttpRequest`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/HttpRequest.md), [`HttpResponse`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/HttpResponse.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/JsonObject.md), [`PrivateKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/PrivateKey.md), [`SecureString`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/SecureString.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/StringBuilder.md), [`StringTable`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/StringTable.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/Task.md)

