fingerprint-suite

The BayesianNetwork class is used to randomly sample from a distribution defined by a JSON network definition.

Network Definition Structure

The definition is a JSON object containing a nodes array. Each node object must include:

• name: The unique identifier for the node.
• values: An array of possible values for that node.
• parentNames: An array of names of nodes that this node depends on.
• conditionalProbabilities: The probability distribution. This can be provided upfront in the JSON, or calculated later from data.

Workflow

1. Initialize: Create an instance with new BayesianNetwork(networkDefinition).
2. Configure Probabilities (Optional): If the JSON doesn't include probabilities, use .setProbabilitiesAccordingToData(dataframe) with a Danfo.js dataframe.
3. Persist: Save the configured network using .saveNetworkDefinition(networkDefinitionFilePath).
4. Sample: Generate data using .generateSample() or .generateConsistentSampleWhenPossible().

{
    "nodes": [
        {
            "name": "ParentNode",
            "values": ["A", "B", "C"],
            "parentNames": [],
            "conditionalProbabilities": {
                "A": 0.1,
                "B": 0.8,
                "C": 0.1
            }
        },
        {
            "name": "ChildNode",
            "values": [".", ",", "!", "?"],
            "parentNames": ["ParentNode"],
            "conditionalProbabilities": {
                "A": {
                    ".": 0.7,
                    "!": 0.3
                },
                "B": {
                    ",": 0.3,
                    "?": 0.7
                },
                "C": {
                    ".": 0.5,
                    "?": 0.5
                }
            }
        }
    ]
}

To generate headers, create an instance of the HeaderGenerator class. You can provide global configuration via HeaderGeneratorOptions in the constructor.

When calling .getHeaders(), you can pass an optional options object to override the global configuration for that specific call. The method generates a random, realistic set of headers, excluding request-dependent headers like Host or HTTP/2 pseudo-headers.

import { HeaderGenerator } from 'header-generator';

// Initialize with global options
let headerGenerator = new HeaderGenerator({
    browsers: [
        { name: 'firefox', minVersion: 90 },
        { name: 'chrome', minVersion: 110 },
        'safari',
    ],
    devices: ['desktop'],
    operatingSystems: ['windows'],
});

// Get headers with specific overrides for this call
let headers = headerGenerator.getHeaders({
    operatingSystems: ['linux'],
    locales: ['en-US', 'en'],
});

To camouflage a Playwright-managed Chromium instance, use the newInjectedContext function from fingerprint-injector. This function allows you to pass fingerprintOptions to constrain the generated fingerprint (e.g., by device type or operating system) and newContextOptions to pass standard Playwright context configurations.

import { chromium } from 'playwright';
import { newInjectedContext } from 'fingerprint-injector';

(async () => {
    const browser = await chromium.launch({ headless: false });
    const context = await newInjectedContext(browser, {
        // Constraints for the generated fingerprint (optional)
        fingerprintOptions: {
            devices: ['mobile'],
            operatingSystems: ['ios'],
        },
        // Playwright's newContext() options (optional, random example for illustration)
        newContextOptions: {
            geolocation: {
                latitude: 51.50853,
                longitude: -0.12574,
            },
        },
    });

    const page = await context.newPage();
    // ... your code using `page` here
})();

The HeaderGeneratorOptions interface defines how headers are generated.

Key options include:

• browsers: An array of BrowserSpecification objects or BrowserName strings (e.g., 'chrome', 'edge', 'firefox', 'safari').
• browserListQuery: A string query for Browserslist. If provided, the browsers array is ignored.
• operatingSystems: An array of OperatingSystem values.
• devices: An array of Device values (e.g., ['desktop']).
• locales: An array of language strings (e.g., ['en-US', 'de']) used for the Accept-Language header.
• httpVersion: Either '1' or '2'. Defaults to '2'.
• strict: If true, the generator throws an error if it cannot satisfy all constraints instead of relaxing them.

export interface HeaderGeneratorOptions {
    browsers: BrowsersType;
    browserListQuery: string;
    operatingSystems: OperatingSystem[];
    devices: Device[];
    locales: string[];
    httpVersion: HttpVersion;
    strict: boolean;
}