Rename APIFY_API_TOKEN to APIFY_TOKEN (env variable at Apify platform is APIFY_TOKE)

Author: jirispilka

.env.example

@@ -1,3 +1,3 @@
-APIFY_API_TOKEN=
+APIFY_TOKEN=
 # ANTHROPIC_API_KEY is only required when you want to run examples/clientStdioChat.js
 ANTHROPIC_API_KEY=

README.md

@@ -83,12 +83,12 @@ The Actor runs in [**Standby mode**](https://docs.apify.com/platform/actors/runn
 Start server with default Actors. To use the Apify MCP Server with set of default Actors,
 send an HTTP GET request with your [Apify API token](https://console.apify.com/settings/integrations) to the following URL.
 ```
-https://mcp-server.apify.actor?token=<APIFY_API_TOKEN>
+https://actors-mcp-server.apify.actor?token=<APIFY_TOKEN>
 ```
 It is also possible to start MCP server with a different set of tools by providing a list of Actor names in the `actors` query parameter.
 Provide a comma-separated list of Actors in the `actors` query parameter:
 ```
-https://mcp-server.apify.actor?token=<APIFY_API_TOKEN>&actors=junglee/free-amazon-product-scraper,lukaskrivka/google-maps-with-contact-details
+https://actors-mcp-server.apify.actor?token=<APIFY_TOKEN>&actors=junglee/free-amazon-product-scraper,lukaskrivka/google-maps-with-contact-details
 ```
 Find list of all available Actors in the [Apify Store](https://apify.com/store).
 
@@ -104,9 +104,9 @@ In the client settings you need to provide server configuration:
     "mcpServers": {
         "apify": {
             "type": "sse",
-            "url": "https://mcp-server.apify.actor/sse",
+            "url": "https://actors-mcp-server.apify.actor/sse",
             "env": {
-                "APIFY_API_TOKEN": "your-apify-api-token"
+                "APIFY_TOKEN": "your-apify-token"
             }
         }
     }
@@ -116,7 +116,7 @@ Alternatively, you can use simple python [client_see.py](https://github.com/apif
 
 1. Initiate Server-Sent-Events (SSE) by sending a GET request to the following URL:
     ```
-    curl https://mcp-server.apify.actor/sse?token=<APIFY_API_TOKEN>
+    curl https://actors-mcp-server.apify.actor/sse?token=<APIFY_TOKEN>
     ```
     The server will respond with a `sessionId`, which you can use to send messages to the server:
     ```shell
@@ -126,7 +126,7 @@ Alternatively, you can use simple python [client_see.py](https://github.com/apif
 
 2. Send a message to the server by making a POST request with the `sessionId`:
     ```shell
-    curl -X POST "https://mcp-server.apify.actor?token=<APIFY_API_TOKEN>&session_id=a1b" -H "Content-Type: application/json" -d '{
+    curl -X POST "https://actors-mcp-server.apify.actor?token=<APIFY_TOKEN>&session_id=a1b" -H "Content-Type: application/json" -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
@@ -158,7 +158,7 @@ Alternatively, you can use simple python [client_see.py](https://github.com/apif
 - MacOS or Windows
 - The latest version of Claude Desktop must be installed (or another MCP client)
 - [Node.js](https://nodejs.org/en) (v18 or higher)
-- [Apify API Token](https://docs.apify.com/platform/integrations/api#api-token) (`APIFY_API_TOKEN`)
+- [Apify API Token](https://docs.apify.com/platform/integrations/api#api-token) (`APIFY_TOKEN`)
 
 ### Install
 
@@ -198,7 +198,7 @@ Configure Claude Desktop to recognize the MCP server.
           "/path/to/actor-mcp-server/dist/index.js"
         ]
         "env": {
-           "APIFY_API_TOKEN": "your-apify-api-token"
+           "APIFY_TOKEN": "your-apify-token"
         }
       }
     }
@@ -214,7 +214,7 @@ Configure Claude Desktop to recognize the MCP server.
           "lukaskrivka/google-maps-with-contact-details,apify/instagram-scraper"
         ]
         "env": {
-           "APIFY_API_TOKEN": "your-apify-api-token"
+           "APIFY_TOKEN": "your-apify-token"
         }
       }
     }
@@ -239,7 +239,7 @@ Configure Claude Desktop to recognize the MCP server.
 
 Create environment file `.env` with the following content:
 ```text
-APIFY_API_TOKEN=your-apify-api-token
+APIFY_TOKEN=your-apify-token
 # ANTHROPIC_API_KEY is only required when you want to run examples/clientStdioChat.js
 ANTHROPIC_API_KEY=your-anthropic-api-token
 ```
@@ -271,7 +271,7 @@ standard input/output (stdio):
 
 Create environment file `.env` with the following content:
 ```text
-APIFY_API_TOKEN=your-apify-api-token
+APIFY_TOKEN=your-apify-token
 # ANTHROPIC_API_KEY is only required when you want to run examples/clientStdioChat.js
 ANTHROPIC_API_KEY=your-anthropic-api-token
 ```
@@ -299,7 +299,7 @@ npm run build
 You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:
 
 ```bash
-npx @modelcontextprotocol/inspector node /path/to/actor-mcp-server/dist/index.js --env APIFY_API_TOKEN=your-apify-api-token
+npx @modelcontextprotocol/inspector node /path/to/actor-mcp-server/dist/index.js --env APIFY_TOKEN=your-apify-token
 ```
 
 Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.

src/actorDefinition.ts

@@ -12,11 +12,11 @@ import type { ActorDefinitionWithDesc, Tool } from './types';
  * @returns {Promise<ActorDefinitionWithDesc | null>} - The actor definition with description or null if not found.
  */
 async function fetchActorDefinition(actorFullName: string): Promise<ActorDefinitionWithDesc | null> {
-    if (!process.env.APIFY_API_TOKEN) {
-        log.error('APIFY_API_TOKEN is required but not set. Please set it as an environment variable');
+    if (!process.env.APIFY_TOKEN) {
+        log.error('APIFY_TOKEN is required but not set. Please set it as an environment variable');
         return null;
     }
-    const client = new ApifyClient({ token: process.env.APIFY_API_TOKEN });
+    const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
     const actorClient = client.actor(actorFullName);
 
     try {

src/const.ts

@@ -10,8 +10,8 @@ export const defaults = {
 };
 
 export const ACTOR_OUTPUT_MAX_CHARS_PER_ITEM = 1_000;
-export const ACTOR_OUTPUT_TRUNCATED_MESSAGE = `Output was truncated because it will not fit into context.` +
-    `There is no reason to call this tool again!`;
+export const ACTOR_OUTPUT_TRUNCATED_MESSAGE = `Output was truncated because it will not fit into context.`
+    + `There is no reason to call this tool again!`;
 
 export enum Routes {
     ROOT = '/',

src/examples/clientStdio.ts

@@ -2,7 +2,7 @@
 /**
  * Connect to the MCP server using stdio transport and call a tool.
  * This script uses a selected tool without LLM involvement.
- * You need to provide the path to the MCP server and `APIFY_API_TOKEN` in the `.env` file.
+ * You need to provide the path to the MCP server and `APIFY_TOKEN` in the `.env` file.
  * You can choose actors to run in the server, for example: `apify/rag-web-browser`.
  */
 
@@ -26,16 +26,16 @@ const NODE_PATH = execSync(process.platform === 'win32' ? 'where node' : 'which
 const TOOLS = 'apify/rag-web-browser,lukaskrivka/google-maps-with-contact-details';
 const SELECTED_TOOL = 'apify_rag-web-browser'; // We need to change / to _ in the tool name
 
-if (!process.env.APIFY_API_TOKEN) {
-    console.error('APIFY_API_TOKEN is required but not set in the environment variables.');
+if (!process.env.APIFY_TOKEN) {
+    console.error('APIFY_TOKEN is required but not set in the environment variables.');
     process.exit(1);
 }
 
 // Create server parameters for stdio connection
 const transport = new StdioClientTransport({
     command: NODE_PATH,
     args: [SERVER_PATH, '--actors', TOOLS],
-    env: { APIFY_API_TOKEN: process.env.APIFY_API_TOKEN || '' },
+    env: { APIFY_TOKEN: process.env.APIFY_TOKEN || '' },
 });
 
 // Create a new client instance

src/examples/clientStdioChat.ts

@@ -18,16 +18,16 @@
  */
 
 import { execSync } from 'child_process';
+import path from 'path';
 import * as readline from 'readline';
-import { fileURLToPath } from "url";
+import { fileURLToPath } from 'url';
 
 import { Anthropic } from '@anthropic-ai/sdk';
 import type { Message, ToolUseBlock, MessageParam } from '@anthropic-ai/sdk/resources/messages';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
 import dotenv from 'dotenv';
-import path from "path";
 
 const filename = fileURLToPath(import.meta.url);
 const dirname = path.dirname(filename);
@@ -79,7 +79,7 @@ class MCPClient {
         const transport = new StdioClientTransport({
             command: NODE_PATH,
             args: serverArgs,
-            env: { APIFY_API_TOKEN: process.env.APIFY_API_TOKEN || '' },
+            env: { APIFY_TOKEN: process.env.APIFY_TOKEN || '' },
         });
 
         await this.client.connect(transport);

src/examples/client_sse.py

@@ -20,7 +20,7 @@
 MCP_SERVER_URL = "https://mcp-server.apify.actor"
 ACTORS = "apify/rag-web-browser"
 
-HEADERS = {"Authorization": f"Bearer {os.getenv('APIFY_API_TOKEN')}"}
+HEADERS = {"Authorization": f"Bearer {os.getenv('APIFY_TOKEN')}"}
 
 async def run() -> None:
 

src/main.ts

@@ -23,8 +23,8 @@ const app = express();
 const mcpServer = new ApifyMcpServer();
 let transport: SSEServerTransport;
 
-const HELP_MESSAGE = `Connect to the server with GET request to ${HOST}/sse?token=YOUR-APIFY-API-TOKEN`
-    + ` and then send POST requests to ${HOST}/message?token=YOUR-APIFY-API-TOKEN.`;
+const HELP_MESSAGE = `Connect to the server with GET request to ${HOST}/sse?token=YOUR-APIFY-TOKEN`
+    + ` and then send POST requests to ${HOST}/message?token=YOUR-APIFY-TOKEN.`;
 
 /**
  * Process input parameters and update tools

src/server.ts

@@ -14,7 +14,7 @@ import {
     ACTOR_OUTPUT_TRUNCATED_MESSAGE,
     defaults,
     SERVER_NAME,
-    SERVER_VERSION
+    SERVER_VERSION,
 } from './const.js';
 import { log } from './logger.js';
 import type { Tool } from './types';
@@ -46,21 +46,21 @@ export class ApifyMcpServer {
     /**
      * Calls an Apify actor and retrieves the dataset items.
      *
-     * It requires the `APIFY_API_TOKEN` environment variable to be set.
+     * It requires the `APIFY_TOKEN` environment variable to be set.
      * If the `APIFY_IS_AT_HOME` the dataset items are pushed to the Apify dataset.
      *
      * @param {string} actorName - The name of the actor to call.
      * @param {unknown} input - The input to pass to the actor.
      * @returns {Promise<object[]>} - A promise that resolves to an array of dataset items.
-     * @throws {Error} - Throws an error if the `APIFY_API_TOKEN` is not set
+     * @throws {Error} - Throws an error if the `APIFY_TOKEN` is not set
      */
     public async callActorGetDataset(actorName: string, input: unknown): Promise<object[]> {
-        if (!process.env.APIFY_API_TOKEN) {
-            throw new Error('APIFY_API_TOKEN is required but not set. Please set it as an environment variable');
+        if (!process.env.APIFY_TOKEN) {
+            throw new Error('APIFY_TOKEN is required but not set. Please set it as an environment variable');
         }
         try {
             log.info(`Calling actor ${actorName} with input: ${JSON.stringify(input)}`);
-            const client = new ApifyClient({ token: process.env.APIFY_API_TOKEN });
+            const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
             const actorClient = client.actor(actorName);
 
             const results = await actorClient.call(input);
@@ -129,20 +129,20 @@ export class ApifyMcpServer {
 
             try {
                 const items = await this.callActorGetDataset(tool.actorName, args);
-                const content = items.map(item => {
-                    let text = JSON.stringify(item).slice(0, ACTOR_OUTPUT_MAX_CHARS_PER_ITEM);
+                const content = items.map((item) => {
+                    const text = JSON.stringify(item).slice(0, ACTOR_OUTPUT_MAX_CHARS_PER_ITEM);
                     return text.length === ACTOR_OUTPUT_MAX_CHARS_PER_ITEM
                         ? { type: 'text', text: `${text} ... ${ACTOR_OUTPUT_TRUNCATED_MESSAGE}` }
                         : { type: 'text', text };
                 });
-                return { content: content };
-
+                return { content };
             } catch (error) {
                 log.error(`Error calling tool: ${error}`);
                 throw new Error(`Error calling tool: ${error}`);
             }
         });
     }
+
     async connect(transport: Transport): Promise<void> {
         await this.server.connect(transport);
     }