feat: Templates endpoint (public templates)

scripts/test-templates.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: join(__dirname, '..', '.env') });
+
+import { Make } from '../dist/index.js';
+
+if (!process.env.MAKE_API_KEY) {
+    console.error('Please provide MAKE_API_KEY environment variable.');
+    process.exit(1);
+}
+if (!process.env.MAKE_ZONE) {
+    console.error('Please provide MAKE_ZONE environment variable.');
+    process.exit(1);
+}
+
+const searchTerm = process.argv[2] ?? 'webhook';
+const usedApps = process.argv[3] ? process.argv[3].split(',').map(s => s.trim()).filter(Boolean) : undefined;
+
+const make = new Make(process.env.MAKE_API_KEY, process.env.MAKE_ZONE);
+
+const filterDesc = usedApps ? `"${searchTerm}" with apps [${usedApps.join(', ')}]` : `"${searchTerm}"`;
+console.log(`\n=== Searching public templates for ${filterDesc} ===\n`);
+const templates = await make.templates.list({ name: searchTerm, usedApps });
+
+console.log(`Found ${templates.length} template(s):`);
+templates.slice(0, 5).forEach(t => {
+    console.log(`  [${t.id}] ${t.name} — apps: ${t.usedApps.join(', ')} — usage: ${t.usage}`);
+});
+
+if (templates.length === 0) {
+    console.log('No templates found. Try a different search term.');
+    process.exit(0);
+}
+
+const first = templates[0];
+console.log(`\n=== Fetching blueprint for template [${first.id}] "${first.name}" (url: ${first.url}) ===\n`);
+const blueprint = await make.templates.getBlueprint(first.url);
+
+console.log('Language:', blueprint.language);
+console.log('Scheduling:', JSON.stringify(blueprint.scheduling));
+console.log('Controller name:', blueprint.controller?.name);
+console.log('Blueprint flow (modules):');
+const flow = blueprint.blueprint?.flow || [];
+flow.forEach((step, i) => {
+    console.log(`  ${i + 1}. ${step.module} (id ${step.id})`);
+});
+console.log(`\nFull blueprint size: ${JSON.stringify(blueprint).length} bytes`);

src/endpoints/templates.mcp.ts

@@ -0,0 +1,86 @@
+import type { Make } from '../make.js';
+
+export const tools = [
+    {
+        name: 'templates_list',
+        title: 'List public templates',
+        description:
+            'Search and list public (approved) templates available for anyone. Supports name-based search for template discovery. Results are sorted by usage by default.',
+        category: 'templates',
+        scope: 'templates:read',
+        annotations: {
+            readOnlyHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Search templates by name' },
+                usedApps: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter templates by apps used',
+                },
+                includeEn: {
+                    type: 'boolean',
+                    description: 'Whether to include English-language templates in results',
+                },
+            },
+        },
+        examples: [{ name: 'webhook' }],
+        execute: async (make: Make, args: { name?: string; usedApps?: string[]; includeEn?: boolean }) => {
+            return await make.templates.list({ ...args, cols: ['*'] });
+        },
+    },
+    {
+        name: 'templates_get',
+        title: 'Get public template',
+        description:
+            'Get details of a public template by its URL slug (e.g. "12289-add-webhook-data-to-a-google-sheet"). Use this for templates discovered via templates_list.',
+        category: 'templates',
+        scope: 'templates:read',
+        identifier: 'templateUrl',
+        annotations: {
+            readOnlyHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                templateUrl: {
+                    type: 'string',
+                    description: 'The URL slug of the template (e.g. "12289-add-webhook-data-to-a-google-sheet")',
+                },
+            },
+            required: ['templateUrl'],
+        },
+        examples: [{ templateUrl: '12289-add-webhook-data-to-a-google-sheet' }],
+        execute: async (make: Make, args: { templateUrl: string }) => {
+            return await make.templates.get(args.templateUrl, { cols: ['*'] });
+        },
+    },
+    {
+        name: 'templates_get-blueprint',
+        title: 'Get public template blueprint',
+        description:
+            'Get the full blueprint of a public template including scenario flow, controller configuration, scheduling, and metadata. Use this for templates discovered via templates_list.',
+        category: 'templates',
+        scope: 'templates:read',
+        identifier: 'templateUrl',
+        annotations: {
+            readOnlyHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                templateUrl: {
+                    type: 'string',
+                    description: 'The URL slug of the template (e.g. "12289-add-webhook-data-to-a-google-sheet")',
+                },
+            },
+            required: ['templateUrl'],
+        },
+        examples: [{ templateUrl: '12289-add-webhook-data-to-a-google-sheet' }],
+        execute: async (make: Make, args: { templateUrl: string }) => {
+            return await make.templates.getBlueprint(args.templateUrl);
+        },
+    },
+];

src/endpoints/templates.ts

@@ -0,0 +1,171 @@
+import type { FetchFunction, Pagination, PickColumns } from '../types.js';
+
+/**
+ * Represents a publicly available approved template in Make.
+ * Public templates can be discovered and used by all Make users.
+ */
+export type Template = {
+    /** Unique identifier of the public template */
+    id: number;
+    /** Name of the public template */
+    name: string;
+    /** Human-readable description of what the template does, or null if not set */
+    description: string | null;
+    /** URL slug identifying this public template */
+    url: string;
+    /** List of app identifiers used in the template */
+    usedApps: string[];
+    /** Number of times this template has been used */
+    usage: number;
+};
+
+/**
+ * Represents the blueprint (scenario definition) extracted from a template.
+ * Contains the full scenario configuration including flow, scheduling, and metadata.
+ */
+export type TemplateBlueprint = {
+    /** The scenario blueprint definition */
+    blueprint: Record<string, unknown>;
+    /** Controller configuration for the scenario */
+    controller: Record<string, unknown>;
+    /** Scheduling configuration for the scenario */
+    scheduling: Record<string, unknown>;
+    /** Language code for the template */
+    language: string;
+    /** Additional metadata for the template, or null if not set */
+    metadata: Record<string, unknown> | null;
+};
+
+/**
+ * Options for listing public approved templates.
+ * @template C Keys of the Template type to include in the response
+ */
+export type ListTemplatesOptions<C extends keyof Template = never> = {
+    /** Specific columns/fields to include in the response */
+    cols?: C[] | ['*'];
+    /** Pagination options */
+    pg?: Partial<Pagination<Template>>;
+    /** Search templates by name */
+    name?: string;
+    /** Filter templates by apps used */
+    usedApps?: string[];
+    /** Whether to include English-language templates in results */
+    includeEn?: boolean;
+};
+
+/**
+ * Options for getting a single public template.
+ * @template C Keys of the Template type to include in the response
+ */
+export type GetTemplateOptions<C extends keyof Template = never> = {
+    /** Specific columns/fields to include in the response */
+    cols?: C[] | ['*'];
+};
+
+/**
+ * Response format for listing public templates.
+ */
+type ListTemplatesResponse<C extends keyof Template = never> = {
+    /** List of public templates matching the query */
+    templatesPublic: PickColumns<Template, C>[];
+    /** Pagination information */
+    pg: Pagination<Template>;
+};
+
+/**
+ * Response format for getting a single public template.
+ */
+type GetTemplateResponse<C extends keyof Template = never> = {
+    /** The requested public template */
+    templatePublic: PickColumns<Template, C>;
+};
+
+/**
+ * Class providing methods for working with public Make templates.
+ * Public templates are approved scenario configurations that can be
+ * discovered and used by any Make user.
+ */
+export class Templates {
+    readonly #fetch: FetchFunction;
+
+    /**
+     * Create a new Templates instance.
+     * @param fetch Function for making API requests
+     */
+    constructor(fetch: FetchFunction) {
+        this.#fetch = fetch;
+    }
+
+    /**
+     * List public (approved) templates available for anyone.
+     * Supports name-based search for template discovery.
+     * Results are sorted by usage in descending order by default.
+     * @param options Optional parameters for searching, filtering, and pagination
+     * @returns Promise with the list of public templates
+     *
+     * @example
+     * ```typescript
+     * // Search public templates by name
+     * const templates = await make.templates.list({ name: 'webhook' });
+     *
+     * // Filter by apps used
+     * const gmailTemplates = await make.templates.list({ usedApps: ['gmail'] });
+     * ```
+     */
+    async list<C extends keyof Template = never>(
+        options: ListTemplatesOptions<C> = {},
+    ): Promise<PickColumns<Template, C>[]> {
+        return (
+            await this.#fetch<ListTemplatesResponse<C>>('/templates/public', {
+                query: {
+                    name: options.name,
+                    usedApps: options.usedApps,
+                    includeEn: options.includeEn,
+                    cols: options.cols,
+                    pg: options.pg,
+                },
+            })
+        ).templatesPublic;
+    }
+
+    /**
+     * Get a single public template by its URL slug.
+     * Use this for templates discovered via {@link list}.
+     * @param templateUrl The URL slug of the template (e.g. "12289-add-webhook-data-to-a-google-sheet")
+     * @param options Optional parameters for field selection
+     * @returns Promise with the public template details
+     *
+     * @example
+     * ```typescript
+     * const template = await make.templates.get('12289-add-webhook-data-to-a-google-sheet');
+     * ```
+     */
+    async get<C extends keyof Template = never>(
+        templateUrl: string,
+        options: GetTemplateOptions<C> = {},
+    ): Promise<PickColumns<Template, C>> {
+        return (
+            await this.#fetch<GetTemplateResponse<C>>(`/templates/public/${templateUrl}`, {
+                query: {
+                    cols: options.cols,
+                },
+            })
+        ).templatePublic;
+    }
+
+    /**
+     * Get the blueprint (scenario definition) for a public template.
+     * The full response object is returned directly since the API returns a flat
+     * structure rather than wrapping the blueprint in a named property.
+     * @param templateUrl The URL slug of the template (e.g. "12289-add-webhook-data-to-a-google-sheet")
+     * @returns Promise with the full blueprint response
+     *
+     * @example
+     * ```typescript
+     * const blueprint = await make.templates.getBlueprint('12289-add-webhook-data-to-a-google-sheet');
+     * ```
+     */
+    async getBlueprint(templateUrl: string): Promise<TemplateBlueprint> {
+        return await this.#fetch<TemplateBlueprint>(`/templates/public/${templateUrl}/blueprint`);
+    }
+}

src/index.ts

@@ -166,4 +166,11 @@ export type {
     UpdateSDKWebhookBody,
 } from './endpoints/sdk/webhooks.js';
 export type { Team, Teams, CreateTeamBody, ListTeamsOptions, GetTeamOptions } from './endpoints/teams.js';
+export type {
+    Template,
+    TemplateBlueprint,
+    Templates,
+    ListTemplatesOptions,
+    GetTemplateOptions,
+} from './endpoints/templates.js';
 export type { User, Users } from './endpoints/users.js';

src/make.ts

@@ -15,6 +15,7 @@ import { Devices } from './endpoints/devices.js';
 import { Functions } from './endpoints/functions.js';
 import { Organizations } from './endpoints/organizations.js';
 import { Enums } from './endpoints/enums.js';
+import { Templates } from './endpoints/templates.js';
 import { SDKApps } from './endpoints/sdk/apps.js';
 import { SDKModules } from './endpoints/sdk/modules.js';
 import { SDKConnections } from './endpoints/sdk/connections.js';
@@ -163,6 +164,13 @@ export class Make {
      */
     public readonly enums: Enums;
 
+    /**
+     * Access to template-related endpoints
+     * Templates allow users to create reusable scenario configurations
+     * that can be shared, published, and discovered by other users
+     */
+    public readonly templates: Templates;
+
     /**
      * Access to SDK-related endpoints
      */
@@ -248,6 +256,7 @@ export class Make {
         this.organizations = new Organizations(this.fetch.bind(this));
         this.enums = new Enums(this.fetch.bind(this));
         this.credentialRequests = new CredentialRequests(this.fetch.bind(this));
+        this.templates = new Templates(this.fetch.bind(this));
         this.sdk = {
             apps: new SDKApps(this.fetch.bind(this)),
             modules: new SDKModules(this.fetch.bind(this)),

src/mcp.ts

@@ -25,6 +25,7 @@ import { tools as FoldersTools } from './endpoints/folders.mcp.js';
 import { tools as IncompleteExecutionsTools } from './endpoints/incomplete-executions.mcp.js';
 import { tools as DataStructuresTools } from './endpoints/data-structures.mcp.js';
 import { tools as EnumsTools } from './endpoints/enums.mcp.js';
+import { tools as TemplatesTools } from './endpoints/templates.mcp.js';
 
 /**
  * JSON Schema definition for input parameters.
@@ -149,4 +150,5 @@ export const MakeMCPTools = [
     ...OrganizationsTools,
     ...UsersTools,
     ...EnumsTools,
+    ...TemplatesTools,
 ] as MakeMCPTool[];