Index of every page on this site: llms.txt
All skills
Run it yourself

Production-ready patterns for Apify SDK and apify-client in TypeScript. Use when building Actors with Crawlee, managing datasets/KV stores, or implementing robust client wrappers with retry and validation. Trigger with "apify SDK patterns", "apify best practices", "apify client wrapper", "crawlee patterns", "idiomatic apify".

Use this Skill: https://skilld.dev/gh/jeremylongshore/tons-of-skills-marketplace/apify-sdk-patterns

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈87 tokens for metadata: the name and description. ≈1.3k when used: this file. ≈3.1k more on demand in 2 files.

Description uses 4.3% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈348 characters, or 4.3%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Apify SDK Patterns

Overview

Production patterns for both the apify SDK (building Actors) and apify-client (calling Actors remotely). Covers Crawlee crawler selection, data storage, proxy configuration, and typed client wrappers. This skill gives you the essential skeletons inline; the full eight-pattern catalog and two worked scenarios live in references/ for progressive drill-down.

Prerequisites

  • Install what you need: apify-client for calling Actors remotely, or apify + crawlee for building Actors. Both can coexist in one project.
  • Set APIFY_TOKEN in the environment — read it via process.env.APIFY_TOKEN, never hard-code it. This is the only credential these patterns require (Apify uses a personal API token, not OAuth).
  • TypeScript is recommended; every snippet here is typed and runs under ts-node or a compiled build.

Instructions

Use the two skeletons below to start, then reach into the reference catalog for the pattern that matches your task.

Pattern 1: Typed Client Singleton

Create one lazily-initialized, token-validated ApifyClient and reuse it everywhere. A resetClient() hook keeps it testable.

// src/apify/client.ts
import { ApifyClient } from 'apify-client';

let instance: ApifyClient | null = null;

export function getApifyClient(): ApifyClient {
  if (!instance) {
    const token = process.env.APIFY_TOKEN;
    if (!token) throw new Error('APIFY_TOKEN is required');
    instance = new ApifyClient({ token });
  }
  return instance;
}

// Reset for testing
export function resetClient(): void {
  instance = null;
}

Pattern 2: Crawlee Crawler Selection

Choose the crawler that matches the page, not the other way around:

import { CheerioCrawler, PlaywrightCrawler, PuppeteerCrawler } from 'crawlee';

// CHEERIO — Fast, lightweight, no JavaScript rendering
// Use for: static HTML, server-rendered pages, APIs
// PLAYWRIGHT — Full browser, all engines, modern API
// Use for: SPAs, JavaScript-heavy pages, complex interactions
// PUPPETEER — Chromium-only browser automation
// Use for: when you need Chromium specifically or legacy Puppeteer code

Patterns 3–8: Full catalog

The remaining six patterns are moved verbatim into patterns.md so this file stays scannable. Pick the one you need:

  • Pattern 3 — Actor lifecycle with error handling: Actor.main() wrapping input validation, conditional proxy, and a failedRequestHandler.
  • Pattern 4 — Dataset operations: push from inside an Actor; list/create/download from an external app.
  • Pattern 5 — Key-value store operations: JSON config and binary artifacts by content type.
  • Pattern 6 — Proxy configuration: datacenter vs residential vs SERP tiers.
  • Pattern 7 — Router for multi-page Actors: labeled listing/detail handlers.
  • Pattern 8 — Safe result wrapper: discriminated-union Result<T> around remote calls.

See patterns.md for the complete code of all six.

Output

Applying these patterns yields:

  • A single reusable ApifyClient instance with fail-fast token validation.
  • Actors that store structured records in the default dataset (downloadable as CSV/JSON) and named config/artifacts in key-value stores.
  • Remote Actor calls that resolve to a typed Result<T> — callers branch on error instead of catching exceptions.
  • Failed requests captured as { url, error, '#isFailed': true } rows rather than aborting the crawl.

Error Handling

Pattern Use Case Benefit
Actor.main() Actor entry point Auto init/exit + error reporting
failedRequestHandler Per-request failures Log failures without stopping crawl
Safe wrapper External calls Prevents uncaught exceptions
Router Multi-page scrapes Clean separation of page types
Proxy rotation Anti-bot sites Higher success rate

Examples

Two runnable end-to-end scenarios live in examples.md:

  • Example A — Call a remote Actor safely from an app: composes the client singleton (Pattern 1) with the safe result wrapper (Pattern 8) to run apify/web-scraper and read its dataset without ever throwing.
  • Example B — A two-tier product scraper Actor: composes crawler selection (Pattern 2), the router (Pattern 7), and dataset writes (Pattern 4) into a listing → detail → structured-record flow.

Resources

Next Steps

Apply these patterns in apify-core-workflow-a for a complete build-and-deploy web scraping workflow, or pair them with apify-common-errors when hardening an Actor for production.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning2mo3 checks · Risk SAFE
  • Gen Agent Trust Hub2mo

    The skill provides production-ready TypeScript patterns for Apify and Crawlee, emphasizing secure handling of API tokens via environment variables. It includes robust error handling and safe execution wrappers. The patterns involve ingesting untrusted web data, which is an inherent part of scraping functionality, but no malicious intent or vulnerabilities beyond the expected surface were found.

  • Socket2mo

    No alerts

  • Snyk2mo

    Risk: MEDIUM · 1 issue

Signed by skilld at 820dfc8. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 20 hours ago.

Activeupdated 4 months ago
What it can do
Reads files Edits files
version
1.5.0
author
Jeremy Longshore <jeremy@intentsolutions.io>
tags
[
  "saas",
  "scraping",
  "automation",
  "apify"
]
All 3 allowed tools
ReadWriteEdit
Other metadata
compatibility
Designed for Claude Code

README badge

README badge for jeremylongshore/tons-of-skills-marketplace/apify-sdk-patterns