Playwright Scraper

Pricing

Pay per usage

Try for free

Go to Apify Store

Playwright Scraper

Try for free

Developed by

Apify

Maintained by Apify

Crawls websites with the headless Chromium, Chrome, or Firefox browser and Playwright library using a provided server-side Node.js code. Supports both recursive crawling and a list of URLs. Supports login to a website.

4.7 (8)

Pricing

Pay per usage

2.9K

520

Issues response

4.9 days

Last modified

20 days ago

Developer tools

Open source

tsconfig.json

{
    "extends": "@apify/tsconfig",
    "compilerOptions": {
        "outDir": "dist",
        "module": "ESNext",
        "allowJs": true,
        "skipLibCheck": true
    },
    "include": ["src"]
}

Dockerfile

FROM apify/actor-node-playwright:22 AS builder

COPY --chown=myuser package*.json ./

RUN npm install --include=dev --audit=false

COPY --chown=myuser . ./

RUN npm run build

FROM apify/actor-node-playwright:22

COPY --from=builder --chown=myuser /home/myuser/dist ./dist

COPY --chown=myuser package*.json ./

RUN npm --quiet set progress=false \
    && npm install --omit=dev --omit=optional \
    && echo "Installed NPM packages:" \
    && (npm list --omit=dev --all || true) \
    && echo "Node.js version:" \
    && node --version \
    && echo "NPM version:" \
    && npm --version \
    && rm -r ~/.npm

COPY --chown=myuser . ./

ENV APIFY_DISABLE_OUTDATED_WARNING=1

CMD ./start_xvfb_and_run_cmd.sh && npm run start:prod --silent

package.json

{
    "name": "actor-playwright-scraper",
    "version": "3.1.0",
    "private": true,
    "description": "Crawl web pages using Apify, headless browser and Playwright",
    "type": "module",
    "dependencies": {
        "@apify/scraper-tools": "^1.1.4",
        "@crawlee/core": "^3.14.1",
        "@crawlee/playwright": "^3.14.1",
        "@crawlee/utils": "^3.14.1",
        "apify": "^3.2.6",
        "idcac-playwright": "^0.1.3",
        "playwright": "*"
    },
    "devDependencies": {
        "@apify/tsconfig": "^0.1.0",
        "@types/node": "^22.7.4",
        "tsx": "^4.19.1",
        "typescript": "~5.9.0"
    },
    "scripts": {
        "start": "npm run start:dev",
        "start:prod": "node dist/main.js",
        "start:dev": "tsx src/main.ts",
        "build": "tsc"
    },
    "repository": {
        "type": "git",
        "url": "https://github.com/apify/apify-sdk-js"
    },
    "author": {
        "name": "Apify Technologies",
        "email": "support@apify.com",
        "url": "https://apify.com"
    },
    "license": "Apache-2.0",
    "homepage": "https://github.com/apify/apify-sdk-js"
}

.dockerignore

# configurations
.idea

# crawlee and apify storage folders
apify_storage
crawlee_storage
storage

# installed files
node_modules

src/main.ts

1import { runActor } from '@apify/scraper-tools';
2
3import { CrawlerSetup } from './internals/crawler_setup.js';
4
5runActor(CrawlerSetup);

.actor/actor.json

{
    "actorSpecification": 1,
    "name": "playwright-scraper",
    "version": "0.1",
    "buildTag": "latest",
    "storages": {
        "dataset": {
            "actorSpecification": 1,
            "fields": {},
            "views": {}
        }
    }
}

src/internals/consts.ts

1import type {
2    GlobInput,
3    ProxyConfigurationOptions,
4    PseudoUrlInput,
5    RegExpInput,
6    RequestOptions,
7    Session,
8} from '@crawlee/core';
9import type { Dictionary } from '@crawlee/utils';
10
11export const enum ProxyRotation {
12    Recommended = 'RECOMMENDED',
13    PerRequest = 'PER_REQUEST',
14    UntilFailure = 'UNTIL_FAILURE',
15}
16
17/**
18 * Replicates the INPUT_SCHEMA with TypeScript types for quick reference
19 * and IDE type check integration.
20 */
21export interface Input {
22    startUrls: RequestOptions[];
23    globs: GlobInput[];
24    regexps: RegExpInput[];
25    pseudoUrls: PseudoUrlInput[];
26    excludes: GlobInput[];
27    linkSelector?: string;
28    keepUrlFragments: boolean;
29    respectRobotsTxtFile: boolean;
30    pageFunction: string;
31    preNavigationHooks?: string;
32    postNavigationHooks?: string;
33    proxyConfiguration: ProxyConfigurationOptions;
34    proxyRotation: ProxyRotation;
35    sessionPoolName?: string;
36    initialCookies: Parameters<Session['setCookies']>[0];
37    launcher: 'chromium' | 'firefox' | 'webkit';
38    useChrome: boolean;
39    maxScrollHeightPixels: number;
40    ignoreSslErrors: boolean;
41    ignoreCorsAndCsp: boolean;
42    closeCookieModals: boolean;
43    downloadMedia: boolean;
44    downloadCss: boolean;
45    maxRequestRetries: number;
46    maxPagesPerCrawl: number;
47    maxResultsPerCrawl: number;
48    maxCrawlingDepth: number;
49    maxConcurrency: number;
50    pageLoadTimeoutSecs: number;
51    pageFunctionTimeoutSecs: number;
52    waitUntil: 'networkidle' | 'load' | 'domcontentloaded';
53    debugLog: boolean;
54    browserLog: boolean;
55    customData: Dictionary;
56    datasetName?: string;
57    keyValueStoreName?: string;
58    requestQueueName?: string;
59    headless: boolean;
60}

src/internals/crawler_setup.ts

1import { readFile } from 'node:fs/promises';
2import { dirname } from 'node:path';
3import { fileURLToPath, URL } from 'node:url';
4
5import type {
6    AutoscaledPool,
7    EnqueueLinksOptions,
8    PlaywrightCrawlerOptions,
9    PlaywrightCrawlingContext,
10    PlaywrightLaunchContext,
11    ProxyConfiguration,
12    Request,
13} from '@crawlee/playwright';
14import {
15    Dataset,
16    KeyValueStore,
17    log,
18    PlaywrightCrawler,
19    RequestList,
20    RequestQueueV2,
21} from '@crawlee/playwright';
22import type { Awaitable, Dictionary } from '@crawlee/utils';
23import { sleep } from '@crawlee/utils';
24import type { ApifyEnv } from 'apify';
25import { Actor } from 'apify';
26import { getInjectableScript } from 'idcac-playwright';
27import type { Response } from 'playwright';
28import playwright from 'playwright';
29
30import type {
31    CrawlerSetupOptions,
32    RequestMetadata,
33} from '@apify/scraper-tools';
34import {
35    browserTools,
36    constants as scraperToolsConstants,
37    createContext,
38    tools,
39} from '@apify/scraper-tools';
40
41import type { Input } from './consts.js';
42import { ProxyRotation } from './consts.js';
43
44const SESSION_STORE_NAME = 'APIFY-PLAYWRIGHT-SCRAPER-SESSION-STORE';
45const REQUEST_QUEUE_INIT_FLAG_KEY = 'REQUEST_QUEUE_INITIALIZED';
46
47const {
48    META_KEY,
49    DEFAULT_VIEWPORT,
50    DEVTOOLS_TIMEOUT_SECS,
51    SESSION_MAX_USAGE_COUNTS,
52} = scraperToolsConstants;
53const SCHEMA = JSON.parse(
54    await readFile(new URL('../../INPUT_SCHEMA.json', import.meta.url), 'utf8'),
55);
56
57/**
58 * Holds all the information necessary for constructing a crawler
59 * instance and creating a context for a pageFunction invocation.
60 */
61export class CrawlerSetup implements CrawlerSetupOptions {
62    name = 'Playwright Scraper';
63    rawInput: string;
64    env: ApifyEnv;
65    /**
66     * Used to store data that persist navigations
67     */
68    globalStore = new Map();
69    requestQueue: RequestQueueV2;
70    keyValueStore: KeyValueStore;
71    customData: unknown;
72    input: Input;
73    maxSessionUsageCount: number;
74    evaledPageFunction: (...args: unknown[]) => unknown;
75    evaledPreNavigationHooks: ((...args: unknown[]) => Awaitable<void>)[];
76    evaledPostNavigationHooks: ((...args: unknown[]) => Awaitable<void>)[];
77    blockedUrlPatterns: string[] = [];
78    devtools: boolean;
79    datasetName?: string;
80    keyValueStoreName?: string;
81    requestQueueName?: string;
82
83    crawler!: PlaywrightCrawler;
84    dataset!: Dataset;
85    pagesOutputted!: number;
86    private initPromise: Promise<void>;
87
88    constructor(input: Input) {
89        // Set log level early to prevent missed messages.
90        if (input.debugLog) log.setLevel(log.LEVELS.DEBUG);
91
92        // Keep this as string to be immutable.
93        this.rawInput = JSON.stringify(input);
94
95        // Attempt to load page function from disk if not present on input.
96        tools.maybeLoadPageFunctionFromDisk(
97            input,
98            dirname(fileURLToPath(import.meta.url)),
99        );
100
101        // Validate INPUT if not running on Apify Cloud Platform.
102        if (!Actor.isAtHome()) tools.checkInputOrThrow(input, SCHEMA);
103
104        this.input = input;
105        this.env = Actor.getEnv();
106
107        // Validations
108        this.input.pseudoUrls.forEach((purl) => {
109            if (!tools.isPlainObject(purl)) {
110                throw new Error(
111                    'The pseudoUrls Array must only contain Objects.',
112                );
113            }
114            if (purl.userData && !tools.isPlainObject(purl.userData)) {
115                throw new Error(
116                    'The userData property of a pseudoUrl must be an Object.',
117                );
118            }
119        });
120
121        if (this.input.useChrome && this.input.launcher !== 'chromium') {
122            throw new Error(
123                'useChrome option could only be used with Chromium browser selected.',
124            );
125        }
126
127        this.input.initialCookies.forEach((cookie) => {
128            if (!tools.isPlainObject(cookie)) {
129                throw new Error(
130                    'The initialCookies Array must only contain Objects.',
131                );
132            }
133        });
134
135        if (
136            !/^(domcontentloaded|load|networkidle)$/.test(this.input.waitUntil)
137        ) {
138            throw new Error(
139                'Navigation wait until event must be valid. See tooltip.',
140            );
141        }
142
143        // solving proxy rotation settings
144        this.maxSessionUsageCount =
145            SESSION_MAX_USAGE_COUNTS[this.input.proxyRotation];
146
147        // Functions need to be evaluated.
148        this.evaledPageFunction = tools.evalFunctionOrThrow(
149            this.input.pageFunction,
150        );
151
152        if (this.input.preNavigationHooks) {
153            this.evaledPreNavigationHooks = tools.evalFunctionArrayOrThrow(
154                this.input.preNavigationHooks,
155                'preNavigationHooks',
156            );
157        } else {
158            this.evaledPreNavigationHooks = [];
159        }
160
161        if (this.input.postNavigationHooks) {
162            this.evaledPostNavigationHooks = tools.evalFunctionArrayOrThrow(
163                this.input.postNavigationHooks,
164                'postNavigationHooks',
165            );
166        } else {
167            this.evaledPostNavigationHooks = [];
168        }
169
170        // Excluded resources
171        this.blockedUrlPatterns = [];
172        if (!this.input.downloadMedia) {
173            this.blockedUrlPatterns = [
174                '.jpg',
175                '.jpeg',
176                '.png',
177                '.svg',
178                '.gif',
179                '.webp',
180                '.webm',
181                '.ico',
182                '.woff',
183                '.eot',
184            ];
185        }
186
187        if (!this.input.downloadCss) {
188            this.blockedUrlPatterns.push('.css');
189        }
190
191        // Start Chromium with Debugger any time the page function includes the keyword.
192        this.devtools = this.input.pageFunction.includes('debugger;');
193
194        // Named storages
195        this.datasetName = this.input.datasetName;
196        this.keyValueStoreName = this.input.keyValueStoreName;
197        this.requestQueueName = this.input.requestQueueName;
198
199        // Initialize async operations.
200        this.crawler = null!;
201        this.requestQueue = null!;
202        this.dataset = null!;
203        this.keyValueStore = null!;
204        this.initPromise = this._initializeAsync();
205    }
206
207    private async _initializeAsync() {
208        // RequestList
209        const startUrls = this.input.startUrls.map((req) => {
210            req.useExtendedUniqueKey = true;
211            req.keepUrlFragment = this.input.keepUrlFragments;
212            return req;
213        });
214
215        // KeyValueStore
216        this.keyValueStore = await KeyValueStore.open(this.keyValueStoreName);
217
218        // RequestQueue
219        this.requestQueue = await RequestQueueV2.open(this.requestQueueName);
220
221        if (
222            !(await this.keyValueStore.recordExists(
223                REQUEST_QUEUE_INIT_FLAG_KEY,
224            ))
225        ) {
226            const requests: Request[] = [];
227            for await (const request of await RequestList.open(
228                null,
229                startUrls,
230            )) {
231                if (
232                    this.input.maxResultsPerCrawl > 0 &&
233                    requests.length >= 1.5 * this.input.maxResultsPerCrawl
234                ) {
235                    break;
236                }
237                requests.push(request);
238            }
239
240            const { waitForAllRequestsToBeAdded } =
241                await this.requestQueue.addRequestsBatched(requests);
242
243            void waitForAllRequestsToBeAdded.then(async () => {
244                await this.keyValueStore.setValue(
245                    REQUEST_QUEUE_INIT_FLAG_KEY,
246                    '1',
247                );
248            });
249        }
250
251        // Dataset
252        this.dataset = await Dataset.open(this.datasetName);
253        const info = await this.dataset.getInfo();
254        this.pagesOutputted = info?.itemCount ?? 0;
255    }
256
257    /**
258     * Resolves to a `PlaywrightCrawler` instance.
259     */
260    async createCrawler() {
261        await this.initPromise;
262
263        const args = [];
264        if (this.input.ignoreCorsAndCsp) args.push('--disable-web-security');
265
266        const options: PlaywrightCrawlerOptions = {
267            requestHandler: this._requestHandler.bind(this),
268            requestQueue: this.requestQueue,
269            requestHandlerTimeoutSecs: this.devtools
270                ? DEVTOOLS_TIMEOUT_SECS
271                : this.input.pageFunctionTimeoutSecs,
272            preNavigationHooks: [],
273            postNavigationHooks: [],
274            failedRequestHandler: this._failedRequestHandler.bind(this),
275            respectRobotsTxtFile: this.input.respectRobotsTxtFile,
276            maxConcurrency: this.input.maxConcurrency,
277            maxRequestRetries: this.input.maxRequestRetries,
278            maxRequestsPerCrawl:
279                this.input.maxPagesPerCrawl === 0
280                    ? undefined
281                    : this.input.maxPagesPerCrawl,
282            proxyConfiguration: (await Actor.createProxyConfiguration(
283                this.input.proxyConfiguration,
284            )) as any as ProxyConfiguration,
285            launchContext: {
286                useChrome: this.input.useChrome,
287                launcher: playwright[this.input.launcher],
288                launchOptions: {
289                    ignoreHTTPSErrors: this.input.ignoreSslErrors,
290                    bypassCSP: this.input.ignoreCorsAndCsp,
291                    defaultViewport: DEFAULT_VIEWPORT,
292                    devtools: this.devtools,
293                    args,
294                    headless: this.input.headless,
295                },
296            } as PlaywrightLaunchContext,
297            useSessionPool: true,
298            persistCookiesPerSession: true,
299            sessionPoolOptions: {
300                persistStateKeyValueStoreId: this.input.sessionPoolName
301                    ? SESSION_STORE_NAME
302                    : undefined,
303                persistStateKey: this.input.sessionPoolName,
304                sessionOptions: {
305                    maxUsageCount: this.maxSessionUsageCount,
306                },
307            },
308            experiments: {
309                requestLocking: true,
310            },
311        };
312
313        this._createNavigationHooks(options);
314
315        if (this.input.proxyRotation === ProxyRotation.UntilFailure) {
316            options.sessionPoolOptions!.maxPoolSize = 1;
317        }
318
319        this.crawler = new PlaywrightCrawler(options);
320
321        return this.crawler;
322    }
323
324    private _createNavigationHooks(options: PlaywrightCrawlerOptions) {
325        options.preNavigationHooks!.push(
326            async ({ request, page, session, blockRequests }, gotoOptions) => {
327                // Attach a console listener to get all logs from Browser context.
328                if (this.input.browserLog) browserTools.dumpConsole(page);
329
330                // Prevent download of stylesheets and media, unless selected otherwise
331                if (this.blockedUrlPatterns.length) {
332                    await blockRequests({
333                        urlPatterns: this.blockedUrlPatterns,
334                    });
335                }
336
337                // Add initial cookies, if any.
338                if (
339                    this.input.initialCookies &&
340                    this.input.initialCookies.length
341                ) {
342                    const cookiesToSet = session
343                        ? tools.getMissingCookiesFromSession(
344                              session,
345                              this.input.initialCookies,
346                              request.url,
347                          )
348                        : this.input.initialCookies;
349
350                    if (cookiesToSet?.length) {
351                        // setting initial cookies that are not already in the session and page
352                        session?.setCookies(cookiesToSet, request.url);
353                        await page.context().addCookies(cookiesToSet);
354                    }
355                }
356
357                if (gotoOptions) {
358                    gotoOptions.timeout =
359                        (this.devtools
360                            ? DEVTOOLS_TIMEOUT_SECS
361                            : this.input.pageLoadTimeoutSecs) * 1000;
362                    gotoOptions.waitUntil = this.input.waitUntil;
363                }
364            },
365        );
366
367        options.preNavigationHooks!.push(
368            ...this._runHookWithEnhancedContext(this.evaledPreNavigationHooks),
369        );
370        options.postNavigationHooks!.push(
371            ...this._runHookWithEnhancedContext(this.evaledPostNavigationHooks),
372        );
373    }
374
375    private _runHookWithEnhancedContext(
376        hooks: ((...args: unknown[]) => Awaitable<void>)[],
377    ) {
378        return hooks.map((hook) => (ctx: Dictionary, ...args: unknown[]) => {
379            const { customData } = this.input;
380            return hook({ ...ctx, Apify: Actor, Actor, customData }, ...args);
381        });
382    }
383
384    private async _failedRequestHandler({
385        request,
386    }: PlaywrightCrawlingContext) {
387        const lastError =
388            request.errorMessages[request.errorMessages.length - 1];
389        const errorMessage = lastError ? lastError.split('\n')[0] : 'no error';
390        log.error(
391            `Request ${request.url} failed and will not be retried anymore. Marking as failed.\nLast Error Message: ${errorMessage}`,
392        );
393        return this._handleResult(request, undefined, undefined, true);
394    }
395
396    /**
397     * First of all, it initializes the state that is exposed to the user via
398     * `pageFunction` context.
399     *
400     * Then it invokes the user provided `pageFunction` with the prescribed context
401     * and saves its return value.
402     *
403     * Finally, it makes decisions based on the current state and post-processes
404     * the data returned from the `pageFunction`.
405     */
406    private async _requestHandler(crawlingContext: PlaywrightCrawlingContext) {
407        const { request, response, crawler } = crawlingContext;
408
409        /**
410         * PRE-PROCESSING
411         */
412        // Make sure that an object containing internal metadata
413        // is present on every request.
414        tools.ensureMetaData(request);
415
416        // Abort the crawler if the maximum number of results was reached.
417        const aborted = await this._handleMaxResultsPerCrawl(
418            crawler.autoscaledPool,
419        );
420        if (aborted) return;
421
422        const pageFunctionArguments: Dictionary = {};
423
424        // We must use properties and descriptors not to trigger getters / setters.
425        Object.defineProperties(
426            pageFunctionArguments,
427            Object.getOwnPropertyDescriptors(crawlingContext),
428        );
429
430        pageFunctionArguments.response = {
431            status: response && response.status(),
432            headers: response && response.headers(),
433        };
434
435        // Setup and create Context.
436        const contextOptions = {
437            crawlerSetup: {
438                rawInput: this.rawInput,
439                env: this.env,
440                globalStore: this.globalStore,
441                requestQueue: this.requestQueue,
442                keyValueStore: this.keyValueStore,
443                customData: this.input.customData,
444            },
445            pageFunctionArguments,
446        };
447        const { context, state } = createContext(contextOptions);
448
449        if (this.input.closeCookieModals) {
450            await sleep(500);
451            await crawlingContext.page.evaluate(getInjectableScript());
452            await sleep(2000);
453        }
454
455        if (this.input.maxScrollHeightPixels > 0) {
456            await crawlingContext.infiniteScroll({
457                maxScrollHeight: this.input.maxScrollHeightPixels,
458            });
459        }
460
461        /**
462         * USER FUNCTION INVOCATION
463         */
464        const pageFunctionResult = await this.evaledPageFunction(context);
465
466        /**
467         * POST-PROCESSING
468         */
469        // Enqueue more links if Pseudo URLs and a link selector are available,
470        // unless the user invoked the `skipLinks()` context function
471        // or maxCrawlingDepth would be exceeded.
472        if (!state.skipLinks) await this._handleLinks(crawlingContext);
473
474        // Save the `pageFunction`s result to the default dataset.
475        await this._handleResult(
476            request,
477            response,
478            pageFunctionResult as Dictionary,
479        );
480    }
481
482    private async _handleMaxResultsPerCrawl(autoscaledPool?: AutoscaledPool) {
483        if (
484            !this.input.maxResultsPerCrawl ||
485            this.pagesOutputted < this.input.maxResultsPerCrawl
486        )
487            return false;
488        if (!autoscaledPool) return false;
489        log.info(
490            `User set limit of ${this.input.maxResultsPerCrawl} results was reached. Finishing the crawl.`,
491        );
492        await autoscaledPool.abort();
493        return true;
494    }
495
496    private async _handleLinks({
497        request,
498        enqueueLinks,
499    }: PlaywrightCrawlingContext) {
500        if (!this.requestQueue) return;
501        const currentDepth = (request.userData![META_KEY] as RequestMetadata)
502            .depth;
503        const hasReachedMaxDepth =
504            this.input.maxCrawlingDepth &&
505            currentDepth >= this.input.maxCrawlingDepth;
506        if (hasReachedMaxDepth) {
507            log.debug(
508                `Request ${request.url} reached the maximum crawling depth of ${currentDepth}.`,
509            );
510            return;
511        }
512
513        const enqueueOptions: EnqueueLinksOptions = {
514            globs: this.input.globs,
515            pseudoUrls: this.input.pseudoUrls,
516            exclude: this.input.excludes,
517            transformRequestFunction: (requestOptions) => {
518                requestOptions.userData ??= {};
519                requestOptions.userData[META_KEY] = {
520                    parentRequestId: request.id || request.uniqueKey,
521                    depth: currentDepth + 1,
522                };
523
524                requestOptions.useExtendedUniqueKey = true;
525                requestOptions.keepUrlFragment = this.input.keepUrlFragments;
526                return requestOptions;
527            },
528        };
529
530        if (this.input.linkSelector) {
531            await enqueueLinks({
532                ...enqueueOptions,
533                selector: this.input.linkSelector,
534            });
535        }
536    }
537
538    private async _handleResult(
539        request: Request,
540        response?: Response,
541        pageFunctionResult?: Dictionary,
542        isError?: boolean,
543    ) {
544        const payload = tools.createDatasetPayload(
545            request,
546            response,
547            pageFunctionResult,
548            isError,
549        );
550        await this.dataset.pushData(payload);
551        this.pagesOutputted++;
552    }
553}

Puppeteer Scraper

apify/puppeteer-scraper

Crawls websites with the headless Chrome and Puppeteer library using a provided server-side Node.js code. This crawler is an alternative to apify/web-scraper that gives you finer control over the process. Supports both recursive crawling and list of URLs. Supports login to website.

Apify

9.6K

5.0

Cheerio Scraper

apify/cheerio-scraper

Crawls websites using raw HTTP requests, parses the HTML with the Cheerio library, and extracts data from the pages using a Node.js code. Supports both recursive crawling and lists of URLs. This actor is a high-performance alternative to apify/web-scraper for websites that do not require JavaScript.

Apify

10K

4.9

Web Scraper

apify/web-scraper

Crawls arbitrary websites using a web browser and extracts structured data from web pages using a provided JavaScript function. The Actor supports both recursive crawling and lists of URLs, and automatically manages concurrency for maximum performance.

Apify

97K

4.8

BeautifulSoup Scraper

apify/beautifulsoup-scraper

Crawls websites using raw HTTP requests. It parses the HTML with the BeautifulSoup library and extracts data from the pages using Python code. Supports both recursive crawling and lists of URLs. This Actor is a Python alternative to Cheerio Scraper.

Apify

901

4.2

Nodejs Runner

martin.forejt/nodejs-runner

This Actor allows you to quickly run arbitrary JavaScript code in a real Node.js environment, making it ideal for testing, debugging, or executing small scripts without setting up a local Node.js instance. The actor spawns a separate Node.js process to run the provided code and captures the logs.

Martin Forejt

5.0

Example Code Runner (Playwright)

apify/example-code-runner-playwright

Generic Actor to run code examples from the documentation via "Run on Apify" links.

Apify

1.6K

4.7

Example Puppeteer

apify/example-puppeteer

Example showing how to use headless Chromium with Puppeteer to open a web page, determine its dimensions, save a screenshot, and print the page to PDF. This actor must use images with Puppeteer (Node.js 8 + Puppeteer on Debian).

Apify

426

4.6

Vanilla JS Scraper

mstephen190/vanilla-js-scraper

Scrape the web using familiar JavaScript methods! Crawls websites using raw HTTP requests, parses the HTML with the JSDOM package, and extracts data from the pages using Node.js code. Supports both recursive crawling and lists of URLs. This actor is a non jQuery alternative to CheerioScraper.

Matthias Stephens

484

Website Checker Runner Playwright

lukaskrivka/website-checker-playwright

Checks the provided website using Playwright. This is a low level runner, most likely you want to use the high level master actor - https://apify.com/lukaskrivka/website-checker