apify 4.0.0-beta.17 → 4.0.0-beta.19

package/dist/actor.d.ts

@@ -379,24 +379,22 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      *
      * If the user function returns a promise, it is considered asynchronous:
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.main(() => {
      *   // My asynchronous function that returns a promise
-     *   return gotScraping('http://www.example.com').then((html) => {
-     *     console.log(html);
-     *   });
+     *   return fetch('http://www.example.com')
+     *     .then((response) => response.text())
+     *     .then((html) => {
+     *       console.log(html);
+     *     });
      * });
      * ```
      *
      * To simplify your code, you can take advantage of the `async`/`await` keywords:
      *
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.main(async () => {
      *   // My asynchronous function
-     *   const html = await request('http://www.example.com');
+     *   const html = await fetch('http://www.example.com').then((response) => response.text());
      *   console.log(html);
      * });
      * ```
@@ -888,24 +886,22 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      *
      * If the user function returns a promise, it is considered asynchronous:
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.main(() => {
      *   // My asynchronous function that returns a promise
-     *   return gotScraping('http://www.example.com').then((html) => {
-     *     console.log(html);
-     *   });
+     *   return fetch('http://www.example.com')
+     *     .then((response) => response.text())
+     *     .then((html) => {
+     *       console.log(html);
+     *     });
      * });
      * ```
      *
      * To simplify your code, you can take advantage of the `async`/`await` keywords:
      *
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.main(async () => {
      *   // My asynchronous function
-     *   const html = await gotScraping('http://www.example.com');
+     *   const html = await fetch('http://www.example.com').then((response) => response.text());
      *   console.log(html);
      * });
      * ```
@@ -931,11 +927,9 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * behavior by setting `options.gracefulShutdown` to `false`.
      *
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.init();
      *
-     * const html = await gotScraping('http://www.example.com');
+     * const html = await fetch('http://www.example.com').then((response) => response.text());
      * console.log(html);
      *
      * await Actor.exit();

package/dist/actor.js

@@ -2,7 +2,7 @@ import { createPrivateKey } from 'node:crypto';
 import { Dataset, purgeDefaultStorages, RequestQueue, serviceLocator } from '@crawlee/core';
 import { sleep, snakeCaseToCamelCase } from '@crawlee/utils';
 import { ApifyClient } from 'apify-client';
-import ow from 'ow';
+import { z } from 'zod';
 import { ACTOR_ENV_VARS, ACTOR_EVENT_NAMES, APIFY_ENV_VARS, INTEGER_ENV_VARS, } from '@apify/consts';
 import { decryptInputSecrets } from '@apify/input_secrets';
 import log from '@apify/log';
@@ -15,7 +15,7 @@ import { KeyValueStore } from './key_value_store.js';
 import { PlatformEventManager } from './platform_event_manager.js';
 import { ProxyConfiguration } from './proxy_configuration.js';
 import { openStorage } from './storage.js';
-import { checkCrawleeVersion, getSystemInfo, printOutdatedSdkWarning } from './utils.js';
+import { checkCrawleeVersion, getSystemInfo, isNonEmptyObject, printOutdatedSdkWarning, validate } from './utils.js';
 /**
  * Exit codes for the Actor process.
  * The error codes must be in the range 1-128, to avoid collision with signal exits
@@ -139,24 +139,22 @@ export class Actor {
      *
      * If the user function returns a promise, it is considered asynchronous:
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.main(() => {
      *   // My asynchronous function that returns a promise
-     *   return gotScraping('http://www.example.com').then((html) => {
-     *     console.log(html);
-     *   });
+     *   return fetch('http://www.example.com')
+     *     .then((response) => response.text())
+     *     .then((html) => {
+     *       console.log(html);
+     *     });
      * });
      * ```
      *
      * To simplify your code, you can take advantage of the `async`/`await` keywords:
      *
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.main(async () => {
      *   // My asynchronous function
-     *   const html = await request('http://www.example.com');
+     *   const html = await fetch('http://www.example.com').then((response) => response.text());
      *   console.log(html);
      * });
      * ```
@@ -534,18 +532,20 @@ export class Actor {
      * @ignore
      */
     async addWebhook(options) {
-        ow(options, ow.object.exactShape({
-            eventTypes: ow.array.ofType(ow.string),
-            requestUrl: ow.string,
-            payloadTemplate: ow.optional.string,
-            idempotencyKey: ow.optional.string,
-            headersTemplate: ow.optional.string,
-            description: ow.optional.string,
-            ignoreSslErrors: ow.optional.boolean,
-            doNotRetry: ow.optional.boolean,
-            shouldInterpolateStrings: ow.optional.boolean,
-            isApifyIntegration: ow.optional.boolean,
-        }));
+        validate(z
+            .object({
+            eventTypes: z.array(z.string()),
+            requestUrl: z.string(),
+            payloadTemplate: z.string().optional(),
+            idempotencyKey: z.string().optional(),
+            headersTemplate: z.string().optional(),
+            description: z.string().optional(),
+            ignoreSslErrors: z.boolean().optional(),
+            doNotRetry: z.boolean().optional(),
+            shouldInterpolateStrings: z.boolean().optional(),
+            isApifyIntegration: z.boolean().optional(),
+        })
+            .strict(), options);
         if (!this.isAtHome()) {
             log.warning('Actor.addWebhook() is only supported when running on the Apify platform. The webhook will not be invoked.');
             return undefined;
@@ -571,8 +571,8 @@ export class Actor {
      */
     async setStatusMessage(statusMessage, options) {
         const { isStatusMessageTerminal, level } = options || {};
-        ow(statusMessage, ow.string);
-        ow(isStatusMessageTerminal, ow.optional.boolean);
+        validate(z.string(), statusMessage);
+        validate(z.boolean().optional(), isStatusMessageTerminal);
         this._ensureActorInit('setStatusMessage');
         const loggedStatusMessage = `[Status message]: ${statusMessage}`;
         switch (level) {
@@ -665,9 +665,7 @@ export class Actor {
      * @ignore
      */
     async openDataset(datasetIdOrName, options = {}) {
-        ow(options, ow.object.exactShape({
-            forceCloud: ow.optional.boolean,
-        }));
+        validate(z.object({ forceCloud: z.boolean().optional() }).strict(), options);
         this._ensureActorInit('openDataset');
         return this._openStorage(Dataset, datasetIdOrName, options);
     }
@@ -774,16 +772,14 @@ export class Actor {
         const { inputSecretsPrivateKeyFile, inputSecretsPrivateKeyPassphrase } = this.config;
         const rawInput = await this.getValue(this.config.inputKey);
         let input = rawInput;
-        if (ow.isValid(rawInput, ow.object.nonEmpty) &&
-            inputSecretsPrivateKeyFile &&
-            inputSecretsPrivateKeyPassphrase) {
+        if (isNonEmptyObject(rawInput) && inputSecretsPrivateKeyFile && inputSecretsPrivateKeyPassphrase) {
             const privateKey = createPrivateKey({
                 key: Buffer.from(inputSecretsPrivateKeyFile, 'base64'),
                 passphrase: inputSecretsPrivateKeyPassphrase,
             });
             input = decryptInputSecrets({ input: rawInput, privateKey });
         }
-        if (ow.isValid(input, ow.object.nonEmpty) && !Buffer.isBuffer(input)) {
+        if (isNonEmptyObject(input) && !Buffer.isBuffer(input)) {
             input = await this.inferDefaultsFromInputSchema(input);
         }
         return input;
@@ -816,9 +812,7 @@ export class Actor {
      * @ignore
      */
     async openKeyValueStore(storeIdOrName, options = {}) {
-        ow(options, ow.object.exactShape({
-            forceCloud: ow.optional.boolean,
-        }));
+        validate(z.object({ forceCloud: z.boolean().optional() }).strict(), options);
         this._ensureActorInit('openKeyValueStore');
         return this._openStorage(KeyValueStore, storeIdOrName, options);
     }
@@ -841,9 +835,7 @@ export class Actor {
      * @ignore
      */
     async openRequestQueue(queueIdOrName, options = {}) {
-        ow(options, ow.object.exactShape({
-            forceCloud: ow.optional.boolean,
-        }));
+        validate(z.object({ forceCloud: z.boolean().optional() }).strict(), options);
         this._ensureActorInit('openRequestQueue');
         const queue = await this._openStorage(RequestQueue, queueIdOrName, options);
         // eslint-disable-next-line dot-notation
@@ -1070,24 +1062,22 @@ export class Actor {
      *
      * If the user function returns a promise, it is considered asynchronous:
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.main(() => {
      *   // My asynchronous function that returns a promise
-     *   return gotScraping('http://www.example.com').then((html) => {
-     *     console.log(html);
-     *   });
+     *   return fetch('http://www.example.com')
+     *     .then((response) => response.text())
+     *     .then((html) => {
+     *       console.log(html);
+     *     });
      * });
      * ```
      *
      * To simplify your code, you can take advantage of the `async`/`await` keywords:
      *
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.main(async () => {
      *   // My asynchronous function
-     *   const html = await gotScraping('http://www.example.com');
+     *   const html = await fetch('http://www.example.com').then((response) => response.text());
      *   console.log(html);
      * });
      * ```
@@ -1115,11 +1105,9 @@ export class Actor {
      * behavior by setting `options.gracefulShutdown` to `false`.
      *
      * ```js
-     * import { gotScraping } from 'got-scraping';
-     *
      * await Actor.init();
      *
-     * const html = await gotScraping('http://www.example.com');
+     * const html = await fetch('http://www.example.com').then((response) => response.text());
      * console.log(html);
      *
      * await Actor.exit();

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './actor.js';
 export { ApifyStorageClient } from './apify_storage_client.js';
+export { ArgumentValidationError } from './utils.js';
 export type { OpenStorageOptions, StorageAlias, StorageId, StorageName, StorageIdentifier, StorageIdentifierWithoutAlias, } from './storage.js';
 export { ChargeOptions, ChargeResult, ActorPricingInfo, ChargingManager } from './charging.js';
 export * from './configuration.js';

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from './actor.js';
 export { ApifyStorageClient } from './apify_storage_client.js';
+export { ArgumentValidationError } from './utils.js';
 export { ChargingManager } from './charging.js';
 export * from './configuration.js';
 export * from './proxy_configuration.js';

package/dist/proxy_configuration.d.ts

@@ -2,6 +2,12 @@ import type { ProxyConfigurationOptions as CoreProxyConfigurationOptions } from
 import { ProxyConfiguration as CoreProxyConfiguration } from '@crawlee/core';
 import type { ProxyInfo as CoreProxyInfo } from '@crawlee/types';
 import { Configuration } from './configuration.js';
+/** Response of the Apify Proxy status endpoint (`proxy.apify.com/?format=json`). */
+interface ProxyStatus {
+    connected: boolean;
+    connectionError: string;
+    isManInTheMiddle: boolean;
+}
 type NewUrlOptions = Parameters<CoreProxyConfiguration['newProxyInfo']>[0];
 export interface ProxyConfigurationOptions extends CoreProxyConfigurationOptions {
     /**
@@ -198,11 +204,16 @@ export declare class ProxyConfiguration extends CoreProxyConfiguration {
     /**
      * Apify Proxy can be down for a second or a minute, but this should not crash processes.
      */
-    protected _fetchStatus(): Promise<{
-        connected: boolean;
-        connectionError: string;
-        isManInTheMiddle: boolean;
-    } | undefined>;
+    protected _fetchStatus(): Promise<ProxyStatus | undefined>;
+    /**
+     * Fetches the Apify Proxy status endpoint once, *through* the proxy, so the
+     * response reports on this exact connection (auth + man-in-the-middle).
+     *
+     * Uses a native `node:http` forward-proxy request — an absolute request URL
+     * plus a `Proxy-Authorization` header — so no proxy-agent dependency is
+     * needed. The status endpoint (`http://proxy.apify.com`) is plain HTTP.
+     */
+    protected _requestStatus(statusUrl: string, proxyUrl: string): Promise<ProxyStatus>;
     /**
      * Throws cannot combine custom proxies with Apify Proxy
      * @internal

package/dist/proxy_configuration.js

@@ -1,10 +1,13 @@
+import { once } from 'node:events';
+import { request as httpRequest } from 'node:http';
+import { json } from 'node:stream/consumers';
 import { ProxyConfiguration as CoreProxyConfiguration } from '@crawlee/core';
-import { gotScraping } from 'got-scraping';
-import ow from 'ow';
+import { z } from 'zod';
 import { APIFY_ENV_VARS, APIFY_PROXY_VALUE_REGEX } from '@apify/consts';
 import { cryptoRandomObjectId } from '@apify/utilities';
 import { Actor } from './actor.js';
 import { Configuration } from './configuration.js';
+import { validate } from './utils.js';
 const CHECK_ACCESS_REQUEST_TIMEOUT_MILLIS = 4_000;
 const CHECK_ACCESS_MAX_ATTEMPTS = 2;
 const COUNTRY_CODE_REGEX = /^[A-Z]{2}$/;
@@ -67,15 +70,17 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
             ['validateRequired']: false,
         });
         this.config = config;
-        ow(rest, ow.object.exactShape({
-            groups: ow.optional.array.ofType(ow.string.matches(APIFY_PROXY_VALUE_REGEX)),
-            apifyProxyGroups: ow.optional.array.ofType(ow.string.matches(APIFY_PROXY_VALUE_REGEX)),
-            countryCode: ow.optional.string.matches(COUNTRY_CODE_REGEX),
-            apifyProxyCountry: ow.optional.string.matches(COUNTRY_CODE_REGEX),
-            subdivisionCode: ow.optional.string.matches(SUBDIVISION_CODE_REGEX),
-            apifyProxySubdivision: ow.optional.string.matches(SUBDIVISION_CODE_REGEX),
-            password: ow.optional.string,
-        }));
+        validate(z
+            .object({
+            groups: z.array(z.string().regex(APIFY_PROXY_VALUE_REGEX)).optional(),
+            apifyProxyGroups: z.array(z.string().regex(APIFY_PROXY_VALUE_REGEX)).optional(),
+            countryCode: z.string().regex(COUNTRY_CODE_REGEX).optional(),
+            apifyProxyCountry: z.string().regex(COUNTRY_CODE_REGEX).optional(),
+            subdivisionCode: z.string().regex(SUBDIVISION_CODE_REGEX).optional(),
+            apifyProxySubdivision: z.string().regex(SUBDIVISION_CODE_REGEX).optional(),
+            password: z.string().optional(),
+        })
+            .strict(), rest);
         const { groups = [], apifyProxyGroups = [], countryCode, apifyProxyCountry, subdivisionCode, apifyProxySubdivision, password = config.proxyPassword, } = options;
         const groupsToUse = groups.length ? groups : apifyProxyGroups;
         const countryCodeToUse = countryCode || apifyProxyCountry;
@@ -254,16 +259,14 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      */
     async _fetchStatus() {
         const { proxyStatusUrl } = this.config;
-        const requestOpts = {
-            url: `${proxyStatusUrl}/?format=json`,
-            proxyUrl: await this.newUrl(),
-            timeout: { request: CHECK_ACCESS_REQUEST_TIMEOUT_MILLIS },
-            responseType: 'json',
-        };
+        const statusUrl = `${proxyStatusUrl}/?format=json`;
+        const proxyUrl = await this.newUrl();
+        // Without a proxy URL we can't perform the (proxied) status check.
+        if (!proxyUrl)
+            return undefined;
         for (let attempt = 1; attempt <= CHECK_ACCESS_MAX_ATTEMPTS; attempt++) {
             try {
-                const response = await gotScraping(requestOpts);
-                return response.body;
+                return await this._requestStatus(statusUrl, proxyUrl);
             }
             catch {
                 // retry connection errors
@@ -271,6 +274,41 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
         }
         return undefined;
     }
+    /**
+     * Fetches the Apify Proxy status endpoint once, *through* the proxy, so the
+     * response reports on this exact connection (auth + man-in-the-middle).
+     *
+     * Uses a native `node:http` forward-proxy request — an absolute request URL
+     * plus a `Proxy-Authorization` header — so no proxy-agent dependency is
+     * needed. The status endpoint (`http://proxy.apify.com`) is plain HTTP.
+     */
+    async _requestStatus(statusUrl, proxyUrl) {
+        const target = new URL(statusUrl);
+        const proxy = new URL(proxyUrl);
+        const headers = { host: target.host };
+        if (proxy.username) {
+            const credentials = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+            headers['proxy-authorization'] = `Basic ${Buffer.from(credentials).toString('base64')}`;
+        }
+        const request = httpRequest({
+            host: proxy.hostname,
+            port: proxy.port,
+            // Absolute-form request URI tells the proxy to forward the request.
+            path: target.href,
+            headers,
+            signal: AbortSignal.timeout(CHECK_ACCESS_REQUEST_TIMEOUT_MILLIS),
+        });
+        request.end();
+        // `once` rejects if the request emits `error` first (connection refused,
+        // timeout/abort), so failures propagate to the retry loop in `_fetchStatus`.
+        const [response] = (await once(request, 'response'));
+        const statusCode = response.statusCode ?? 0;
+        if (statusCode < 200 || statusCode >= 300) {
+            response.resume(); // drain so the socket can be freed
+            throw new Error(`Apify Proxy status check responded with status code ${statusCode}.`);
+        }
+        return (await json(response));
+    }
     /**
      * Throws cannot combine custom proxies with Apify Proxy
      * @internal

package/dist/utils.d.ts

@@ -1,3 +1,30 @@
+import type { z } from 'zod';
+/**
+ * Returns `true` for a plain, non-empty object (not `null`, not an array).
+ * Mirrors the `ow.object.nonEmpty` predicate the SDK used previously.
+ * @internal
+ */
+export declare function isNonEmptyObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Error thrown when an argument fails validation (e.g. by `Actor.addWebhook()`
+ * or the `ProxyConfiguration` constructor).
+ *
+ * Its `message` is a human-readable sentence naming the offending field and the
+ * value it received (see {@link formatZodError}) — not a raw JSON dump. The
+ * structured zod {@link https://zod.dev | zod} issues are available on `issues`
+ * (and the original `ZodError` on `cause`) for programmatic inspection.
+ */
+export declare class ArgumentValidationError extends Error {
+    /** Structured issues from the underlying schema check. */
+    readonly issues: z.ZodError['issues'];
+    constructor(error: z.ZodError, value: unknown);
+}
+/**
+ * Validates `value` against a zod `schema`, returning the parsed value, or
+ * throwing an {@link ArgumentValidationError} if it doesn't match.
+ * @internal
+ */
+export declare function validate<Schema extends z.ZodType>(schema: Schema, value: unknown): z.infer<Schema>;
 /**
  * Gets info about system, node version and apify package version.
  * @internal

package/dist/utils.js

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { type } from 'node:os';
 import { normalize } from 'node:path';
@@ -6,14 +6,100 @@ import { normalize } from 'node:path';
 import crawleePkgJson from '@crawlee/core/package.json' with { type: 'json' };
 // @ts-ignore if we enable resolveJsonModule, we end up with `src` folder in `dist`
 import apifyClientPkgJson from 'apify-client/package.json' with { type: 'json' };
-// eslint-disable-next-line import/extensions
-import { readJSONSync } from 'fs-extra/esm';
 import semver from 'semver';
 import { APIFY_ENV_VARS } from '@apify/consts';
 import log from '@apify/log';
 // @ts-ignore if we enable resolveJsonModule, we end up with `src` folder in `dist`
 import apifyPkgJson from '../package.json' with { type: 'json' };
 const require = createRequire(import.meta.url);
+/**
+ * Returns `true` for a plain, non-empty object (not `null`, not an array).
+ * Mirrors the `ow.object.nonEmpty` predicate the SDK used previously.
+ * @internal
+ */
+export function isNonEmptyObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+/** Formats a zod issue path like `groups[0]` or `countryCode`. */
+function formatIssuePath(path) {
+    let out = '';
+    for (const key of path) {
+        if (typeof key === 'number')
+            out += `[${key}]`;
+        else
+            out += out ? `.${String(key)}` : String(key);
+    }
+    return out;
+}
+/** Reads the value at `path` from the validated input, to include in the error. */
+function valueAtPath(root, path) {
+    let current = root;
+    for (const key of path) {
+        if (current === null || typeof current !== 'object')
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+/** Renders a primitive received value for an error; skips objects/Dates (noisy). */
+function describeReceived(value) {
+    switch (typeof value) {
+        case 'string':
+            return value;
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+            return String(value);
+        default:
+            return undefined;
+    }
+}
+/**
+ * Formats a `ZodError` as a plain, human-readable message that names the
+ * offending field *and* the value it received (e.g. ``must match pattern
+ * /^[A-Z]{2}$/ at `countryCode`, got `CZE` ``) — closer to the old `ow` errors
+ * than zod's default, which omits the received value.
+ */
+function formatZodError(error, root) {
+    return error.issues
+        .map((issue) => {
+        const location = issue.path.length ? ` at \`${formatIssuePath(issue.path)}\`` : '';
+        const received = describeReceived(valueAtPath(root, issue.path));
+        const got = received === undefined ? '' : `, got \`${received}\``;
+        return `${issue.message}${location}${got}`;
+    })
+        .join('\n');
+}
+/**
+ * Error thrown when an argument fails validation (e.g. by `Actor.addWebhook()`
+ * or the `ProxyConfiguration` constructor).
+ *
+ * Its `message` is a human-readable sentence naming the offending field and the
+ * value it received (see {@link formatZodError}) — not a raw JSON dump. The
+ * structured zod {@link https://zod.dev | zod} issues are available on `issues`
+ * (and the original `ZodError` on `cause`) for programmatic inspection.
+ */
+export class ArgumentValidationError extends Error {
+    /** Structured issues from the underlying schema check. */
+    issues;
+    constructor(error, value) {
+        super(formatZodError(error, value), { cause: error });
+        this.name = 'ArgumentValidationError';
+        this.issues = error.issues;
+    }
+}
+/**
+ * Validates `value` against a zod `schema`, returning the parsed value, or
+ * throwing an {@link ArgumentValidationError} if it doesn't match.
+ * @internal
+ */
+export function validate(schema, value) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new ArgumentValidationError(result.error, value);
+    }
+    return result.data;
+}
 /**
  * Gets info about system, node version and apify package version.
  * @internal
@@ -55,7 +141,7 @@ export function checkCrawleeVersion() {
         }
         let version;
         try {
-            version = readJSONSync(path).version;
+            version = JSON.parse(readFileSync(path, 'utf8')).version;
         }
         catch {
             //

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify",
-  "version": "4.0.0-beta.17",
+  "version": "4.0.0-beta.19",
   "description": "The scalable web crawling and scraping library for JavaScript/Node.js. Enables development of data extraction and web automation jobs (not only) with headless Chrome and Puppeteer.",
   "engines": {
     "node": ">=22.0.0"
@@ -61,10 +61,7 @@
     "@crawlee/core": "^4.0.0-beta.61",
     "@crawlee/types": "^4.0.0-beta.61",
     "@crawlee/utils": "^4.0.0-beta.61",
-    "apify-client": "^2.17.0",
-    "fs-extra": "^11.2.0",
-    "got-scraping": "^4.2.1",
-    "ow": "^2.0.0",
+    "apify-client": "^2.23.4",
     "semver": "^7.5.4",
     "tslib": "^2.6.2",
     "ws": "^8.18.0",
@@ -77,7 +74,6 @@
     "@crawlee/memory-storage": "^4.0.0-beta.61",
     "@playwright/browser-chromium": "^1.60.0",
     "@types/content-type": "^1.1.8",
-    "@types/fs-extra": "^11.0.4",
     "@types/node": "^24.0.0",
     "@types/semver": "^7.5.8",
     "@types/tough-cookie": "^4.0.5",