From df34285f62d80cf0e2b5960fe3095d5a99d87ec1 Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Thu, 16 Apr 2026 17:12:23 +0200
Subject: [PATCH 01/17] test: add mock data files for templates endpoint

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 test/mocks/templates/blueprint.json   | 34 +++++++++++++++++++++++++++
 test/mocks/templates/get.json         | 18 ++++++++++++++
 test/mocks/templates/list-public.json | 26 ++++++++++++++++++++
 test/mocks/templates/list.json        | 26 ++++++++++++++++++++
 4 files changed, 104 insertions(+)
 create mode 100644 test/mocks/templates/blueprint.json
 create mode 100644 test/mocks/templates/get.json
 create mode 100644 test/mocks/templates/list-public.json
 create mode 100644 test/mocks/templates/list.json

diff --git a/test/mocks/templates/blueprint.json b/test/mocks/templates/blueprint.json
new file mode 100644
index 0000000..bac9ad4
--- /dev/null
+++ b/test/mocks/templates/blueprint.json
@@ -0,0 +1,34 @@
+{
+    "blueprint": {
+        "name": "My Private Template",
+        "flow": [
+            {
+                "id": 1,
+                "module": "http:ActionSendData",
+                "version": 3,
+                "parameters": {},
+                "mapper": {
+                    "url": "https://example.com",
+                    "method": "get"
+                },
+                "metadata": {
+                    "expect": []
+                }
+            }
+        ],
+        "metadata": {
+            "version": 1
+        }
+    },
+    "controller": {
+        "name": "My Private Template",
+        "modules": {},
+        "idSequence": 2
+    },
+    "scheduling": {
+        "type": "indefinitely",
+        "interval": 900
+    },
+    "language": "en",
+    "metadata": null
+}
diff --git a/test/mocks/templates/get.json b/test/mocks/templates/get.json
new file mode 100644
index 0000000..c555d83
--- /dev/null
+++ b/test/mocks/templates/get.json
@@ -0,0 +1,18 @@
+{
+    "template": {
+        "id": 61,
+        "name": "My Private Template",
+        "teamId": 1,
+        "description": "A template for testing",
+        "usedApps": ["http", "json"],
+        "public": false,
+        "published": null,
+        "approved": null,
+        "approvedId": null,
+        "requestedApproval": false,
+        "publishedId": null,
+        "publicUrl": null,
+        "approvedName": null,
+        "publishedName": null
+    }
+}
diff --git a/test/mocks/templates/list-public.json b/test/mocks/templates/list-public.json
new file mode 100644
index 0000000..bef7656
--- /dev/null
+++ b/test/mocks/templates/list-public.json
@@ -0,0 +1,26 @@
+{
+    "templatesPublic": [
+        {
+            "id": 13,
+            "name": "Http template example",
+            "description": null,
+            "url": "13-http-template-example",
+            "usedApps": ["http"],
+            "usage": 321
+        },
+        {
+            "id": 17,
+            "name": "Webhook to Email",
+            "description": "Send email when webhook is triggered",
+            "url": "17-webhook-to-email",
+            "usedApps": ["gateway", "gmail"],
+            "usage": 52
+        }
+    ],
+    "pg": {
+        "sortBy": "usage",
+        "limit": 100,
+        "sortDir": "desc",
+        "offset": 0
+    }
+}
diff --git a/test/mocks/templates/list.json b/test/mocks/templates/list.json
new file mode 100644
index 0000000..ad020b5
--- /dev/null
+++ b/test/mocks/templates/list.json
@@ -0,0 +1,26 @@
+{
+    "templates": [
+        {
+            "id": 61,
+            "name": "My Private Template",
+            "teamId": 1,
+            "description": "A template for testing",
+            "usedApps": ["http", "json"],
+            "public": false,
+            "published": null,
+            "approved": null,
+            "approvedId": null,
+            "requestedApproval": false,
+            "publishedId": null,
+            "publicUrl": null,
+            "approvedName": null,
+            "publishedName": null
+        }
+    ],
+    "pg": {
+        "sortBy": "name",
+        "limit": 10,
+        "sortDir": "asc",
+        "offset": 0
+    }
+}

From 48602c556e24d9f34d54463d1ee3e3bc5c69ec5c Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Thu, 16 Apr 2026 17:15:45 +0200
Subject: [PATCH 02/17] feat: add Templates endpoint class and unit tests

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/endpoints/templates.ts | 267 +++++++++++++++++++++++++++++++++++++
 test/templates.spec.ts     |  45 +++++++
 2 files changed, 312 insertions(+)
 create mode 100644 src/endpoints/templates.ts
 create mode 100644 test/templates.spec.ts

diff --git a/src/endpoints/templates.ts b/src/endpoints/templates.ts
new file mode 100644
index 0000000..40df1bc
--- /dev/null
+++ b/src/endpoints/templates.ts
@@ -0,0 +1,267 @@
+import type { FetchFunction, Pagination, PickColumns } from '../types.js';
+
+/**
+ * Represents a private team-scoped template in Make.
+ * Templates allow users to create reusable scenario configurations
+ * that can optionally be shared publicly or submitted for approval.
+ */
+export type Template = {
+    /** Unique identifier of the template */
+    id: number;
+    /** Name of the template */
+    name: string;
+    /** ID of the team that owns the template */
+    teamId: number;
+    /** Human-readable description of what the template does, or null if not set */
+    description: string | null;
+    /** List of app identifiers used in the template */
+    usedApps: string[];
+    /** Whether the template has been made publicly visible */
+    public: boolean;
+    /** ISO timestamp when the template was published, or null if not published */
+    published: string | null;
+    /** ISO timestamp when the template was approved, or null if not approved */
+    approved: string | null;
+    /** ID of the approving user, or null if not approved */
+    approvedId: number | null;
+    /** Whether approval has been requested for the template, or null if not applicable */
+    requestedApproval: boolean | null;
+    /** ID of the publishing user, or null if not published */
+    publishedId: number | null;
+    /** Public URL slug of the template, or null if not published */
+    publicUrl: string | null;
+    /** Name of the approving user, or null if not approved */
+    approvedName: string | null;
+    /** Name of the publishing user, or null if not published */
+    publishedName: string | null;
+};
+
+/**
+ * Represents a publicly available approved template in Make.
+ * Public templates can be discovered and used by all Make users.
+ */
+export type TemplatePublic = {
+    /** 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 private team 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>>;
+    /** Filter templates by team ID */
+    teamId?: number;
+    /** Filter by whether the template is public */
+    public?: boolean;
+    /** Filter templates by apps used */
+    usedApps?: string[];
+};
+
+/**
+ * Options for listing public approved templates.
+ * @template C Keys of the TemplatePublic type to include in the response
+ */
+export type ListTemplatesPublicOptions<C extends keyof TemplatePublic = never> = {
+    /** Specific columns/fields to include in the response */
+    cols?: C[] | ['*'];
+    /** Pagination options */
+    pg?: Partial<Pagination<TemplatePublic>>;
+    /** 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 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[] | ['*'];
+};
+
+/**
+ * Options for getting a template blueprint.
+ */
+export type GetTemplateBlueprintOptions = {
+    /** Whether to retrieve the blueprint for immediate use in a new scenario */
+    forUse?: boolean;
+    /** ID of the public template to retrieve the blueprint for */
+    templatePublicId?: number;
+};
+
+/**
+ * Response format for listing private templates.
+ */
+type ListTemplatesResponse<C extends keyof Template = never> = {
+    /** List of templates matching the query */
+    templates: PickColumns<Template, C>[];
+    /** Pagination information */
+    pg: Pagination<Template>;
+};
+
+/**
+ * Response format for listing public templates.
+ */
+type ListTemplatesPublicResponse<C extends keyof TemplatePublic = never> = {
+    /** List of public templates matching the query */
+    templatesPublic: PickColumns<TemplatePublic, C>[];
+    /** Pagination information */
+    pg: Pagination<TemplatePublic>;
+};
+
+/**
+ * Response format for getting a single template.
+ */
+type GetTemplateResponse<C extends keyof Template = never> = {
+    /** The requested template */
+    template: PickColumns<Template, C>;
+};
+
+/**
+ * Class providing methods for working with Make templates.
+ * Templates allow users to create reusable scenario configurations
+ * that can be shared, published, and discovered by other users.
+ */
+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 private team-scoped templates.
+     * @param options Optional parameters for filtering and pagination
+     * @returns Promise with the list of templates
+     *
+     * @example
+     * ```typescript
+     * // List all templates for team 1
+     * const templates = await make.templates.list({ teamId: 1 });
+     * ```
+     */
+    async list<C extends keyof Template = never>(options: ListTemplatesOptions<C> = {}): Promise<PickColumns<Template, C>[]> {
+        const { teamId, public: isPublic, usedApps, cols, pg } = options;
+        return (
+            await this.#fetch<ListTemplatesResponse<C>>('/templates', {
+                query: {
+                    teamId,
+                    public: isPublic,
+                    usedApps,
+                    cols,
+                    pg,
+                },
+            })
+        ).templates;
+    }
+
+    /**
+     * List publicly available approved templates.
+     * @param options Optional parameters for filtering and pagination
+     * @returns Promise with the list of public templates
+     *
+     * @example
+     * ```typescript
+     * // Search public templates by name
+     * const templates = await make.templates.listPublic({ name: 'Http' });
+     * ```
+     */
+    async listPublic<C extends keyof TemplatePublic = never>(options: ListTemplatesPublicOptions<C> = {}): Promise<PickColumns<TemplatePublic, C>[]> {
+        const { name, usedApps, includeEn, cols, pg } = options;
+        return (
+            await this.#fetch<ListTemplatesPublicResponse<C>>('/templates/public', {
+                query: {
+                    name,
+                    usedApps,
+                    includeEn,
+                    cols,
+                    pg,
+                },
+            })
+        ).templatesPublic;
+    }
+
+    /**
+     * Get a single template by ID.
+     * @param templateId The template ID to retrieve
+     * @param options Optional parameters for field selection
+     * @returns Promise with the template details
+     *
+     * @example
+     * ```typescript
+     * const template = await make.templates.get(61);
+     * ```
+     */
+    async get<C extends keyof Template = never>(templateId: number, options: GetTemplateOptions<C> = {}): Promise<PickColumns<Template, C>> {
+        return (
+            await this.#fetch<GetTemplateResponse<C>>(`/templates/${templateId}`, {
+                query: {
+                    cols: options.cols,
+                },
+            })
+        ).template;
+    }
+
+    /**
+     * Get the blueprint (scenario definition) for a 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 templateId The template ID to retrieve the blueprint for
+     * @param options Optional parameters for blueprint retrieval
+     * @returns Promise with the full blueprint response
+     *
+     * @example
+     * ```typescript
+     * // Get blueprint for immediate use
+     * const blueprint = await make.templates.getBlueprint(61, { forUse: true });
+     * ```
+     */
+    async getBlueprint(templateId: number, options: GetTemplateBlueprintOptions = {}): Promise<TemplateBlueprint> {
+        return await this.#fetch<TemplateBlueprint>(`/templates/${templateId}/blueprint`, {
+            query: {
+                forUse: options.forUse,
+                templatePublicId: options.templatePublicId,
+            },
+        });
+    }
+}
diff --git a/test/templates.spec.ts b/test/templates.spec.ts
new file mode 100644
index 0000000..30581b8
--- /dev/null
+++ b/test/templates.spec.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from '@jest/globals';
+import { Make } from '../src/make.js';
+import { mockFetch } from './test.utils.js';
+
+import * as listMock from './mocks/templates/list.json';
+import * as listPublicMock from './mocks/templates/list-public.json';
+import * as getMock from './mocks/templates/get.json';
+import * as blueprintMock from './mocks/templates/blueprint.json';
+
+const MAKE_API_KEY = 'api-key';
+const MAKE_ZONE = 'make.local';
+
+describe('Endpoints: Templates', () => {
+    const make = new Make(MAKE_API_KEY, MAKE_ZONE);
+
+    it('Should list templates', async () => {
+        mockFetch('GET https://make.local/api/v2/templates?teamId=1', listMock);
+        const result = await make.templates.list({ teamId: 1 });
+        expect(result).toStrictEqual(listMock.templates);
+    });
+
+    it('Should list public templates with name search', async () => {
+        mockFetch('GET https://make.local/api/v2/templates/public?name=Http', listPublicMock);
+        const result = await make.templates.listPublic({ name: 'Http' });
+        expect(result).toStrictEqual(listPublicMock.templatesPublic);
+    });
+
+    it('Should get template by ID', async () => {
+        mockFetch('GET https://make.local/api/v2/templates/61', getMock);
+        const result = await make.templates.get(61);
+        expect(result).toStrictEqual(getMock.template);
+    });
+
+    it('Should get template blueprint', async () => {
+        mockFetch('GET https://make.local/api/v2/templates/61/blueprint', blueprintMock);
+        const result = await make.templates.getBlueprint(61);
+        expect(result).toStrictEqual(blueprintMock);
+    });
+
+    it('Should get template blueprint with forUse option', async () => {
+        mockFetch('GET https://make.local/api/v2/templates/61/blueprint?forUse=true', blueprintMock);
+        const result = await make.templates.getBlueprint(61, { forUse: true });
+        expect(result).toStrictEqual(blueprintMock);
+    });
+});

From fe24fea5b00466e5810b3c8b865bbc9a30c5900d Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Thu, 16 Apr 2026 17:15:54 +0200
Subject: [PATCH 03/17] feat: wire Templates endpoint into Make client and
 exports

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/index.ts | 10 ++++++++++
 src/make.ts  |  9 +++++++++
 2 files changed, 19 insertions(+)

diff --git a/src/index.ts b/src/index.ts
index adad5d0..8f75d87 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -166,4 +166,14 @@ export type {
     UpdateSDKWebhookBody,
 } from './endpoints/sdk/webhooks.js';
 export type { Team, Teams, CreateTeamBody, ListTeamsOptions, GetTeamOptions } from './endpoints/teams.js';
+export type {
+    Template,
+    TemplatePublic,
+    TemplateBlueprint,
+    Templates,
+    ListTemplatesOptions,
+    ListTemplatesPublicOptions,
+    GetTemplateOptions,
+    GetTemplateBlueprintOptions,
+} from './endpoints/templates.js';
 export type { User, Users } from './endpoints/users.js';
diff --git a/src/make.ts b/src/make.ts
index e9e81ea..8b110ae 100644
--- a/src/make.ts
+++ b/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)),

From c2861c5137f374e855fc024bfe7fdbc57fc67841 Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Thu, 16 Apr 2026 17:31:02 +0200
Subject: [PATCH 04/17] style: align listPublic with codebase conventions

Use direct property access pattern instead of destructuring
in listPublic method. Improve JSDoc on list and listPublic.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/endpoints/templates.ts | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/src/endpoints/templates.ts b/src/endpoints/templates.ts
index 40df1bc..d50cdf1 100644
--- a/src/endpoints/templates.ts
+++ b/src/endpoints/templates.ts
@@ -170,7 +170,8 @@ export class Templates {
     }
 
     /**
-     * List private team-scoped templates.
+     * List private templates accessible to the authenticated user.
+     * Results can be filtered by team, public status, and used apps.
      * @param options Optional parameters for filtering and pagination
      * @returns Promise with the list of templates
      *
@@ -178,6 +179,9 @@ export class Templates {
      * ```typescript
      * // List all templates for team 1
      * const templates = await make.templates.list({ teamId: 1 });
+     *
+     * // List only public templates
+     * const publicTemplates = await make.templates.list({ public: true });
      * ```
      */
     async list<C extends keyof Template = never>(options: ListTemplatesOptions<C> = {}): Promise<PickColumns<Template, C>[]> {
@@ -196,26 +200,30 @@ export class Templates {
     }
 
     /**
-     * List publicly available approved templates.
-     * @param options Optional parameters for filtering and pagination
+     * 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.listPublic({ name: 'Http' });
+     * const templates = await make.templates.listPublic({ name: 'webhook' });
+     *
+     * // Filter by apps used
+     * const gmailTemplates = await make.templates.listPublic({ usedApps: ['gmail'] });
      * ```
      */
     async listPublic<C extends keyof TemplatePublic = never>(options: ListTemplatesPublicOptions<C> = {}): Promise<PickColumns<TemplatePublic, C>[]> {
-        const { name, usedApps, includeEn, cols, pg } = options;
         return (
             await this.#fetch<ListTemplatesPublicResponse<C>>('/templates/public', {
                 query: {
-                    name,
-                    usedApps,
-                    includeEn,
-                    cols,
-                    pg,
+                    name: options.name,
+                    usedApps: options.usedApps,
+                    includeEn: options.includeEn,
+                    cols: options.cols,
+                    pg: options.pg,
                 },
             })
         ).templatesPublic;

From 62af9599a9b592e648eb368998cf8bf4d17d18f1 Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 10:57:29 +0200
Subject: [PATCH 05/17] feat: add MCP tool definitions for templates endpoint

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/endpoints/templates.mcp.ts | 116 +++++++++++++++++++++++++++++++++
 src/mcp.ts                     |   2 +
 2 files changed, 118 insertions(+)
 create mode 100644 src/endpoints/templates.mcp.ts

diff --git a/src/endpoints/templates.mcp.ts b/src/endpoints/templates.mcp.ts
new file mode 100644
index 0000000..14ecaf2
--- /dev/null
+++ b/src/endpoints/templates.mcp.ts
@@ -0,0 +1,116 @@
+import type { Make } from '../make.js';
+
+export const tools = [
+    {
+        name: 'templates_list',
+        title: 'List templates',
+        description:
+            'List private templates accessible to the authenticated user, optionally filtered by team, public status, or used apps',
+        category: 'templates',
+        scope: 'templates:read',
+        identifier: 'teamId',
+        annotations: {
+            readOnlyHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                teamId: { type: 'number', description: 'The team ID to filter templates by' },
+                public: { type: 'boolean', description: 'Filter by whether the template is public' },
+                usedApps: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter templates by apps used',
+                },
+            },
+        },
+        examples: [{ teamId: 1 }],
+        execute: async (make: Make, args: { teamId?: number; public?: boolean; usedApps?: string[] }) => {
+            return await make.templates.list({ ...args, cols: ['*'] });
+        },
+    },
+    {
+        name: 'templates_list-public',
+        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.listPublic({ ...args, cols: ['*'] });
+        },
+    },
+    {
+        name: 'templates_get',
+        title: 'Get template',
+        description: 'Get details of a private template by its ID',
+        category: 'templates',
+        scope: 'templates:read',
+        identifier: 'templateId',
+        annotations: {
+            readOnlyHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                templateId: { type: 'number', description: 'The template ID to retrieve' },
+            },
+            required: ['templateId'],
+        },
+        examples: [{ templateId: 61 }],
+        execute: async (make: Make, args: { templateId: number }) => {
+            return await make.templates.get(args.templateId, { cols: ['*'] });
+        },
+    },
+    {
+        name: 'templates_get-blueprint',
+        title: 'Get template blueprint',
+        description:
+            'Get the full blueprint of a template including scenario flow, controller configuration, scheduling, and metadata',
+        category: 'templates',
+        scope: 'templates:read',
+        identifier: 'templateId',
+        annotations: {
+            readOnlyHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                templateId: { type: 'number', description: 'The template ID to retrieve the blueprint for' },
+                forUse: {
+                    type: 'boolean',
+                    description: 'Whether to retrieve the blueprint for immediate use in a new scenario',
+                },
+                templatePublicId: {
+                    type: 'number',
+                    description: 'ID of the public template to retrieve the blueprint for',
+                },
+            },
+            required: ['templateId'],
+        },
+        examples: [{ templateId: 61 }],
+        execute: async (
+            make: Make,
+            args: { templateId: number; forUse?: boolean; templatePublicId?: number },
+        ) => {
+            const { templateId, ...options } = args;
+            return await make.templates.getBlueprint(templateId, options);
+        },
+    },
+];
diff --git a/src/mcp.ts b/src/mcp.ts
index d6ada1d..c6e653e 100644
--- a/src/mcp.ts
+++ b/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[];

From 21ca17ab19df92b042a422332b41a55d5d3e1174 Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 11:00:21 +0200
Subject: [PATCH 06/17] test: add integration tests for templates endpoint

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 test/templates.integration.test.ts | 55 ++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 test/templates.integration.test.ts

diff --git a/test/templates.integration.test.ts b/test/templates.integration.test.ts
new file mode 100644
index 0000000..2148f44
--- /dev/null
+++ b/test/templates.integration.test.ts
@@ -0,0 +1,55 @@
+import 'dotenv/config';
+import { describe, expect, it } from '@jest/globals';
+import { Make } from '../src/make.js';
+
+const MAKE_API_KEY = String(process.env.MAKE_API_KEY || '');
+const MAKE_ZONE = String(process.env.MAKE_ZONE || '');
+const MAKE_TEAM = Number(process.env.MAKE_TEAM || 0);
+
+describe('Integration: Templates', () => {
+    const make = new Make(MAKE_API_KEY, MAKE_ZONE);
+
+    it('Should list templates for a team', async () => {
+        const templates = await make.templates.list({ teamId: MAKE_TEAM });
+
+        expect(Array.isArray(templates)).toBe(true);
+    });
+
+    it('Should list templates with column selection', async () => {
+        const templates = await make.templates.list({
+            teamId: MAKE_TEAM,
+            cols: ['id', 'name'],
+        });
+
+        expect(Array.isArray(templates)).toBe(true);
+        if (templates.length > 0) {
+            expect(templates[0]).toHaveProperty('id');
+            expect(templates[0]).toHaveProperty('name');
+        }
+    });
+
+    it('Should list public templates', async () => {
+        const templates = await make.templates.listPublic();
+
+        expect(Array.isArray(templates)).toBe(true);
+        expect(templates.length).toBeGreaterThan(0);
+    });
+
+    it('Should search public templates by name', async () => {
+        const templates = await make.templates.listPublic({ name: 'http' });
+
+        expect(Array.isArray(templates)).toBe(true);
+        if (templates.length > 0) {
+            expect(templates[0]).toHaveProperty('id');
+            expect(templates[0]).toHaveProperty('name');
+            expect(templates[0]).toHaveProperty('url');
+            expect(templates[0]).toHaveProperty('usage');
+        }
+    });
+
+    it('Should search public templates with usedApps filter', async () => {
+        const templates = await make.templates.listPublic({ usedApps: ['http'] });
+
+        expect(Array.isArray(templates)).toBe(true);
+    });
+});

From b237c0bf72967bb6bea75eb4046a30563d1eb50e Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 11:11:05 +0200
Subject: [PATCH 07/17] chore: format templates files and fix conditional
 expects

Remove conditional expect calls in integration tests to satisfy
jest/no-conditional-expect. Apply prettier formatting.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/endpoints/templates.mcp.ts     |  5 +----
 src/endpoints/templates.ts         | 13 ++++++++++---
 test/templates.integration.test.ts | 17 +++++++----------
 3 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/src/endpoints/templates.mcp.ts b/src/endpoints/templates.mcp.ts
index 14ecaf2..b25816d 100644
--- a/src/endpoints/templates.mcp.ts
+++ b/src/endpoints/templates.mcp.ts
@@ -105,10 +105,7 @@ export const tools = [
             required: ['templateId'],
         },
         examples: [{ templateId: 61 }],
-        execute: async (
-            make: Make,
-            args: { templateId: number; forUse?: boolean; templatePublicId?: number },
-        ) => {
+        execute: async (make: Make, args: { templateId: number; forUse?: boolean; templatePublicId?: number }) => {
             const { templateId, ...options } = args;
             return await make.templates.getBlueprint(templateId, options);
         },
diff --git a/src/endpoints/templates.ts b/src/endpoints/templates.ts
index d50cdf1..f39978d 100644
--- a/src/endpoints/templates.ts
+++ b/src/endpoints/templates.ts
@@ -184,7 +184,9 @@ export class Templates {
      * const publicTemplates = await make.templates.list({ public: true });
      * ```
      */
-    async list<C extends keyof Template = never>(options: ListTemplatesOptions<C> = {}): Promise<PickColumns<Template, C>[]> {
+    async list<C extends keyof Template = never>(
+        options: ListTemplatesOptions<C> = {},
+    ): Promise<PickColumns<Template, C>[]> {
         const { teamId, public: isPublic, usedApps, cols, pg } = options;
         return (
             await this.#fetch<ListTemplatesResponse<C>>('/templates', {
@@ -215,7 +217,9 @@ export class Templates {
      * const gmailTemplates = await make.templates.listPublic({ usedApps: ['gmail'] });
      * ```
      */
-    async listPublic<C extends keyof TemplatePublic = never>(options: ListTemplatesPublicOptions<C> = {}): Promise<PickColumns<TemplatePublic, C>[]> {
+    async listPublic<C extends keyof TemplatePublic = never>(
+        options: ListTemplatesPublicOptions<C> = {},
+    ): Promise<PickColumns<TemplatePublic, C>[]> {
         return (
             await this.#fetch<ListTemplatesPublicResponse<C>>('/templates/public', {
                 query: {
@@ -240,7 +244,10 @@ export class Templates {
      * const template = await make.templates.get(61);
      * ```
      */
-    async get<C extends keyof Template = never>(templateId: number, options: GetTemplateOptions<C> = {}): Promise<PickColumns<Template, C>> {
+    async get<C extends keyof Template = never>(
+        templateId: number,
+        options: GetTemplateOptions<C> = {},
+    ): Promise<PickColumns<Template, C>> {
         return (
             await this.#fetch<GetTemplateResponse<C>>(`/templates/${templateId}`, {
                 query: {
diff --git a/test/templates.integration.test.ts b/test/templates.integration.test.ts
index 2148f44..3b4087e 100644
--- a/test/templates.integration.test.ts
+++ b/test/templates.integration.test.ts
@@ -22,10 +22,6 @@ describe('Integration: Templates', () => {
         });
 
         expect(Array.isArray(templates)).toBe(true);
-        if (templates.length > 0) {
-            expect(templates[0]).toHaveProperty('id');
-            expect(templates[0]).toHaveProperty('name');
-        }
     });
 
     it('Should list public templates', async () => {
@@ -33,18 +29,19 @@ describe('Integration: Templates', () => {
 
         expect(Array.isArray(templates)).toBe(true);
         expect(templates.length).toBeGreaterThan(0);
+        expect(templates[0]).toHaveProperty('id');
+        expect(templates[0]).toHaveProperty('name');
+        expect(templates[0]).toHaveProperty('url');
+        expect(templates[0]).toHaveProperty('usage');
     });
 
     it('Should search public templates by name', async () => {
         const templates = await make.templates.listPublic({ name: 'http' });
 
         expect(Array.isArray(templates)).toBe(true);
-        if (templates.length > 0) {
-            expect(templates[0]).toHaveProperty('id');
-            expect(templates[0]).toHaveProperty('name');
-            expect(templates[0]).toHaveProperty('url');
-            expect(templates[0]).toHaveProperty('usage');
-        }
+        expect(templates.length).toBeGreaterThan(0);
+        expect(templates[0]).toHaveProperty('id');
+        expect(templates[0]).toHaveProperty('name');
     });
 
     it('Should search public templates with usedApps filter', async () => {

From 4d9ce923d5e0d6fe7ce1c994ac40abbf490b067c Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 11:25:22 +0200
Subject: [PATCH 08/17] feat: add getPublic and getPublicBlueprint methods for
 templates

Public templates use URL slugs (e.g. "12289-add-webhook-data-to-a-google-sheet"),
not numeric IDs, so the private getBlueprint endpoint returns 404 for them.
Add dedicated methods hitting /templates/public/:templateUrl and
/templates/public/:templateUrl/blueprint plus matching MCP tools.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 scripts/test-templates.mjs           | 49 +++++++++++++++++
 src/endpoints/templates.mcp.ts       | 50 ++++++++++++++++++
 src/endpoints/templates.ts           | 78 ++++++++++++++++++++++++++++
 src/index.ts                         |  2 +
 test/mocks/templates/get-public.json | 10 ++++
 test/templates.spec.ts               | 16 ++++++
 6 files changed, 205 insertions(+)
 create mode 100644 scripts/test-templates.mjs
 create mode 100644 test/mocks/templates/get-public.json

diff --git a/scripts/test-templates.mjs b/scripts/test-templates.mjs
new file mode 100644
index 0000000..5b6ece7
--- /dev/null
+++ b/scripts/test-templates.mjs
@@ -0,0 +1,49 @@
+#!/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 make = new Make(process.env.MAKE_API_KEY, process.env.MAKE_ZONE);
+
+console.log(`\n=== Searching public templates for "${searchTerm}" ===\n`);
+const templates = await make.templates.listPublic({ name: searchTerm });
+
+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.getPublicBlueprint(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`);
diff --git a/src/endpoints/templates.mcp.ts b/src/endpoints/templates.mcp.ts
index b25816d..c9a3e01 100644
--- a/src/endpoints/templates.mcp.ts
+++ b/src/endpoints/templates.mcp.ts
@@ -110,4 +110,54 @@ export const tools = [
             return await make.templates.getBlueprint(templateId, options);
         },
     },
+    {
+        name: 'templates_get-public',
+        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-public.',
+        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.getPublic(args.templateUrl, { cols: ['*'] });
+        },
+    },
+    {
+        name: 'templates_get-public-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-public.',
+        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.getPublicBlueprint(args.templateUrl);
+        },
+    },
 ];
diff --git a/src/endpoints/templates.ts b/src/endpoints/templates.ts
index f39978d..32a1637 100644
--- a/src/endpoints/templates.ts
+++ b/src/endpoints/templates.ts
@@ -125,6 +125,25 @@ export type GetTemplateBlueprintOptions = {
     templatePublicId?: number;
 };
 
+/**
+ * Options for getting a single public template.
+ * @template C Keys of the TemplatePublic type to include in the response
+ */
+export type GetTemplatePublicOptions<C extends keyof TemplatePublic = never> = {
+    /** Specific columns/fields to include in the response */
+    cols?: C[] | ['*'];
+    /** ID of the public template to retrieve */
+    templatePublicId?: number;
+};
+
+/**
+ * Options for getting a public template blueprint.
+ */
+export type GetTemplatePublicBlueprintOptions = {
+    /** ID of the public template to retrieve the blueprint for */
+    templatePublicId?: number;
+};
+
 /**
  * Response format for listing private templates.
  */
@@ -153,6 +172,14 @@ type GetTemplateResponse<C extends keyof Template = never> = {
     template: PickColumns<Template, C>;
 };
 
+/**
+ * Response format for getting a single public template.
+ */
+type GetTemplatePublicResponse<C extends keyof TemplatePublic = never> = {
+    /** The requested public template */
+    templatePublic: PickColumns<TemplatePublic, C>;
+};
+
 /**
  * Class providing methods for working with Make templates.
  * Templates allow users to create reusable scenario configurations
@@ -279,4 +306,55 @@ export class Templates {
             },
         });
     }
+
+    /**
+     * Get a single public template by its URL slug.
+     * Use this for templates discovered via {@link listPublic}.
+     * @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.getPublic('12289-add-webhook-data-to-a-google-sheet');
+     * ```
+     */
+    async getPublic<C extends keyof TemplatePublic = never>(
+        templateUrl: string,
+        options: GetTemplatePublicOptions<C> = {},
+    ): Promise<PickColumns<TemplatePublic, C>> {
+        return (
+            await this.#fetch<GetTemplatePublicResponse<C>>(`/templates/public/${templateUrl}`, {
+                query: {
+                    cols: options.cols,
+                    templatePublicId: options.templatePublicId,
+                },
+            })
+        ).templatePublic;
+    }
+
+    /**
+     * Get the blueprint (scenario definition) for a public template.
+     * Use this for templates discovered via {@link listPublic}.
+     * 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")
+     * @param options Optional parameters for blueprint retrieval
+     * @returns Promise with the full blueprint response
+     *
+     * @example
+     * ```typescript
+     * const blueprint = await make.templates.getPublicBlueprint('12289-add-webhook-data-to-a-google-sheet');
+     * ```
+     */
+    async getPublicBlueprint(
+        templateUrl: string,
+        options: GetTemplatePublicBlueprintOptions = {},
+    ): Promise<TemplateBlueprint> {
+        return await this.#fetch<TemplateBlueprint>(`/templates/public/${templateUrl}/blueprint`, {
+            query: {
+                templatePublicId: options.templatePublicId,
+            },
+        });
+    }
 }
diff --git a/src/index.ts b/src/index.ts
index 8f75d87..726f4e9 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -175,5 +175,7 @@ export type {
     ListTemplatesPublicOptions,
     GetTemplateOptions,
     GetTemplateBlueprintOptions,
+    GetTemplatePublicOptions,
+    GetTemplatePublicBlueprintOptions,
 } from './endpoints/templates.js';
 export type { User, Users } from './endpoints/users.js';
diff --git a/test/mocks/templates/get-public.json b/test/mocks/templates/get-public.json
new file mode 100644
index 0000000..70d3daf
--- /dev/null
+++ b/test/mocks/templates/get-public.json
@@ -0,0 +1,10 @@
+{
+    "templatePublic": {
+        "id": 13,
+        "name": "Http template example",
+        "description": null,
+        "url": "13-http-template-example",
+        "usedApps": ["http"],
+        "usage": 321
+    }
+}
diff --git a/test/templates.spec.ts b/test/templates.spec.ts
index 30581b8..98307cd 100644
--- a/test/templates.spec.ts
+++ b/test/templates.spec.ts
@@ -5,6 +5,7 @@ import { mockFetch } from './test.utils.js';
 import * as listMock from './mocks/templates/list.json';
 import * as listPublicMock from './mocks/templates/list-public.json';
 import * as getMock from './mocks/templates/get.json';
+import * as getPublicMock from './mocks/templates/get-public.json';
 import * as blueprintMock from './mocks/templates/blueprint.json';
 
 const MAKE_API_KEY = 'api-key';
@@ -42,4 +43,19 @@ describe('Endpoints: Templates', () => {
         const result = await make.templates.getBlueprint(61, { forUse: true });
         expect(result).toStrictEqual(blueprintMock);
     });
+
+    it('Should get public template by URL slug', async () => {
+        mockFetch('GET https://make.local/api/v2/templates/public/13-http-template-example', getPublicMock);
+        const result = await make.templates.getPublic('13-http-template-example');
+        expect(result).toStrictEqual(getPublicMock.templatePublic);
+    });
+
+    it('Should get public template blueprint by URL slug', async () => {
+        mockFetch(
+            'GET https://make.local/api/v2/templates/public/13-http-template-example/blueprint',
+            blueprintMock,
+        );
+        const result = await make.templates.getPublicBlueprint('13-http-template-example');
+        expect(result).toStrictEqual(blueprintMock);
+    });
 });

From 4d853ca32016c47f1760affc5b3a0761bba81828 Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 12:03:08 +0200
Subject: [PATCH 09/17] refactor(templates): drop private templates, keep
 public only

Remove the private-template surface (Template/list/get/getBlueprint
addressable by numeric ID) and rename the public variants
(TemplatePublic/listPublic/getPublic/getPublicBlueprint) to the base
names. Tests, mocks, MCP tools, index exports, and the live smoke
script are updated to match.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 scripts/test-templates.mjs            |   4 +-
 src/endpoints/templates.mcp.ts        | 101 ++---------
 src/endpoints/templates.ts            | 241 +++-----------------------
 src/index.ts                          |   5 -
 test/mocks/templates/get-public.json  |  10 --
 test/mocks/templates/get.json         |  22 +--
 test/mocks/templates/list-public.json |  26 ---
 test/mocks/templates/list.json        |  36 ++--
 test/templates.integration.test.ts    |  39 +++--
 test/templates.spec.ts                |  40 +----
 10 files changed, 92 insertions(+), 432 deletions(-)
 delete mode 100644 test/mocks/templates/get-public.json
 delete mode 100644 test/mocks/templates/list-public.json

diff --git a/scripts/test-templates.mjs b/scripts/test-templates.mjs
index 5b6ece7..d7c231a 100644
--- a/scripts/test-templates.mjs
+++ b/scripts/test-templates.mjs
@@ -22,7 +22,7 @@ const searchTerm = process.argv[2] || 'webhook';
 const make = new Make(process.env.MAKE_API_KEY, process.env.MAKE_ZONE);
 
 console.log(`\n=== Searching public templates for "${searchTerm}" ===\n`);
-const templates = await make.templates.listPublic({ name: searchTerm });
+const templates = await make.templates.list({ name: searchTerm });
 
 console.log(`Found ${templates.length} template(s):`);
 templates.slice(0, 5).forEach(t => {
@@ -36,7 +36,7 @@ if (templates.length === 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.getPublicBlueprint(first.url);
+const blueprint = await make.templates.getBlueprint(first.url);
 
 console.log('Language:', blueprint.language);
 console.log('Scheduling:', JSON.stringify(blueprint.scheduling));
diff --git a/src/endpoints/templates.mcp.ts b/src/endpoints/templates.mcp.ts
index c9a3e01..34279b2 100644
--- a/src/endpoints/templates.mcp.ts
+++ b/src/endpoints/templates.mcp.ts
@@ -3,34 +3,6 @@ import type { Make } from '../make.js';
 export const tools = [
     {
         name: 'templates_list',
-        title: 'List templates',
-        description:
-            'List private templates accessible to the authenticated user, optionally filtered by team, public status, or used apps',
-        category: 'templates',
-        scope: 'templates:read',
-        identifier: 'teamId',
-        annotations: {
-            readOnlyHint: true,
-        },
-        inputSchema: {
-            type: 'object',
-            properties: {
-                teamId: { type: 'number', description: 'The team ID to filter templates by' },
-                public: { type: 'boolean', description: 'Filter by whether the template is public' },
-                usedApps: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Filter templates by apps used',
-                },
-            },
-        },
-        examples: [{ teamId: 1 }],
-        execute: async (make: Make, args: { teamId?: number; public?: boolean; usedApps?: string[] }) => {
-            return await make.templates.list({ ...args, cols: ['*'] });
-        },
-    },
-    {
-        name: 'templates_list-public',
         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.',
@@ -48,72 +20,22 @@ export const tools = [
                     items: { type: 'string' },
                     description: 'Filter templates by apps used',
                 },
-                includeEn: { type: 'boolean', description: 'Whether to include English-language templates in results' },
+                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.listPublic({ ...args, cols: ['*'] });
+            return await make.templates.list({ ...args, cols: ['*'] });
         },
     },
     {
         name: 'templates_get',
-        title: 'Get template',
-        description: 'Get details of a private template by its ID',
-        category: 'templates',
-        scope: 'templates:read',
-        identifier: 'templateId',
-        annotations: {
-            readOnlyHint: true,
-        },
-        inputSchema: {
-            type: 'object',
-            properties: {
-                templateId: { type: 'number', description: 'The template ID to retrieve' },
-            },
-            required: ['templateId'],
-        },
-        examples: [{ templateId: 61 }],
-        execute: async (make: Make, args: { templateId: number }) => {
-            return await make.templates.get(args.templateId, { cols: ['*'] });
-        },
-    },
-    {
-        name: 'templates_get-blueprint',
-        title: 'Get template blueprint',
-        description:
-            'Get the full blueprint of a template including scenario flow, controller configuration, scheduling, and metadata',
-        category: 'templates',
-        scope: 'templates:read',
-        identifier: 'templateId',
-        annotations: {
-            readOnlyHint: true,
-        },
-        inputSchema: {
-            type: 'object',
-            properties: {
-                templateId: { type: 'number', description: 'The template ID to retrieve the blueprint for' },
-                forUse: {
-                    type: 'boolean',
-                    description: 'Whether to retrieve the blueprint for immediate use in a new scenario',
-                },
-                templatePublicId: {
-                    type: 'number',
-                    description: 'ID of the public template to retrieve the blueprint for',
-                },
-            },
-            required: ['templateId'],
-        },
-        examples: [{ templateId: 61 }],
-        execute: async (make: Make, args: { templateId: number; forUse?: boolean; templatePublicId?: number }) => {
-            const { templateId, ...options } = args;
-            return await make.templates.getBlueprint(templateId, options);
-        },
-    },
-    {
-        name: 'templates_get-public',
         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-public.',
+        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',
@@ -132,13 +54,14 @@ export const tools = [
         },
         examples: [{ templateUrl: '12289-add-webhook-data-to-a-google-sheet' }],
         execute: async (make: Make, args: { templateUrl: string }) => {
-            return await make.templates.getPublic(args.templateUrl, { cols: ['*'] });
+            return await make.templates.get(args.templateUrl, { cols: ['*'] });
         },
     },
     {
-        name: 'templates_get-public-blueprint',
+        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-public.',
+        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',
@@ -157,7 +80,7 @@ export const tools = [
         },
         examples: [{ templateUrl: '12289-add-webhook-data-to-a-google-sheet' }],
         execute: async (make: Make, args: { templateUrl: string }) => {
-            return await make.templates.getPublicBlueprint(args.templateUrl);
+            return await make.templates.getBlueprint(args.templateUrl);
         },
     },
 ];
diff --git a/src/endpoints/templates.ts b/src/endpoints/templates.ts
index 32a1637..b8d794d 100644
--- a/src/endpoints/templates.ts
+++ b/src/endpoints/templates.ts
@@ -1,46 +1,10 @@
 import type { FetchFunction, Pagination, PickColumns } from '../types.js';
 
-/**
- * Represents a private team-scoped template in Make.
- * Templates allow users to create reusable scenario configurations
- * that can optionally be shared publicly or submitted for approval.
- */
-export type Template = {
-    /** Unique identifier of the template */
-    id: number;
-    /** Name of the template */
-    name: string;
-    /** ID of the team that owns the template */
-    teamId: number;
-    /** Human-readable description of what the template does, or null if not set */
-    description: string | null;
-    /** List of app identifiers used in the template */
-    usedApps: string[];
-    /** Whether the template has been made publicly visible */
-    public: boolean;
-    /** ISO timestamp when the template was published, or null if not published */
-    published: string | null;
-    /** ISO timestamp when the template was approved, or null if not approved */
-    approved: string | null;
-    /** ID of the approving user, or null if not approved */
-    approvedId: number | null;
-    /** Whether approval has been requested for the template, or null if not applicable */
-    requestedApproval: boolean | null;
-    /** ID of the publishing user, or null if not published */
-    publishedId: number | null;
-    /** Public URL slug of the template, or null if not published */
-    publicUrl: string | null;
-    /** Name of the approving user, or null if not approved */
-    approvedName: string | null;
-    /** Name of the publishing user, or null if not published */
-    publishedName: string | null;
-};
-
 /**
  * Represents a publicly available approved template in Make.
  * Public templates can be discovered and used by all Make users.
  */
-export type TemplatePublic = {
+export type Template = {
     /** Unique identifier of the public template */
     id: number;
     /** Name of the public template */
@@ -73,7 +37,7 @@ export type TemplateBlueprint = {
 };
 
 /**
- * Options for listing private team templates.
+ * 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> = {
@@ -81,23 +45,6 @@ export type ListTemplatesOptions<C extends keyof Template = never> = {
     cols?: C[] | ['*'];
     /** Pagination options */
     pg?: Partial<Pagination<Template>>;
-    /** Filter templates by team ID */
-    teamId?: number;
-    /** Filter by whether the template is public */
-    public?: boolean;
-    /** Filter templates by apps used */
-    usedApps?: string[];
-};
-
-/**
- * Options for listing public approved templates.
- * @template C Keys of the TemplatePublic type to include in the response
- */
-export type ListTemplatesPublicOptions<C extends keyof TemplatePublic = never> = {
-    /** Specific columns/fields to include in the response */
-    cols?: C[] | ['*'];
-    /** Pagination options */
-    pg?: Partial<Pagination<TemplatePublic>>;
     /** Search templates by name */
     name?: string;
     /** Filter templates by apps used */
@@ -107,7 +54,7 @@ export type ListTemplatesPublicOptions<C extends keyof TemplatePublic = never> =
 };
 
 /**
- * Options for getting a single template.
+ * 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> = {
@@ -115,75 +62,28 @@ export type GetTemplateOptions<C extends keyof Template = never> = {
     cols?: C[] | ['*'];
 };
 
-/**
- * Options for getting a template blueprint.
- */
-export type GetTemplateBlueprintOptions = {
-    /** Whether to retrieve the blueprint for immediate use in a new scenario */
-    forUse?: boolean;
-    /** ID of the public template to retrieve the blueprint for */
-    templatePublicId?: number;
-};
-
-/**
- * Options for getting a single public template.
- * @template C Keys of the TemplatePublic type to include in the response
- */
-export type GetTemplatePublicOptions<C extends keyof TemplatePublic = never> = {
-    /** Specific columns/fields to include in the response */
-    cols?: C[] | ['*'];
-    /** ID of the public template to retrieve */
-    templatePublicId?: number;
-};
-
-/**
- * Options for getting a public template blueprint.
- */
-export type GetTemplatePublicBlueprintOptions = {
-    /** ID of the public template to retrieve the blueprint for */
-    templatePublicId?: number;
-};
-
-/**
- * Response format for listing private templates.
- */
-type ListTemplatesResponse<C extends keyof Template = never> = {
-    /** List of templates matching the query */
-    templates: PickColumns<Template, C>[];
-    /** Pagination information */
-    pg: Pagination<Template>;
-};
-
 /**
  * Response format for listing public templates.
  */
-type ListTemplatesPublicResponse<C extends keyof TemplatePublic = never> = {
+type ListTemplatesResponse<C extends keyof Template = never> = {
     /** List of public templates matching the query */
-    templatesPublic: PickColumns<TemplatePublic, C>[];
+    templatesPublic: PickColumns<Template, C>[];
     /** Pagination information */
-    pg: Pagination<TemplatePublic>;
-};
-
-/**
- * Response format for getting a single template.
- */
-type GetTemplateResponse<C extends keyof Template = never> = {
-    /** The requested template */
-    template: PickColumns<Template, C>;
+    pg: Pagination<Template>;
 };
 
 /**
  * Response format for getting a single public template.
  */
-type GetTemplatePublicResponse<C extends keyof TemplatePublic = never> = {
+type GetTemplateResponse<C extends keyof Template = never> = {
     /** The requested public template */
-    templatePublic: PickColumns<TemplatePublic, C>;
+    templatePublic: PickColumns<Template, C>;
 };
 
 /**
- * Class providing methods for working with Make templates.
- * Templates allow users to create reusable scenario configurations
- * that can be shared, published, and discovered by other users.
+ * 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;
@@ -196,38 +96,6 @@ export class Templates {
         this.#fetch = fetch;
     }
 
-    /**
-     * List private templates accessible to the authenticated user.
-     * Results can be filtered by team, public status, and used apps.
-     * @param options Optional parameters for filtering and pagination
-     * @returns Promise with the list of templates
-     *
-     * @example
-     * ```typescript
-     * // List all templates for team 1
-     * const templates = await make.templates.list({ teamId: 1 });
-     *
-     * // List only public templates
-     * const publicTemplates = await make.templates.list({ public: true });
-     * ```
-     */
-    async list<C extends keyof Template = never>(
-        options: ListTemplatesOptions<C> = {},
-    ): Promise<PickColumns<Template, C>[]> {
-        const { teamId, public: isPublic, usedApps, cols, pg } = options;
-        return (
-            await this.#fetch<ListTemplatesResponse<C>>('/templates', {
-                query: {
-                    teamId,
-                    public: isPublic,
-                    usedApps,
-                    cols,
-                    pg,
-                },
-            })
-        ).templates;
-    }
-
     /**
      * List public (approved) templates available for anyone.
      * Supports name-based search for template discovery.
@@ -238,17 +106,17 @@ export class Templates {
      * @example
      * ```typescript
      * // Search public templates by name
-     * const templates = await make.templates.listPublic({ name: 'webhook' });
+     * const templates = await make.templates.list({ name: 'webhook' });
      *
      * // Filter by apps used
-     * const gmailTemplates = await make.templates.listPublic({ usedApps: ['gmail'] });
+     * const gmailTemplates = await make.templates.list({ usedApps: ['gmail'] });
      * ```
      */
-    async listPublic<C extends keyof TemplatePublic = never>(
-        options: ListTemplatesPublicOptions<C> = {},
-    ): Promise<PickColumns<TemplatePublic, C>[]> {
+    async list<C extends keyof Template = never>(
+        options: ListTemplatesOptions<C> = {},
+    ): Promise<PickColumns<Template, C>[]> {
         return (
-            await this.#fetch<ListTemplatesPublicResponse<C>>('/templates/public', {
+            await this.#fetch<ListTemplatesResponse<C>>('/templates/public', {
                 query: {
                     name: options.name,
                     usedApps: options.usedApps,
@@ -260,74 +128,26 @@ export class Templates {
         ).templatesPublic;
     }
 
-    /**
-     * Get a single template by ID.
-     * @param templateId The template ID to retrieve
-     * @param options Optional parameters for field selection
-     * @returns Promise with the template details
-     *
-     * @example
-     * ```typescript
-     * const template = await make.templates.get(61);
-     * ```
-     */
-    async get<C extends keyof Template = never>(
-        templateId: number,
-        options: GetTemplateOptions<C> = {},
-    ): Promise<PickColumns<Template, C>> {
-        return (
-            await this.#fetch<GetTemplateResponse<C>>(`/templates/${templateId}`, {
-                query: {
-                    cols: options.cols,
-                },
-            })
-        ).template;
-    }
-
-    /**
-     * Get the blueprint (scenario definition) for a 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 templateId The template ID to retrieve the blueprint for
-     * @param options Optional parameters for blueprint retrieval
-     * @returns Promise with the full blueprint response
-     *
-     * @example
-     * ```typescript
-     * // Get blueprint for immediate use
-     * const blueprint = await make.templates.getBlueprint(61, { forUse: true });
-     * ```
-     */
-    async getBlueprint(templateId: number, options: GetTemplateBlueprintOptions = {}): Promise<TemplateBlueprint> {
-        return await this.#fetch<TemplateBlueprint>(`/templates/${templateId}/blueprint`, {
-            query: {
-                forUse: options.forUse,
-                templatePublicId: options.templatePublicId,
-            },
-        });
-    }
-
     /**
      * Get a single public template by its URL slug.
-     * Use this for templates discovered via {@link listPublic}.
+     * 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.getPublic('12289-add-webhook-data-to-a-google-sheet');
+     * const template = await make.templates.get('12289-add-webhook-data-to-a-google-sheet');
      * ```
      */
-    async getPublic<C extends keyof TemplatePublic = never>(
+    async get<C extends keyof Template = never>(
         templateUrl: string,
-        options: GetTemplatePublicOptions<C> = {},
-    ): Promise<PickColumns<TemplatePublic, C>> {
+        options: GetTemplateOptions<C> = {},
+    ): Promise<PickColumns<Template, C>> {
         return (
-            await this.#fetch<GetTemplatePublicResponse<C>>(`/templates/public/${templateUrl}`, {
+            await this.#fetch<GetTemplateResponse<C>>(`/templates/public/${templateUrl}`, {
                 query: {
                     cols: options.cols,
-                    templatePublicId: options.templatePublicId,
                 },
             })
         ).templatePublic;
@@ -335,26 +155,17 @@ export class Templates {
 
     /**
      * Get the blueprint (scenario definition) for a public template.
-     * Use this for templates discovered via {@link listPublic}.
      * 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")
-     * @param options Optional parameters for blueprint retrieval
      * @returns Promise with the full blueprint response
      *
      * @example
      * ```typescript
-     * const blueprint = await make.templates.getPublicBlueprint('12289-add-webhook-data-to-a-google-sheet');
+     * const blueprint = await make.templates.getBlueprint('12289-add-webhook-data-to-a-google-sheet');
      * ```
      */
-    async getPublicBlueprint(
-        templateUrl: string,
-        options: GetTemplatePublicBlueprintOptions = {},
-    ): Promise<TemplateBlueprint> {
-        return await this.#fetch<TemplateBlueprint>(`/templates/public/${templateUrl}/blueprint`, {
-            query: {
-                templatePublicId: options.templatePublicId,
-            },
-        });
+    async getBlueprint(templateUrl: string): Promise<TemplateBlueprint> {
+        return await this.#fetch<TemplateBlueprint>(`/templates/public/${templateUrl}/blueprint`);
     }
 }
diff --git a/src/index.ts b/src/index.ts
index 726f4e9..3871476 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -168,14 +168,9 @@ export type {
 export type { Team, Teams, CreateTeamBody, ListTeamsOptions, GetTeamOptions } from './endpoints/teams.js';
 export type {
     Template,
-    TemplatePublic,
     TemplateBlueprint,
     Templates,
     ListTemplatesOptions,
-    ListTemplatesPublicOptions,
     GetTemplateOptions,
-    GetTemplateBlueprintOptions,
-    GetTemplatePublicOptions,
-    GetTemplatePublicBlueprintOptions,
 } from './endpoints/templates.js';
 export type { User, Users } from './endpoints/users.js';
diff --git a/test/mocks/templates/get-public.json b/test/mocks/templates/get-public.json
deleted file mode 100644
index 70d3daf..0000000
--- a/test/mocks/templates/get-public.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "templatePublic": {
-        "id": 13,
-        "name": "Http template example",
-        "description": null,
-        "url": "13-http-template-example",
-        "usedApps": ["http"],
-        "usage": 321
-    }
-}
diff --git a/test/mocks/templates/get.json b/test/mocks/templates/get.json
index c555d83..70d3daf 100644
--- a/test/mocks/templates/get.json
+++ b/test/mocks/templates/get.json
@@ -1,18 +1,10 @@
 {
-    "template": {
-        "id": 61,
-        "name": "My Private Template",
-        "teamId": 1,
-        "description": "A template for testing",
-        "usedApps": ["http", "json"],
-        "public": false,
-        "published": null,
-        "approved": null,
-        "approvedId": null,
-        "requestedApproval": false,
-        "publishedId": null,
-        "publicUrl": null,
-        "approvedName": null,
-        "publishedName": null
+    "templatePublic": {
+        "id": 13,
+        "name": "Http template example",
+        "description": null,
+        "url": "13-http-template-example",
+        "usedApps": ["http"],
+        "usage": 321
     }
 }
diff --git a/test/mocks/templates/list-public.json b/test/mocks/templates/list-public.json
deleted file mode 100644
index bef7656..0000000
--- a/test/mocks/templates/list-public.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-    "templatesPublic": [
-        {
-            "id": 13,
-            "name": "Http template example",
-            "description": null,
-            "url": "13-http-template-example",
-            "usedApps": ["http"],
-            "usage": 321
-        },
-        {
-            "id": 17,
-            "name": "Webhook to Email",
-            "description": "Send email when webhook is triggered",
-            "url": "17-webhook-to-email",
-            "usedApps": ["gateway", "gmail"],
-            "usage": 52
-        }
-    ],
-    "pg": {
-        "sortBy": "usage",
-        "limit": 100,
-        "sortDir": "desc",
-        "offset": 0
-    }
-}
diff --git a/test/mocks/templates/list.json b/test/mocks/templates/list.json
index ad020b5..bef7656 100644
--- a/test/mocks/templates/list.json
+++ b/test/mocks/templates/list.json
@@ -1,26 +1,26 @@
 {
-    "templates": [
+    "templatesPublic": [
         {
-            "id": 61,
-            "name": "My Private Template",
-            "teamId": 1,
-            "description": "A template for testing",
-            "usedApps": ["http", "json"],
-            "public": false,
-            "published": null,
-            "approved": null,
-            "approvedId": null,
-            "requestedApproval": false,
-            "publishedId": null,
-            "publicUrl": null,
-            "approvedName": null,
-            "publishedName": null
+            "id": 13,
+            "name": "Http template example",
+            "description": null,
+            "url": "13-http-template-example",
+            "usedApps": ["http"],
+            "usage": 321
+        },
+        {
+            "id": 17,
+            "name": "Webhook to Email",
+            "description": "Send email when webhook is triggered",
+            "url": "17-webhook-to-email",
+            "usedApps": ["gateway", "gmail"],
+            "usage": 52
         }
     ],
     "pg": {
-        "sortBy": "name",
-        "limit": 10,
-        "sortDir": "asc",
+        "sortBy": "usage",
+        "limit": 100,
+        "sortDir": "desc",
         "offset": 0
     }
 }
diff --git a/test/templates.integration.test.ts b/test/templates.integration.test.ts
index 3b4087e..6c6c611 100644
--- a/test/templates.integration.test.ts
+++ b/test/templates.integration.test.ts
@@ -4,28 +4,12 @@ import { Make } from '../src/make.js';
 
 const MAKE_API_KEY = String(process.env.MAKE_API_KEY || '');
 const MAKE_ZONE = String(process.env.MAKE_ZONE || '');
-const MAKE_TEAM = Number(process.env.MAKE_TEAM || 0);
 
 describe('Integration: Templates', () => {
     const make = new Make(MAKE_API_KEY, MAKE_ZONE);
 
-    it('Should list templates for a team', async () => {
-        const templates = await make.templates.list({ teamId: MAKE_TEAM });
-
-        expect(Array.isArray(templates)).toBe(true);
-    });
-
-    it('Should list templates with column selection', async () => {
-        const templates = await make.templates.list({
-            teamId: MAKE_TEAM,
-            cols: ['id', 'name'],
-        });
-
-        expect(Array.isArray(templates)).toBe(true);
-    });
-
     it('Should list public templates', async () => {
-        const templates = await make.templates.listPublic();
+        const templates = await make.templates.list();
 
         expect(Array.isArray(templates)).toBe(true);
         expect(templates.length).toBeGreaterThan(0);
@@ -36,7 +20,7 @@ describe('Integration: Templates', () => {
     });
 
     it('Should search public templates by name', async () => {
-        const templates = await make.templates.listPublic({ name: 'http' });
+        const templates = await make.templates.list({ name: 'http' });
 
         expect(Array.isArray(templates)).toBe(true);
         expect(templates.length).toBeGreaterThan(0);
@@ -45,8 +29,25 @@ describe('Integration: Templates', () => {
     });
 
     it('Should search public templates with usedApps filter', async () => {
-        const templates = await make.templates.listPublic({ usedApps: ['http'] });
+        const templates = await make.templates.list({ usedApps: ['http'] });
 
         expect(Array.isArray(templates)).toBe(true);
     });
+
+    it('Should get a public template by URL slug', async () => {
+        const [first] = await make.templates.list({ name: 'http' });
+        const template = await make.templates.get(first!.url);
+
+        expect(template.id).toBe(first!.id);
+        expect(template.url).toBe(first!.url);
+    });
+
+    it('Should get a public template blueprint by URL slug', async () => {
+        const [first] = await make.templates.list({ name: 'http' });
+        const blueprint = await make.templates.getBlueprint(first!.url);
+
+        expect(blueprint).toHaveProperty('blueprint');
+        expect(blueprint).toHaveProperty('scheduling');
+        expect(blueprint).toHaveProperty('language');
+    });
 });
diff --git a/test/templates.spec.ts b/test/templates.spec.ts
index 98307cd..be3a38c 100644
--- a/test/templates.spec.ts
+++ b/test/templates.spec.ts
@@ -3,9 +3,7 @@ import { Make } from '../src/make.js';
 import { mockFetch } from './test.utils.js';
 
 import * as listMock from './mocks/templates/list.json';
-import * as listPublicMock from './mocks/templates/list-public.json';
 import * as getMock from './mocks/templates/get.json';
-import * as getPublicMock from './mocks/templates/get-public.json';
 import * as blueprintMock from './mocks/templates/blueprint.json';
 
 const MAKE_API_KEY = 'api-key';
@@ -14,40 +12,16 @@ const MAKE_ZONE = 'make.local';
 describe('Endpoints: Templates', () => {
     const make = new Make(MAKE_API_KEY, MAKE_ZONE);
 
-    it('Should list templates', async () => {
-        mockFetch('GET https://make.local/api/v2/templates?teamId=1', listMock);
-        const result = await make.templates.list({ teamId: 1 });
-        expect(result).toStrictEqual(listMock.templates);
-    });
-
     it('Should list public templates with name search', async () => {
-        mockFetch('GET https://make.local/api/v2/templates/public?name=Http', listPublicMock);
-        const result = await make.templates.listPublic({ name: 'Http' });
-        expect(result).toStrictEqual(listPublicMock.templatesPublic);
-    });
-
-    it('Should get template by ID', async () => {
-        mockFetch('GET https://make.local/api/v2/templates/61', getMock);
-        const result = await make.templates.get(61);
-        expect(result).toStrictEqual(getMock.template);
-    });
-
-    it('Should get template blueprint', async () => {
-        mockFetch('GET https://make.local/api/v2/templates/61/blueprint', blueprintMock);
-        const result = await make.templates.getBlueprint(61);
-        expect(result).toStrictEqual(blueprintMock);
-    });
-
-    it('Should get template blueprint with forUse option', async () => {
-        mockFetch('GET https://make.local/api/v2/templates/61/blueprint?forUse=true', blueprintMock);
-        const result = await make.templates.getBlueprint(61, { forUse: true });
-        expect(result).toStrictEqual(blueprintMock);
+        mockFetch('GET https://make.local/api/v2/templates/public?name=Http', listMock);
+        const result = await make.templates.list({ name: 'Http' });
+        expect(result).toStrictEqual(listMock.templatesPublic);
     });
 
     it('Should get public template by URL slug', async () => {
-        mockFetch('GET https://make.local/api/v2/templates/public/13-http-template-example', getPublicMock);
-        const result = await make.templates.getPublic('13-http-template-example');
-        expect(result).toStrictEqual(getPublicMock.templatePublic);
+        mockFetch('GET https://make.local/api/v2/templates/public/13-http-template-example', getMock);
+        const result = await make.templates.get('13-http-template-example');
+        expect(result).toStrictEqual(getMock.templatePublic);
     });
 
     it('Should get public template blueprint by URL slug', async () => {
@@ -55,7 +29,7 @@ describe('Endpoints: Templates', () => {
             'GET https://make.local/api/v2/templates/public/13-http-template-example/blueprint',
             blueprintMock,
         );
-        const result = await make.templates.getPublicBlueprint('13-http-template-example');
+        const result = await make.templates.getBlueprint('13-http-template-example');
         expect(result).toStrictEqual(blueprintMock);
     });
 });

From 9a6c6a79abc847af254a0774dbcbe9f29cc0d128 Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 12:09:31 +0200
Subject: [PATCH 10/17] chore(scripts): add usedApps filter to templates smoke
 test

Second CLI arg is now a comma-separated list of app identifiers
forwarded as templates.list({ usedApps }). Example:
  node scripts/test-templates.mjs webhook google-sheets

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 scripts/test-templates.mjs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/scripts/test-templates.mjs b/scripts/test-templates.mjs
index d7c231a..17e7140 100644
--- a/scripts/test-templates.mjs
+++ b/scripts/test-templates.mjs
@@ -17,12 +17,14 @@ if (!process.env.MAKE_ZONE) {
     process.exit(1);
 }
 
-const searchTerm = process.argv[2] || 'webhook';
+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);
 
-console.log(`\n=== Searching public templates for "${searchTerm}" ===\n`);
-const templates = await make.templates.list({ name: searchTerm });
+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 => {

From b672277a20320f8481245f2f656fe36b2c09a64c Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 12:44:06 +0200
Subject: [PATCH 11/17] remove: file

---
 scripts/test-templates.mjs | 51 --------------------------------------
 1 file changed, 51 deletions(-)
 delete mode 100644 scripts/test-templates.mjs

diff --git a/scripts/test-templates.mjs b/scripts/test-templates.mjs
deleted file mode 100644
index 17e7140..0000000
--- a/scripts/test-templates.mjs
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/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`);

From b7161bb7b1abe9fe1481048dbdb3052718cb4879 Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 12:54:58 +0200
Subject: [PATCH 12/17] feat(templates): update template names and enhance
 documentation for public templates

---
 README.md                           |  2 ++
 src/endpoints/templates.ts          | 41 ++++++++++++++++++-----------
 src/make.ts                         |  5 ++--
 test/mocks/templates/blueprint.json |  4 +--
 test/templates.integration.test.ts  |  2 ++
 test/templates.spec.ts              |  9 +++++++
 6 files changed, 42 insertions(+), 21 deletions(-)

diff --git a/README.md b/README.md
index 7ca3116..9f3e958 100644
--- a/README.md
+++ b/README.md
@@ -63,6 +63,7 @@ const make = new Make('your-api-key', 'eu2.make.com', {
 - **Organizations** - Top-level account and billing management
 - **Scenarios** - Scenario management
 - **Teams** - Team management and collaboration
+- **Templates** - Public template discovery and blueprint export (read-only)
 - **Users** - Current user information and authentication
 
 ## Custom Apps Development Endpoints
@@ -202,6 +203,7 @@ All tools are organized into the following categories:
 - `organizations`
 - `scenarios`
 - `teams`
+- `templates`
 - `users`
 - `sdk.apps`
 - `sdk.connections`
diff --git a/src/endpoints/templates.ts b/src/endpoints/templates.ts
index b8d794d..eadb799 100644
--- a/src/endpoints/templates.ts
+++ b/src/endpoints/templates.ts
@@ -1,4 +1,6 @@
 import type { FetchFunction, Pagination, PickColumns } from '../types.js';
+import type { Blueprint } from './blueprints.js';
+import type { Scheduling } from './scenarios.js';
 
 /**
  * Represents a publicly available approved template in Make.
@@ -9,35 +11,42 @@ export type Template = {
     id: number;
     /** Name of the public template */
     name: string;
-    /** Human-readable description of what the template does, or null if not set */
+    /** Human-readable description of what the public 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 */
+    /** List of app identifiers used in the public template */
     usedApps: string[];
-    /** Number of times this template has been used */
+    /** Number of times this public 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.
+ * Blueprint payload returned by the public-template blueprint endpoint.
+ * Wraps the scenario blueprint together with its scheduling and controller configuration.
  */
 export type TemplateBlueprint = {
-    /** The scenario blueprint definition */
-    blueprint: Record<string, unknown>;
+    /** The scenario blueprint definition (modules, flow, metadata). Scheduling is exposed at the top level of this payload instead. */
+    blueprint: Omit<Blueprint, 'scheduling' | 'interface'>;
     /** Controller configuration for the scenario */
-    controller: Record<string, unknown>;
+    controller: {
+        /** Controller name */
+        name: string;
+        /** Controller-tracked module state, keyed by module ID */
+        modules: Record<string, unknown>;
+        /** Next ID to assign when adding a module */
+        idSequence: number;
+    };
     /** Scheduling configuration for the scenario */
-    scheduling: Record<string, unknown>;
-    /** Language code for the template */
+    scheduling: Scheduling;
+    /** Language code for the public template (e.g. "en") */
     language: string;
-    /** Additional metadata for the template, or null if not set */
+    /** Additional metadata for the public template, or null if not set */
     metadata: Record<string, unknown> | null;
 };
 
 /**
- * Options for listing public approved templates.
+ * 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> = {
@@ -45,11 +54,11 @@ export type ListTemplatesOptions<C extends keyof Template = never> = {
     cols?: C[] | ['*'];
     /** Pagination options */
     pg?: Partial<Pagination<Template>>;
-    /** Search templates by name */
+    /** Search public templates by name */
     name?: string;
-    /** Filter templates by apps used */
+    /** Filter public templates by apps used */
     usedApps?: string[];
-    /** Whether to include English-language templates in results */
+    /** Whether to include English-language public templates in results */
     includeEn?: boolean;
 };
 
@@ -154,7 +163,7 @@ export class Templates {
     }
 
     /**
-     * Get the blueprint (scenario definition) for a public template.
+     * Get the blueprint (scenario definition) for a public template by its URL slug.
      * 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")
diff --git a/src/make.ts b/src/make.ts
index 8b110ae..dd073bb 100644
--- a/src/make.ts
+++ b/src/make.ts
@@ -165,9 +165,8 @@ 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
+     * Access to public template endpoints.
+     * Public templates are approved, read-only scenario configurations discoverable and usable by any Make user.
      */
     public readonly templates: Templates;
 
diff --git a/test/mocks/templates/blueprint.json b/test/mocks/templates/blueprint.json
index bac9ad4..ba92222 100644
--- a/test/mocks/templates/blueprint.json
+++ b/test/mocks/templates/blueprint.json
@@ -1,6 +1,6 @@
 {
     "blueprint": {
-        "name": "My Private Template",
+        "name": "Http template example",
         "flow": [
             {
                 "id": 1,
@@ -21,7 +21,7 @@
         }
     },
     "controller": {
-        "name": "My Private Template",
+        "name": "Http template example",
         "modules": {},
         "idSequence": 2
     },
diff --git a/test/templates.integration.test.ts b/test/templates.integration.test.ts
index 6c6c611..6ab29c9 100644
--- a/test/templates.integration.test.ts
+++ b/test/templates.integration.test.ts
@@ -36,6 +36,7 @@ describe('Integration: Templates', () => {
 
     it('Should get a public template by URL slug', async () => {
         const [first] = await make.templates.list({ name: 'http' });
+        expect(first).toBeDefined();
         const template = await make.templates.get(first!.url);
 
         expect(template.id).toBe(first!.id);
@@ -44,6 +45,7 @@ describe('Integration: Templates', () => {
 
     it('Should get a public template blueprint by URL slug', async () => {
         const [first] = await make.templates.list({ name: 'http' });
+        expect(first).toBeDefined();
         const blueprint = await make.templates.getBlueprint(first!.url);
 
         expect(blueprint).toHaveProperty('blueprint');
diff --git a/test/templates.spec.ts b/test/templates.spec.ts
index be3a38c..73d000b 100644
--- a/test/templates.spec.ts
+++ b/test/templates.spec.ts
@@ -18,6 +18,15 @@ describe('Endpoints: Templates', () => {
         expect(result).toStrictEqual(listMock.templatesPublic);
     });
 
+    it('Should serialize usedApps array and includeEn boolean query params', async () => {
+        mockFetch(
+            'GET https://make.local/api/v2/templates/public?usedApps%5B%5D=gmail&usedApps%5B%5D=http&includeEn=true',
+            listMock,
+        );
+        const result = await make.templates.list({ usedApps: ['gmail', 'http'], includeEn: true });
+        expect(result).toStrictEqual(listMock.templatesPublic);
+    });
+
     it('Should get public template by URL slug', async () => {
         mockFetch('GET https://make.local/api/v2/templates/public/13-http-template-example', getMock);
         const result = await make.templates.get('13-http-template-example');

From ab9c170306da1b26d3924b1ecbe642fc593d5a27 Mon Sep 17 00:00:00 2001
From: JanKulhavy <j.kulhavy.ext@make.com>
Date: Sat, 18 Apr 2026 13:08:15 +0200
Subject: [PATCH 13/17] feat(templates): rename templates to public-templates
 and update related types and imports

---
 README.md                                     |  2 +-
 ...mplates.mcp.ts => public-templates.mcp.ts} | 26 +++++-----
 .../{templates.ts => public-templates.ts}     | 48 +++++++++----------
 src/index.ts                                  | 12 ++---
 src/make.ts                                   |  6 +--
 src/mcp.ts                                    |  4 +-
 .../blueprint.json                            |  0
 .../{templates => public-templates}/get.json  |  0
 .../{templates => public-templates}/list.json |  0
 ...s => public-templates.integration.test.ts} |  2 +-
 ...lates.spec.ts => public-templates.spec.ts} |  8 ++--
 11 files changed, 54 insertions(+), 54 deletions(-)
 rename src/endpoints/{templates.mcp.ts => public-templates.mcp.ts} (76%)
 rename src/endpoints/{templates.ts => public-templates.ts} (77%)
 rename test/mocks/{templates => public-templates}/blueprint.json (100%)
 rename test/mocks/{templates => public-templates}/get.json (100%)
 rename test/mocks/{templates => public-templates}/list.json (100%)
 rename test/{templates.integration.test.ts => public-templates.integration.test.ts} (97%)
 rename test/{templates.spec.ts => public-templates.spec.ts} (87%)

diff --git a/README.md b/README.md
index 9f3e958..24569d7 100644
--- a/README.md
+++ b/README.md
@@ -203,7 +203,7 @@ All tools are organized into the following categories:
 - `organizations`
 - `scenarios`
 - `teams`
-- `templates`
+- `public-templates`
 - `users`
 - `sdk.apps`
 - `sdk.connections`
diff --git a/src/endpoints/templates.mcp.ts b/src/endpoints/public-templates.mcp.ts
similarity index 76%
rename from src/endpoints/templates.mcp.ts
rename to src/endpoints/public-templates.mcp.ts
index 34279b2..da5f365 100644
--- a/src/endpoints/templates.mcp.ts
+++ b/src/endpoints/public-templates.mcp.ts
@@ -2,11 +2,11 @@ import type { Make } from '../make.js';
 
 export const tools = [
     {
-        name: 'templates_list',
+        name: 'public-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',
+        category: 'public-templates',
         scope: 'templates:read',
         annotations: {
             readOnlyHint: true,
@@ -14,15 +14,15 @@ export const tools = [
         inputSchema: {
             type: 'object',
             properties: {
-                name: { type: 'string', description: 'Search templates by name' },
+                name: { type: 'string', description: 'Search public templates by name' },
                 usedApps: {
                     type: 'array',
                     items: { type: 'string' },
-                    description: 'Filter templates by apps used',
+                    description: 'Filter public templates by apps used',
                 },
                 includeEn: {
                     type: 'boolean',
-                    description: 'Whether to include English-language templates in results',
+                    description: 'Whether to include English-language public templates in results',
                 },
             },
         },
@@ -32,11 +32,11 @@ export const tools = [
         },
     },
     {
-        name: 'templates_get',
+        name: 'public-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',
+            '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 public-templates_list.',
+        category: 'public-templates',
         scope: 'templates:read',
         identifier: 'templateUrl',
         annotations: {
@@ -47,7 +47,7 @@ export const tools = [
             properties: {
                 templateUrl: {
                     type: 'string',
-                    description: 'The URL slug of the template (e.g. "12289-add-webhook-data-to-a-google-sheet")',
+                    description: 'The URL slug of the public template (e.g. "12289-add-webhook-data-to-a-google-sheet")',
                 },
             },
             required: ['templateUrl'],
@@ -58,11 +58,11 @@ export const tools = [
         },
     },
     {
-        name: 'templates_get-blueprint',
+        name: 'public-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',
+            'Get the full blueprint of a public template including scenario flow, controller configuration, scheduling, and metadata. Use this for templates discovered via public-templates_list.',
+        category: 'public-templates',
         scope: 'templates:read',
         identifier: 'templateUrl',
         annotations: {
@@ -73,7 +73,7 @@ export const tools = [
             properties: {
                 templateUrl: {
                     type: 'string',
-                    description: 'The URL slug of the template (e.g. "12289-add-webhook-data-to-a-google-sheet")',
+                    description: 'The URL slug of the public template (e.g. "12289-add-webhook-data-to-a-google-sheet")',
                 },
             },
             required: ['templateUrl'],
diff --git a/src/endpoints/templates.ts b/src/endpoints/public-templates.ts
similarity index 77%
rename from src/endpoints/templates.ts
rename to src/endpoints/public-templates.ts
index eadb799..7e93302 100644
--- a/src/endpoints/templates.ts
+++ b/src/endpoints/public-templates.ts
@@ -6,7 +6,7 @@ import type { Scheduling } from './scenarios.js';
  * Represents a publicly available approved template in Make.
  * Public templates can be discovered and used by all Make users.
  */
-export type Template = {
+export type PublicTemplate = {
     /** Unique identifier of the public template */
     id: number;
     /** Name of the public template */
@@ -25,7 +25,7 @@ export type Template = {
  * Blueprint payload returned by the public-template blueprint endpoint.
  * Wraps the scenario blueprint together with its scheduling and controller configuration.
  */
-export type TemplateBlueprint = {
+export type PublicTemplateBlueprint = {
     /** The scenario blueprint definition (modules, flow, metadata). Scheduling is exposed at the top level of this payload instead. */
     blueprint: Omit<Blueprint, 'scheduling' | 'interface'>;
     /** Controller configuration for the scenario */
@@ -47,13 +47,13 @@ export type TemplateBlueprint = {
 
 /**
  * Options for listing public (approved) templates.
- * @template C Keys of the Template type to include in the response
+ * @template C Keys of the PublicTemplate type to include in the response
  */
-export type ListTemplatesOptions<C extends keyof Template = never> = {
+export type ListPublicTemplatesOptions<C extends keyof PublicTemplate = never> = {
     /** Specific columns/fields to include in the response */
     cols?: C[] | ['*'];
     /** Pagination options */
-    pg?: Partial<Pagination<Template>>;
+    pg?: Partial<Pagination<PublicTemplate>>;
     /** Search public templates by name */
     name?: string;
     /** Filter public templates by apps used */
@@ -64,9 +64,9 @@ export type ListTemplatesOptions<C extends keyof Template = never> = {
 
 /**
  * Options for getting a single public template.
- * @template C Keys of the Template type to include in the response
+ * @template C Keys of the PublicTemplate type to include in the response
  */
-export type GetTemplateOptions<C extends keyof Template = never> = {
+export type GetPublicTemplateOptions<C extends keyof PublicTemplate = never> = {
     /** Specific columns/fields to include in the response */
     cols?: C[] | ['*'];
 };
@@ -74,19 +74,19 @@ export type GetTemplateOptions<C extends keyof Template = never> = {
 /**
  * Response format for listing public templates.
  */
-type ListTemplatesResponse<C extends keyof Template = never> = {
+type ListPublicTemplatesResponse<C extends keyof PublicTemplate = never> = {
     /** List of public templates matching the query */
-    templatesPublic: PickColumns<Template, C>[];
+    templatesPublic: PickColumns<PublicTemplate, C>[];
     /** Pagination information */
-    pg: Pagination<Template>;
+    pg: Pagination<PublicTemplate>;
 };
 
 /**
  * Response format for getting a single public template.
  */
-type GetTemplateResponse<C extends keyof Template = never> = {
+type GetPublicTemplateResponse<C extends keyof PublicTemplate = never> = {
     /** The requested public template */
-    templatePublic: PickColumns<Template, C>;
+    templatePublic: PickColumns<PublicTemplate, C>;
 };
 
 /**
@@ -94,11 +94,11 @@ type GetTemplateResponse<C extends keyof Template = never> = {
  * Public templates are approved scenario configurations that can be
  * discovered and used by any Make user.
  */
-export class Templates {
+export class PublicTemplates {
     readonly #fetch: FetchFunction;
 
     /**
-     * Create a new Templates instance.
+     * Create a new PublicTemplates instance.
      * @param fetch Function for making API requests
      */
     constructor(fetch: FetchFunction) {
@@ -121,11 +121,11 @@ export class Templates {
      * const gmailTemplates = await make.templates.list({ usedApps: ['gmail'] });
      * ```
      */
-    async list<C extends keyof Template = never>(
-        options: ListTemplatesOptions<C> = {},
-    ): Promise<PickColumns<Template, C>[]> {
+    async list<C extends keyof PublicTemplate = never>(
+        options: ListPublicTemplatesOptions<C> = {},
+    ): Promise<PickColumns<PublicTemplate, C>[]> {
         return (
-            await this.#fetch<ListTemplatesResponse<C>>('/templates/public', {
+            await this.#fetch<ListPublicTemplatesResponse<C>>('/templates/public', {
                 query: {
                     name: options.name,
                     usedApps: options.usedApps,
@@ -149,12 +149,12 @@ export class Templates {
      * const template = await make.templates.get('12289-add-webhook-data-to-a-google-sheet');
      * ```
      */
-    async get<C extends keyof Template = never>(
+    async get<C extends keyof PublicTemplate = never>(
         templateUrl: string,
-        options: GetTemplateOptions<C> = {},
-    ): Promise<PickColumns<Template, C>> {
+        options: GetPublicTemplateOptions<C> = {},
+    ): Promise<PickColumns<PublicTemplate, C>> {
         return (
-            await this.#fetch<GetTemplateResponse<C>>(`/templates/public/${templateUrl}`, {
+            await this.#fetch<GetPublicTemplateResponse<C>>(`/templates/public/${templateUrl}`, {
                 query: {
                     cols: options.cols,
                 },
@@ -174,7 +174,7 @@ export class Templates {
      * 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`);
+    async getBlueprint(templateUrl: string): Promise<PublicTemplateBlueprint> {
+        return await this.#fetch<PublicTemplateBlueprint>(`/templates/public/${templateUrl}/blueprint`);
     }
 }
diff --git a/src/index.ts b/src/index.ts
index 3871476..31b88cd 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -167,10 +167,10 @@ export type {
 } 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';
+    PublicTemplate,
+    PublicTemplateBlueprint,
+    PublicTemplates,
+    ListPublicTemplatesOptions,
+    GetPublicTemplateOptions,
+} from './endpoints/public-templates.js';
 export type { User, Users } from './endpoints/users.js';
diff --git a/src/make.ts b/src/make.ts
index dd073bb..07c8345 100644
--- a/src/make.ts
+++ b/src/make.ts
@@ -15,7 +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 { PublicTemplates } from './endpoints/public-templates.js';
 import { SDKApps } from './endpoints/sdk/apps.js';
 import { SDKModules } from './endpoints/sdk/modules.js';
 import { SDKConnections } from './endpoints/sdk/connections.js';
@@ -168,7 +168,7 @@ export class Make {
      * Access to public template endpoints.
      * Public templates are approved, read-only scenario configurations discoverable and usable by any Make user.
      */
-    public readonly templates: Templates;
+    public readonly templates: PublicTemplates;
 
     /**
      * Access to SDK-related endpoints
@@ -255,7 +255,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.templates = new PublicTemplates(this.fetch.bind(this));
         this.sdk = {
             apps: new SDKApps(this.fetch.bind(this)),
             modules: new SDKModules(this.fetch.bind(this)),
diff --git a/src/mcp.ts b/src/mcp.ts
index c6e653e..bbf4cb6 100644
--- a/src/mcp.ts
+++ b/src/mcp.ts
@@ -25,7 +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';
+import { tools as PublicTemplatesTools } from './endpoints/public-templates.mcp.js';
 
 /**
  * JSON Schema definition for input parameters.
@@ -150,5 +150,5 @@ export const MakeMCPTools = [
     ...OrganizationsTools,
     ...UsersTools,
     ...EnumsTools,
-    ...TemplatesTools,
+    ...PublicTemplatesTools,
 ] as MakeMCPTool[];
diff --git a/test/mocks/templates/blueprint.json b/test/mocks/public-templates/blueprint.json
similarity index 100%
rename from test/mocks/templates/blueprint.json
rename to test/mocks/public-templates/blueprint.json
diff --git a/test/mocks/templates/get.json b/test/mocks/public-templates/get.json
similarity index 100%
rename from test/mocks/templates/get.json
rename to test/mocks/public-templates/get.json
diff --git a/test/mocks/templates/list.json b/test/mocks/public-templates/list.json
similarity index 100%
rename from test/mocks/templates/list.json
rename to test/mocks/public-templates/list.json
diff --git a/test/templates.integration.test.ts b/test/public-templates.integration.test.ts
similarity index 97%
rename from test/templates.integration.test.ts
rename to test/public-templates.integration.test.ts
index 6ab29c9..2a9f066 100644
--- a/test/templates.integration.test.ts
+++ b/test/public-templates.integration.test.ts
@@ -5,7 +5,7 @@ import { Make } from '../src/make.js';
 const MAKE_API_KEY = String(process.env.MAKE_API_KEY || '');
 const MAKE_ZONE = String(process.env.MAKE_ZONE || '');
 
-describe('Integration: Templates', () => {
+describe('Integration: PublicTemplates', () => {
     const make = new Make(MAKE_API_KEY, MAKE_ZONE);
 
     it('Should list public templates', async () => {
diff --git a/test/templates.spec.ts b/test/public-templates.spec.ts
similarity index 87%
rename from test/templates.spec.ts
rename to test/public-templates.spec.ts
index 73d000b..602c66e 100644
--- a/test/templates.spec.ts
+++ b/test/public-templates.spec.ts
@@ -2,14 +2,14 @@ import { describe, expect, it } from '@jest/globals';
 import { Make } from '../src/make.js';
 import { mockFetch } from './test.utils.js';
 
-import * as listMock from './mocks/templates/list.json';
-import * as getMock from './mocks/templates/get.json';
-import * as blueprintMock from './mocks/templates/blueprint.json';
+import * as listMock from './mocks/public-templates/list.json';
+import * as getMock from './mocks/public-templates/get.json';
+import * as blueprintMock from './mocks/public-templates/blueprint.json';
 
 const MAKE_API_KEY = 'api-key';
 const MAKE_ZONE = 'make.local';
 
-describe('Endpoints: Templates', () => {
+describe('Endpoints: PublicTemplates', () => {
     const make = new Make(MAKE_API_KEY, MAKE_ZONE);
 
     it('Should list public templates with name search', async () => {

From d333930f1a5baa5d2ef87a39bf5f96bd3ae3ea60 Mon Sep 17 00:00:00 2001
From: JanKulhavy <132362423+JanKulhavy@users.noreply.github.com>
Date: Sat, 18 Apr 2026 13:15:33 +0200
Subject: [PATCH 14/17] Update src/endpoints/public-templates.mcp.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 src/endpoints/public-templates.mcp.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/endpoints/public-templates.mcp.ts b/src/endpoints/public-templates.mcp.ts
index da5f365..52bf5ed 100644
--- a/src/endpoints/public-templates.mcp.ts
+++ b/src/endpoints/public-templates.mcp.ts
@@ -27,8 +27,8 @@ export const tools = [
             },
         },
         examples: [{ name: 'webhook' }],
-        execute: async (make: Make, args: { name?: string; usedApps?: string[]; includeEn?: boolean }) => {
-            return await make.templates.list({ ...args, cols: ['*'] });
+        execute: async (make: Make, args?: { name?: string; usedApps?: string[]; includeEn?: boolean }) => {
+            return await make.templates.list({ ...(args ?? {}), cols: ['*'] });
         },
     },
     {

From d9e614298eb2a6263506a707cb52d57c8acf2f8f Mon Sep 17 00:00:00 2001
From: Patrik Simek <patrik@patriksimek.cz>
Date: Sat, 25 Apr 2026 20:24:22 +0200
Subject: [PATCH 15/17] Update test/public-templates.integration.test.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 test/public-templates.integration.test.ts | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/test/public-templates.integration.test.ts b/test/public-templates.integration.test.ts
index 2a9f066..434618b 100644
--- a/test/public-templates.integration.test.ts
+++ b/test/public-templates.integration.test.ts
@@ -37,16 +37,22 @@ describe('Integration: PublicTemplates', () => {
     it('Should get a public template by URL slug', async () => {
         const [first] = await make.templates.list({ name: 'http' });
         expect(first).toBeDefined();
-        const template = await make.templates.get(first!.url);
+        if (!first) {
+            throw new Error('Expected at least one public template matching "http"');
+        }
+        const template = await make.templates.get(first.url);
 
-        expect(template.id).toBe(first!.id);
-        expect(template.url).toBe(first!.url);
+        expect(template.id).toBe(first.id);
+        expect(template.url).toBe(first.url);
     });
 
     it('Should get a public template blueprint by URL slug', async () => {
         const [first] = await make.templates.list({ name: 'http' });
         expect(first).toBeDefined();
-        const blueprint = await make.templates.getBlueprint(first!.url);
+        if (!first) {
+            throw new Error('Expected at least one public template matching "http"');
+        }
+        const blueprint = await make.templates.getBlueprint(first.url);
 
         expect(blueprint).toHaveProperty('blueprint');
         expect(blueprint).toHaveProperty('scheduling');

From 87d394ee83cd515dadcbcdee22805321ab51edb2 Mon Sep 17 00:00:00 2001
From: Patrik Simek <patrik@patriksimek.cz>
Date: Sat, 25 Apr 2026 21:11:33 +0200
Subject: [PATCH 16/17] refactor: rename templates to publicTemplates for
 consistency

---
 README.md   | 2 +-
 src/make.ts | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index fde2157..aebe0e3 100644
--- a/README.md
+++ b/README.md
@@ -63,7 +63,7 @@ const make = new Make('your-api-key', 'eu2.make.com', {
 - **Organizations** - Top-level account and billing management
 - **Scenarios** - Scenario management
 - **Teams** - Team management and collaboration
-- **Templates** - Public template discovery and blueprint export (read-only)
+- **Public Templates** - Public template discovery and blueprint export (read-only)
 - **Users** - Current user information and authentication
 
 ## Custom Apps Development Endpoints
diff --git a/src/make.ts b/src/make.ts
index 07c8345..8e8a903 100644
--- a/src/make.ts
+++ b/src/make.ts
@@ -168,7 +168,7 @@ export class Make {
      * Access to public template endpoints.
      * Public templates are approved, read-only scenario configurations discoverable and usable by any Make user.
      */
-    public readonly templates: PublicTemplates;
+    public readonly publicTemplates: PublicTemplates;
 
     /**
      * Access to SDK-related endpoints
@@ -255,7 +255,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 PublicTemplates(this.fetch.bind(this));
+        this.publicTemplates = new PublicTemplates(this.fetch.bind(this));
         this.sdk = {
             apps: new SDKApps(this.fetch.bind(this)),
             modules: new SDKModules(this.fetch.bind(this)),

From 82fe4fb68ce1039efc68e5125bd5d09993ab6d79 Mon Sep 17 00:00:00 2001
From: Patrik Simek <patrik@patriksimek.cz>
Date: Sat, 25 Apr 2026 21:14:09 +0200
Subject: [PATCH 17/17] refactor: rename templates to publicTemplates for
 consistency

---
 src/endpoints/public-templates.tools.ts   | 12 +++++++-----
 src/endpoints/public-templates.ts         |  8 ++++----
 test/public-templates.integration.test.ts | 14 +++++++-------
 test/public-templates.spec.ts             | 13 +++++--------
 4 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/src/endpoints/public-templates.tools.ts b/src/endpoints/public-templates.tools.ts
index 9abf1f9..4e06fc2 100644
--- a/src/endpoints/public-templates.tools.ts
+++ b/src/endpoints/public-templates.tools.ts
@@ -28,7 +28,7 @@ export const tools = [
         },
         examples: [{ name: 'webhook' }],
         execute: async (make: Make, args?: { name?: string; usedApps?: string[]; includeEn?: boolean }) => {
-            return await make.templates.list({ ...(args ?? {}), cols: ['*'] });
+            return await make.publicTemplates.list({ ...(args ?? {}), cols: ['*'] });
         },
     },
     {
@@ -49,14 +49,15 @@ export const tools = [
             properties: {
                 templateUrl: {
                     type: 'string',
-                    description: 'The URL slug of the public template (e.g. "12289-add-webhook-data-to-a-google-sheet")',
+                    description:
+                        'The URL slug of the public 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: ['*'] });
+            return await make.publicTemplates.get(args.templateUrl, { cols: ['*'] });
         },
     },
     {
@@ -77,14 +78,15 @@ export const tools = [
             properties: {
                 templateUrl: {
                     type: 'string',
-                    description: 'The URL slug of the public template (e.g. "12289-add-webhook-data-to-a-google-sheet")',
+                    description:
+                        'The URL slug of the public 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);
+            return await make.publicTemplates.getBlueprint(args.templateUrl);
         },
     },
 ];
diff --git a/src/endpoints/public-templates.ts b/src/endpoints/public-templates.ts
index 7e93302..53d142e 100644
--- a/src/endpoints/public-templates.ts
+++ b/src/endpoints/public-templates.ts
@@ -115,10 +115,10 @@ export class PublicTemplates {
      * @example
      * ```typescript
      * // Search public templates by name
-     * const templates = await make.templates.list({ name: 'webhook' });
+     * const templates = await make.publicTemplates.list({ name: 'webhook' });
      *
      * // Filter by apps used
-     * const gmailTemplates = await make.templates.list({ usedApps: ['gmail'] });
+     * const gmailTemplates = await make.publicTemplates.list({ usedApps: ['gmail'] });
      * ```
      */
     async list<C extends keyof PublicTemplate = never>(
@@ -146,7 +146,7 @@ export class PublicTemplates {
      *
      * @example
      * ```typescript
-     * const template = await make.templates.get('12289-add-webhook-data-to-a-google-sheet');
+     * const template = await make.publicTemplates.get('12289-add-webhook-data-to-a-google-sheet');
      * ```
      */
     async get<C extends keyof PublicTemplate = never>(
@@ -171,7 +171,7 @@ export class PublicTemplates {
      *
      * @example
      * ```typescript
-     * const blueprint = await make.templates.getBlueprint('12289-add-webhook-data-to-a-google-sheet');
+     * const blueprint = await make.publicTemplates.getBlueprint('12289-add-webhook-data-to-a-google-sheet');
      * ```
      */
     async getBlueprint(templateUrl: string): Promise<PublicTemplateBlueprint> {
diff --git a/test/public-templates.integration.test.ts b/test/public-templates.integration.test.ts
index 434618b..6716ece 100644
--- a/test/public-templates.integration.test.ts
+++ b/test/public-templates.integration.test.ts
@@ -9,7 +9,7 @@ describe('Integration: PublicTemplates', () => {
     const make = new Make(MAKE_API_KEY, MAKE_ZONE);
 
     it('Should list public templates', async () => {
-        const templates = await make.templates.list();
+        const templates = await make.publicTemplates.list();
 
         expect(Array.isArray(templates)).toBe(true);
         expect(templates.length).toBeGreaterThan(0);
@@ -20,7 +20,7 @@ describe('Integration: PublicTemplates', () => {
     });
 
     it('Should search public templates by name', async () => {
-        const templates = await make.templates.list({ name: 'http' });
+        const templates = await make.publicTemplates.list({ name: 'http' });
 
         expect(Array.isArray(templates)).toBe(true);
         expect(templates.length).toBeGreaterThan(0);
@@ -29,30 +29,30 @@ describe('Integration: PublicTemplates', () => {
     });
 
     it('Should search public templates with usedApps filter', async () => {
-        const templates = await make.templates.list({ usedApps: ['http'] });
+        const templates = await make.publicTemplates.list({ usedApps: ['http'] });
 
         expect(Array.isArray(templates)).toBe(true);
     });
 
     it('Should get a public template by URL slug', async () => {
-        const [first] = await make.templates.list({ name: 'http' });
+        const [first] = await make.publicTemplates.list({ name: 'http' });
         expect(first).toBeDefined();
         if (!first) {
             throw new Error('Expected at least one public template matching "http"');
         }
-        const template = await make.templates.get(first.url);
+        const template = await make.publicTemplates.get(first.url);
 
         expect(template.id).toBe(first.id);
         expect(template.url).toBe(first.url);
     });
 
     it('Should get a public template blueprint by URL slug', async () => {
-        const [first] = await make.templates.list({ name: 'http' });
+        const [first] = await make.publicTemplates.list({ name: 'http' });
         expect(first).toBeDefined();
         if (!first) {
             throw new Error('Expected at least one public template matching "http"');
         }
-        const blueprint = await make.templates.getBlueprint(first.url);
+        const blueprint = await make.publicTemplates.getBlueprint(first.url);
 
         expect(blueprint).toHaveProperty('blueprint');
         expect(blueprint).toHaveProperty('scheduling');
diff --git a/test/public-templates.spec.ts b/test/public-templates.spec.ts
index 602c66e..1bb0c9b 100644
--- a/test/public-templates.spec.ts
+++ b/test/public-templates.spec.ts
@@ -14,7 +14,7 @@ describe('Endpoints: PublicTemplates', () => {
 
     it('Should list public templates with name search', async () => {
         mockFetch('GET https://make.local/api/v2/templates/public?name=Http', listMock);
-        const result = await make.templates.list({ name: 'Http' });
+        const result = await make.publicTemplates.list({ name: 'Http' });
         expect(result).toStrictEqual(listMock.templatesPublic);
     });
 
@@ -23,22 +23,19 @@ describe('Endpoints: PublicTemplates', () => {
             'GET https://make.local/api/v2/templates/public?usedApps%5B%5D=gmail&usedApps%5B%5D=http&includeEn=true',
             listMock,
         );
-        const result = await make.templates.list({ usedApps: ['gmail', 'http'], includeEn: true });
+        const result = await make.publicTemplates.list({ usedApps: ['gmail', 'http'], includeEn: true });
         expect(result).toStrictEqual(listMock.templatesPublic);
     });
 
     it('Should get public template by URL slug', async () => {
         mockFetch('GET https://make.local/api/v2/templates/public/13-http-template-example', getMock);
-        const result = await make.templates.get('13-http-template-example');
+        const result = await make.publicTemplates.get('13-http-template-example');
         expect(result).toStrictEqual(getMock.templatePublic);
     });
 
     it('Should get public template blueprint by URL slug', async () => {
-        mockFetch(
-            'GET https://make.local/api/v2/templates/public/13-http-template-example/blueprint',
-            blueprintMock,
-        );
-        const result = await make.templates.getBlueprint('13-http-template-example');
+        mockFetch('GET https://make.local/api/v2/templates/public/13-http-template-example/blueprint', blueprintMock);
+        const result = await make.publicTemplates.getBlueprint('13-http-template-example');
         expect(result).toStrictEqual(blueprintMock);
     });
 });