Using Apify and AgentKit by ScaleKit Together

What's the idea?

Pattern 1: Apify Actor with per-user OAuth via AgentKit

Prerequisites

• A ScaleKit account at app.scalekit.com with API credentials
• Apify CLI: npm install -g @apify/cli
• Node.js 18+

Step 1: Set up Connectors in the ScaleKit Dashboard

1. Search for YouTube, click Create
2. Copy the Redirect URI from the panel, paste it into your Google Cloud OAuth client under Authorized redirect URIs
3. Enable YouTube Data API v3 in Google Cloud Console
4. Add test users to your OAuth consent screen
5. Enter your Client ID + Client Secret in ScaleKit, select scopes (youtube.readonly at minimum), click Save
6. Note the connection name (e.g., youtube)

1. Search for Notion, click Create
2. Enter Client ID and Client Secret from your Notion integration
3. ScaleKit pre-configures the redirect URI and scopes - click Save
4. Note the connection name (e.g., notion)

Step 2: Create the Apify Actor Project

apify create notion-youtube-agent -t project_empty
cd notion-youtube-agent
npm install @scalekit-sdk/node openai apify

Step 3: Set Environment Variables

SCALEKIT_ENV_URL=https://your-env.scalekit.cloud
SCALEKIT_CLIENT_ID=skc_...
SCALEKIT_CLIENT_SECRET=your-secret

Step 4: Initialize ScaleKit and Define Identifiers

import { Actor } from 'apify';
import ScalekitClient from '@scalekit-sdk/node';

await Actor.init();

const { userId } = Actor.getEnv();
const scalekit = new ScalekitClient(
  process.env.SCALEKIT_ENV_URL,
  process.env.SCALEKIT_CLIENT_ID,
  process.env.SCALEKIT_CLIENT_SECRET
);

// Per-user: each Apify account connects their own Notion workspace
const notionIdentifier = userId;

// Shared: one YouTube OAuth session used by all runs
const youtubeIdentifier = 'shared-youtube'; // hardcoded, not an input field

Step 5: Handle the OAuth Flow with a Magic Link

// src/notionAuth.js
import { Actor } from 'apify';

const ACTIVE = 1;

export async function ensureNotionConnected(scalekitActions, identifier, { connectionName }) {
  const account = await scalekitActions.getConnectedAccount({ identifier, connectionName });

  if (account?.status === ACTIVE) return; // already authorized, proceed

  // Generate the magic link and pause the Actor
  const { link: magicLink } = await scalekitActions.getAuthorizationURL({
    identifier,
    connectionName,
  });

  // Write the auth URL to Actor output so the user can click it
  await Actor.setValue('OUTPUT', {
    status: 'AWAITING__AUTH',
    magicLink,
    message: 'Open the magicLink to authorize Notion, then re-run the Actor.',
  });

  // Poll until the user completes the flow
  await pollUntilAuthorized(scalekitActions, identifier, connectionName);
}

Step 6: Fetch Tokens and Call APIs

// src/notionTools.js
const token = await scalekitActions.getToken({ identifier, connectionName: 'notion' });

const response = await fetch('https://api.notion.com/v1/search', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token.accessToken}`,
    'Notion-Version': '2022-06-28',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ query: searchTerm }),
});

Step 7: Build the Agentic Loop

// src/agent.js
import { notionTools } from './notionTools.js';
import { youtubeTools } from './youtubeTools.js';

const tools = [...notionTools, ...youtubeTools];

// Standard OpenAI tool-calling loop
while (true) {
  const response = await llm.chat({ messages, tools });
  if (response.finish_reason === 'stop') break;

  const toolResults = await Promise.all(
    response.tool_calls.map(call => executeTool(call, scalekitActions))
  );
  messages.push(...toolResults);
}

Step 8: Deploy to Apify

apify push

• SCALEKIT_ENV_URL
• SCALEKIT_CLIENT_ID
• SCALEKIT_CLIENT_SECRET
• Optionally NOTION_DEFAULT_PARENT_PAGE_ID or NOTION_DEFAULT_DATABASE_ID

Pattern 2: Use the Apify MCP Connector Inside an AgentKit Agent

Project Structure (from the example repo)

.actor/
  actor.json          # Apify actor metadata
  input_schema.json   # Apify Store UI form
  output_schema.json  # Actor output for web view + dataset
  pay_per_event.json  # Monetisation event definitions
src/
  main.js             # Actor entry point - auth + agent
  agent.js            # Agentic loop (tools + LLM)
  llm.js              # LLM abstraction (OpenAI-compatible)
  notionTools.js      # Notion tool definitions + Scalekit executor
  notionAuth.js       # Magic link + polling auth flow
  youtubeTools.js     # YouTube API calls via Scalekit
  youtubeAuth.js      # YouTube magic link + polling auth flow

Key Design Principles

• Operator credentials vs. user tokens - Your SCALEKIT_CLIENT_ID/SECRET are operator-level (go in env vars, never in input). Individual users' OAuth tokens are stored by ScaleKit keyed by identifier.
• Apify userId as the identifier - Using Actor.getEnv().userId means tokens persist across runs automatically per Apify account, with no user-managed input fields.
• Shared vs. per-user connectors - Some services (e.g., a shared YouTube research account) use a hardcoded identifier; others (Notion, Gmail) use the per-user userId. Make this decision per connector.
• Magic link polling - Because Actors run headlessly, the auth handoff works by writing a link to OUTPUT and polling ScaleKit until the connected account becomes active.