Make TypeScript SDK

A TypeScript SDK for interacting with the Make API. This SDK provides a type-safe way to interact with Make's API endpoints for managing scenarios, teams, data stores, and more.

Installation

Via NPM (Node.js)

npm install @makehq/sdk
Copy

Via JSR (Deno)

deno add jsr:@make/sdk
Copy

Basic Usage

import { Make } from '@makehq/sdk';

// Initialize the Make client
const make = new Make('your-api-key', 'eu2.make.com');

// Get user information
const user = await make.users.me();

// List scenarios
const scenarios = await make.scenarios.list(/* Team ID */);

// Work with data stores
const dataStore = await make.dataStores.get(/* DataStore ID */);
Copy

Initialize with retry configuration (optional):

const make = new Make('your-api-key', 'eu2.make.com', {
    retry: {
        onRateLimit: true,
        maxRetries: 3,
    },
});
Copy

Platform Endpoints

• Enums - Standardized lists (countries, regions, timezones)
• Blueprit - Blueprint management
• Connections - External service connections and authentication
• Credential Requests - Credential authorization requests and management
• Data Stores - Data storage within Make
• Data Store Records - Individual records within data stores
• Data Structures - Data schemas and formats
• Executions - Scenario execution history
• Folders - Scenario categorization
• Functions - Custom JavaScript functions for scenarios
• Hooks - Webhooks and mailhooks for external integrations
• Incomplete Executions - Failed or incomplete scenario runs
• Keys - API keys and secrets
• Organizations - Top-level account and billing management
• Scenarios - Scenario management
• Teams - Team management and collaboration
• Public Templates - Public template discovery and blueprint export (read-only)
• Users - Current user information and authentication

Custom Apps Development Endpoints

• SDK Apps - Create and manage custom Make applications
• SDK Modules - Building blocks for custom apps
• SDK Connections - Authentication for custom apps
• SDK Functions - Reusable code blocks within custom apps
• SDK RPCs - Remote procedure calls for custom apps
• SDK Webhooks - Webhook handling for custom apps

Features

• Full TypeScript support with type definitions
• Support for majority of Make API endpoints
• Built-in error handling and response typing
• Comprehensive test coverage
• Harness-agnostic tool definitions powering the Make MCP Server and the Make CLI

Configuration Options

The Make constructor accepts an optional third parameter with configuration options:

const make = new Make('your-api-key', 'eu2.make.com', {
    version: 2,
    headers: { 'X-Custom-Header': 'value' },
    retry: {
        onRateLimit: true,
        onServerError: true,
        maxRetries: 3,
        baseDelay: 1000,
        maxDelay: 30000,
        backoffMultiplier: 2,
    },
});
Copy

Available Options

Option	Type	Default	Description
version	number	2	API version to use
headers	Record<string, string>	{}	Custom headers to include in all requests
retry	RetryOptions	See below	Configuration for retry behavior

Retry Options

The SDK supports automatic retries with exponential backoff for handling rate limits and transient server errors.

Option	Type	Default	Description
onRateLimit	boolean	false	Enable retries for rate limit errors (HTTP 429)
onServerError	boolean	false	Enable retries for server errors (HTTP 5xx)
maxRetries	number	3	Maximum number of retry attempts
baseDelay	number	1000	Base delay in milliseconds for exponential backoff
maxDelay	number	30000	Maximum delay in milliseconds
backoffMultiplier	number	2	Multiplier for exponential backoff

The retry mechanism uses exponential backoff with jitter to prevent thundering herd problems. When a Retry-After header is present in the response, the SDK respects it (capped at maxDelay).

Tool Definitions

Every SDK endpoint is also described as a harness-agnostic tool definition - a self-contained record with a JSON Schema, examples, and an executor. The same definitions power:

• the official Make MCP Server,
• the official Make CLI,
• and any future consumer.

Import them directly via the ./tools subpath:

import { Make } from '@makehq/sdk';
import { MakeTools } from '@makehq/sdk/tools';

const make = new Make('your-api-key', 'eu2.make.com');

// List tools
const tools = MakeTools.map(tool => {
    return {
        name: tool.name,
        title: tool.title,
        description: tool.description,
        inputSchema: tool.inputSchema,
    };
});

// Execute a tool
const tool = MakeTools.find(tool => tool.name === 'scenarios_list');

try {
    await tool.execute(make, { teamId: 1 });
} catch (error) {
    // Handle error
}
Copy

See full example in the scripts/run-mcp-server.mjs file.

Tool Structure

Each tool is described as demonstrated in the following example:

{
    name: 'scenarios_list',
    title: 'List scenarios',
    description: 'List all scenarios for a team',
    category: 'scenarios',
    scope: 'scenarios:read',
    inputSchema: {
        type: 'object',
        properties: {
            teamId: { type: 'number', description: 'The team ID to filter scenarios by' },
        },
        required: ['teamId'],
    },
    execute: async (make: Make, args: { teamId: number }) => {
        return await make.scenarios.list(args.teamId);
    },
}
Copy

Tool Categories

All tools are organized into the following categories:

• connections
• credential-requests
• data-stores
• data-store-records
• data-structures
• enums
• executions
• folders
• functions
• hooks
• incomplete-executions
• keys
• organizations
• scenarios
• teams
• public-templates
• users
• sdk.apps
• sdk.connections
• sdk.functions
• sdk.modules
• sdk.rpcs
• sdk.webhooks

Tool Scopes

You can learn more about scopes in our documentation.

Project Structure

make-sdk/
├── src/                       # Source code
│   ├── endpoints/             # API endpoint implementations
│   │   ├── *.ts               # Endpoints
│   │   └── *.tools.ts         # Tool definitions (MCP / CLI / …)
│   ├── index.ts               # Main entry point
│   ├── make.ts                # Core Make client
│   ├── tools.ts               # Aggregated tool definitions (./tools export)
│   ├── types.ts               # Common type definitions
│   └── utils.ts               # Utility functions
├── test/                      # Test files
│   ├── mocks/                 # Test mocks
│   ├── *.spec.ts              # Unit tests
│   ├── *.integration.test.ts  # Integration tests
│   └── test.utils.ts          # Test utilities
├── dist/                      # Compiled output
└── docs/                      # Documentation
Copy

Testing

The project includes both unit tests and integration tests. To run the tests:

Unit Tests

npm test
Copy

Integration Tests

# Make sure to set up your .env file first
npm run test:integration
Copy

Environment Setup

Create a .env file in the root directory with the following variables:

MAKE_API_KEY="<your-api-key>"
MAKE_ZONE="<zone>"
MAKE_TEAM="<team-id>"
MAKE_ORGANIZATION="<organization-id>"
Copy

Please provide zone without https:// prefix (e.g. eu2.make.com).

Building

To build the project:

npm run build        # Builds both ESM and CJS versions
Copy

Documentation

API documentation can be generated using:

npm run build:docs
Copy