Install impit using npm. The root package automatically detects your platform and installs the appropriate prebuilt binary (supporting Linux, macOS, and Windows across x86_64 and arm64 architectures).

npm install impit

The impit module allows you to switch TLS fingerprints and HTTP headers to impersonate a specific browser while maintaining a fetch-compatible API.

To use it, instantiate the Impit class with a configuration object and call the .fetch() method. The .fetch() method behaves identically to the built-in Node.js fetch function.

import { Impit } from 'impit';

// Set up the Impit instance
const impit = new Impit({
    browser: "chrome", // or "firefox"
    proxyUrl: "http://localhost:8080",
    ignoreTlsErrors: true,
});

// Use the `fetch` method as you would with the built-in `fetch` function
const response = await impit.fetch("https://example.com");

console.log(response.status);
console.log(response.headers);
console.log(await response.text());

To use impit in a Rust project, you must add it as a dependency and patch rustls and h2 to use the versions provided by the impit repository. Without these patches, the project will not build.

Additionally, you must build your project with the specific rustflag --cfg reqwest_unstable because impit utilizes unstable reqwest features, such as HTTP/3 support.

[dependencies]
impit = { git="https://github.com/apify/impit.git", branch="master" }

[patch.crates-io]
rustls = { git="https://github.com/apify/rustls.git" }
h2 = { git="https://github.com/apify/h2.git" }

Build command requirement:

rustflags = "--cfg reqwest_unstable"

If you are working in a Node.js environment, you can install the impit-node package via npm.

npm install impit

When iterating over HttpHeaders, the library resolves headers using a specific priority and deduplication logic:

1. Custom Headers First: Headers provided via with_custom_headers have the highest priority.
2. Fingerprint Headers Second: If a BrowserFingerprint is present, its headers are added after custom headers.
3. Deduplication: If a header name appears multiple times (e.g., once in custom headers and once in the fingerprint), only the first occurrence (the one with higher priority) is kept. The comparison is case-insensitive.
4. Empty Values: Headers with empty string values are filtered out and not included in the final set.

AsyncClient manages stateful interactions through two primary mechanisms:

Cookie Management

You can initialize the client with a persistent cookie_jar or by providing an initial set of cookies. If a cookie_jar is provided, the client will use it to store and send cookies across requests. If cookies are provided, they are converted into a PythonCookieJar for the client's use.

Redirect Behavior

By default, AsyncClient uses ManualRedirect behavior, meaning it will not automatically follow redirects. To enable automatic following, set follow_redirects=True during initialization. You can control the depth of this behavior using the max_redirects parameter (defaults to 20).

To enable automatic cookie handling in Impit, pass a cookieJar object in the constructor. The Impit class will automatically call getCookieString(url) before requests to include cookies in the headers, and call setCookie(cookie, url) when receiving Set-Cookie headers in responses.

Required Cookie Jar Interface:

• getCookieString(url: string): Promise<string>: Returns a cookie string for the given URL.
• setCookie(cookie: string, url: string): Promise<void>: Saves a cookie for the given URL.

const impit = new Impit({
    cookieJar: {
        getCookieString: async (url) => 'key=value',
        setCookie: async (cookie, url) => { /* implementation */ }
    }
});

The Impit class is the primary interface for making HTTP requests with browser impersonation. One Impit instance represents a single user agent, meaning all requests made by that instance share the same configuration, resources (such as the cookie jar and connection pool), and settings.

To use it, instantiate Impit and use the .fetch() method, which is designed to be API-compatible with the standard Web Fetch API.

import { Impit } from 'impit';

const impit = new Impit();
const response = await impit.fetch('https://example.com');
console.log(await response.text());

To use impit for browser impersonation, you need to initialize an Impit instance using a builder pattern. You can specify a browser fingerprint (e.g., from fingerprint::database) and enable features like HTTP/3. The Impit struct is generic over a cookie jar type (e.g., reqwest::cookie::Jar).

use impit::{impit::Impit, fingerprint::database as fingerprints};
use reqwest::cookie::Jar;

#[tokio::main]
async fn main() {
   let impit = Impit::<Jar>::builder()
       .with_fingerprint(fingerprints::firefox_144::fingerprint())
       .with_http3()
       .build()
       .unwrap();

   let response = impit.get(String::from("https://example.com"), None, None).await;

   match response {
       Ok(response) => {
           println!("{}", response.text().await.unwrap());
       }
       Err(e) => {
           println!("{:#?}", e);
       }
   }
}