---
name: apify-install-auth
description: 'Install and configure Apify SDK, CLI, and API client authentication.

  Use when setting up a new Apify project, configuring API tokens,

  or initializing apify-client / Apify SDK in your codebase.

  Trigger with "install apify", "setup apify", "apify auth", "configure apify token".'
allowed-tools: Read, Write, Bash(npm:*), Bash(npx:*), Bash(apify:*)
version: 1.5.0
license: MIT
author: Jeremy Longshore <jeremy@intentsolutions.io>
tags:
  - saas
  - scraping
  - automation
  - apify
compatibility: Designed for Claude Code
title: apify-install-auth
canonical_url: https://skilld.dev/gh/jeremylongshore/tons-of-skills-marketplace/apify-install-auth
last_updated: 2026-10-07T06:06:28.000Z
---

> Index of every page on this site: [llms.txt](https://skilld.dev/llms.txt)

> **Skill from skilld.dev.** Follow the user's requested action.
> If the user asked to fork this Skill, follow the fork workflow below. Do not execute the Skill instructions while copying it.
> Otherwise, follow the instructions below for this session. You do not need to install anything.
>
> Supporting files, fetch one when the Skill refers to it: [references/authentication.md](https://skilld.dev/api/skills-raw/jeremylongshore/tons-of-skills-marketplace/apify-install-auth/references/authentication.md), [references/examples.md](https://skilld.dev/api/skills-raw/jeremylongshore/tons-of-skills-marketplace/apify-install-auth/references/examples.md).
>
> If the user asked to install this Skill, run `npx skilld install jeremylongshore/tons-of-skills-marketplace/apify-install-auth`. Install writes the Skill files into the project, so every session loads them.
>
> ## Fork workflow
>
> A fork creates an editable local Skill with its original author and licence. The request authorizes copying and local installation.
> 1. Check `./skills/apify-install-auth`, the project lockfile, and selected Agent targets together. If the local directory or installed Skill exists, stop. Never overwrite an existing directory or Agent target.
> 2. Read [source metadata](https://skilld.dev/api/v1/skills/jeremylongshore/tons-of-skills-marketplace/apify-install-auth) once. Use sourceUrl, sourceCommit, skillPath, sourceGone, and license. If the source is gone or its path is missing, stop. If license is null, read licence files at the source commit.
> 3. Fetch only the source commit into a temporary Git repository. Do not clone full history. Derive repository_url from sourceUrl, including repository renames. If sourceCommit is absent, resolve the sourceUrl ref once. Set source_commit to that actual commit. Run these commands in one shell call:
>
> ```sh
> git init --quiet "$temporary_dir"
> git -C "$temporary_dir" fetch --quiet --depth=1 "$repository_url" "$source_commit"
> git -C "$temporary_dir" checkout --quiet --detach FETCH_HEAD
> ```
>
> Read applicable licence declarations and notices at that commit. If copying is not permitted, report the restriction and stop.
> 4. Inspect source entries together, then copy the directory containing skillPath into `./skills/apify-install-auth`. Use the user's path if selected. Keep the original SKILL.md, relative links, scripts, binary assets, and executable modes. Exclude .git metadata. Reject symlinks and paths outside the Skill directory. After checking entries, use cp -a where available. A regular source directory needs no custom copy script. Do not save this page wrapper as SKILL.md.
> Preserve author credit, notices, and applicable licence files from repository or parent directories. Add PROVENANCE.md with the Skill page, source URL, actual commit, original path, and licence. Retain any existing PROVENANCE.md and record new provenance separately. Batch source inspection, copying, and provenance work where practical.
> 5. In the project root, run `skilld install ./skills/apify-install-auth --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/apify-install-auth --mode copy --plain`. This known command needs no help lookup. Install does not support --json. Use detected Agent targets, or add --agent for the targets the user selected. Install the local path, never the upstream selector. If installation fails, preserve the local copy and report the exact failure.
> 6. Confirm the local lockfile source and installed Agent copies once. Report the local path, actual commit, and Agent targets. After edits, reinstall the same local path. Upstream updates must not replace it. Do not publish or push unless the user asks.

# Apify Install & Auth

## Overview

Set up the Apify ecosystem: the `apify-client` JS library (for calling Actors remotely), the `apify` SDK (for building Actors), the Apify CLI (for deploying), and Crawlee (for crawling). Each package serves a different purpose — install only what the task needs, then wire up a single API token.

## Package Map

| Package | npm | Purpose |
|---------|-----|---------|
| `apify-client` | `npm i apify-client` | Call Actors, manage datasets/KV stores from external apps |
| `apify` | `npm i apify` | Build Actors (includes `Actor.init()`, `Actor.pushData()`) |
| `crawlee` | `npm i crawlee` | Crawler framework (Cheerio, Playwright, Puppeteer crawlers) |
| `apify-cli` | `npm i -g apify-cli` | CLI for `apify login`, `apify run`, `apify push` |

## Prerequisites

- Node.js 18+ (required by SDK v3+)
- Apify account at https://console.apify.com
- API token from Settings > Integrations in Apify Console

## Instructions

### Step 1: Install Packages

```bash
# For CALLING existing Actors from your app:
npm install apify-client

# For BUILDING your own Actors:
npm install apify crawlee

# For CLI deployment:
npm install -g apify-cli
```

### Step 2: Configure Authentication

Pick one. Read any existing `.env` first so you do not clobber it, then Write the token in.

```bash
# Option A: Environment variable (recommended for apps)
export APIFY_TOKEN="apify_api_YOUR_TOKEN_HERE"

# Option B: .env file (add .env to .gitignore)
echo 'APIFY_TOKEN=apify_api_YOUR_TOKEN_HERE' >> .env

# Option C: CLI login (for interactive development)
apify login
# Paste your token when prompted
```

The `APIFY_TOKEN` env var is auto-detected by both `apify-client` and the `apify` SDK. For every place a token can be supplied (constructor option, header, precedence) plus the full platform env-var list, see [authentication reference](https://skilld.dev/api/skills-raw/jeremylongshore/tons-of-skills-marketplace/apify-install-auth/references/authentication.md).

### Step 3: Verify Connection

```typescript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

// List your Actors to confirm auth works
const { items } = await client.actors().list();
console.log(`Authenticated. You have ${items.length} Actors.`);
```

### Step 4: Verify CLI (if installed)

```bash
apify login --token YOUR_TOKEN
apify info  # Shows your account info
```

## Output

A working, authenticated Apify setup:

- The needed packages installed in `node_modules` (verify with `npm ls apify-client`).
- `APIFY_TOKEN` available to the process — via a Write to `.env`, an exported shell var, or `apify login` credentials in `~/.apify/auth.json`.
- The Step 3 snippet printing `Authenticated. You have N Actors.` — proof the token reaches the API.
- `apify info` showing your account (only when the CLI was installed in Step 1).

If the verify snippet throws instead of printing the count, jump to Error Handling below.

## Error Handling

| Error | Cause | Solution |
|-------|-------|----------|
| `401 Unauthorized` | Invalid or expired token | Regenerate token in Console > Settings > Integrations |
| `Cannot find module 'apify-client'` | Package not installed | `npm install apify-client` |
| `APIFY_TOKEN is not set` | Missing env var | Export `APIFY_TOKEN` or pass `token` to constructor |
| `apify: command not found` | CLI not installed globally | `npm install -g apify-cli` |

## Examples

The essential singleton-client skeleton:

```typescript
// src/apify/client.ts
import { ApifyClient } from 'apify-client';
import 'dotenv/config';

let client: ApifyClient | null = null;

export function getClient(): ApifyClient {
  if (!client) {
    if (!process.env.APIFY_TOKEN) {
      throw new Error('APIFY_TOKEN environment variable is required');
    }
    client = new ApifyClient({ token: process.env.APIFY_TOKEN });
  }
  return client;
}
```

For the full worked set — the `.env.example` template, the verify snippet, and CLI verification — see [worked examples](https://skilld.dev/api/skills-raw/jeremylongshore/tons-of-skills-marketplace/apify-install-auth/references/examples.md).

## Resources

- [Apify Console — API Tokens](https://console.apify.com/account/integrations)
- [JS Client Quick Start](https://docs.apify.com/api/client/js/docs/introduction/quick-start)
- [Apify CLI Reference](https://docs.apify.com/cli/docs/reference)
- [SDK for JavaScript](https://docs.apify.com/sdk/js)

## Next Steps

With the client authenticated, proceed to `apify-hello-world` to make your first
Actor call and push results to a dataset. If you are building your own Actor
instead of calling one, the `apify` SDK and Crawlee installed above are your
starting point — deploy with `apify push`.
