Templated API

https://templated.io/docs
Admin
The Templated API automates the generation of images, videos, and PDFs, providing a simple interface...
Tokens:86,958
Snippets:708
Trust Score:8.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Branding Setup

Source: https://templated.io/docs/embed/configuration.md

Customize the editor's appearance by providing URLs for your logo and its link, and specifying an accent color.

```html
Logo URL: https://yourdomain.com/logo.png
Logo Link: https://yourdomain.com/dashboard
Accent Color: #FF6B35
```

--------------------------------

### List All Renders in Java

Source: https://templated.io/docs/renders/list.md

This Java example demonstrates how to make an HTTP GET request to list renders. It handles the response and potential exceptions.

```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URLEncoder;

public class ListRenders {
    public static void main(String[] args) {
        try {
            String apiKey = "API_KEY";
            URL url = new URL("https://api.templated.io/v1/renders");
            
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setRequestProperty("Authorization", "Bearer " + apiKey);

            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                System.out.println(response.toString());
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Complete Templated.io Embed Example

Source: https://templated.io/docs/embed/form-mode.md

This comprehensive example demonstrates how to embed the Templated.io editor, listen for events, and control form mode and panel position using JavaScript. It includes initial URL-based loading and interactive buttons to trigger these actions.

```html
<iframe id="template-embed" width="100%" height="700" frameborder="0"></iframe>
<div>
  <button onclick="toggleFormMode()">Toggle Form Mode</button>
  <button onclick="switchPanelPosition()">Switch Panel Position</button>
</div>

<script>
  const iframe = document.getElementById('template-embed');
  const CONFIG_ID = 'YOUR_EMBED_CONFIG_ID';
  const TEMPLATE_ID = 'tpl_ABC123';

  let formEnabled = true;
  let panelPosition = 'right';

  // 1) Initial URL-based load
  const url = new URL(`https://app.templated.io/editor/form/${TEMPLATE_ID}`);
  url.searchParams.set('embed', CONFIG_ID);
  url.searchParams.set('form-panel-position', 'right');
  iframe.src = url.toString();

  // 2) Listen for editor events
  window.addEventListener('message', (event) => {
    const msg = event.data;
    console.log('Received message:', msg);

    switch (msg?.type) {
      case 'EDITOR_READY':
        console.log('Editor ready for interactions');
        break;

      case 'FORM_MODE_UPDATED':
        formEnabled = msg.enabled;
        console.log('Form mode:', formEnabled ? 'enabled' : 'disabled');
        break;

      case 'FORM_PANEL_POSITION_UPDATED':
        panelPosition = msg.position;
        console.log('Panel position:', panelPosition);
        break;

      case 'FORM_VALUES_CHANGED':
        console.log('Form values changed:', msg.data);
        break;

      case 'FORM_RENDER_REQUESTED':
        console.log('Render requested:', msg.format, msg.templateId);
        break;
    }
  });

  // 3) Control functions
  function toggleFormMode() {
    formEnabled = !formEnabled;
    iframe.contentWindow.postMessage({
      type: 'SET_FORM_MODE',
      enabled: formEnabled
    }, '*');
  }

  function switchPanelPosition() {
    panelPosition = panelPosition === 'right' ? 'left' : 'right';
    iframe.contentWindow.postMessage({
      type: 'SET_FORM_PANEL_POSITION',
      position: panelPosition
    }, '*');
  }
</script>
```

--------------------------------

### Comprehensive Templated.io Embed Example

Source: https://templated.io/docs/embed/preview-mode.md

This example demonstrates how to embed a Templated.io preview, load an initial template via URL with various flags, and interact with the editor using postMessage for dynamic updates and controls. It includes event listeners for editor feedback and functions to toggle layer move, layer resize, text editing, update content, and save the template.

```html
<iframe id="template-embed" width="100%" height="700" frameborder="0"></iframe>
<div>
  <button onclick="toggleLayerMove()">Toggle Layer Move</button>
  <button onclick="toggleLayerResize()">Toggle Layer Resize</button>
  <button onclick="toggleTextEditing()">Toggle Text Editing</button>
  <button onclick="updateContent()">Update Content</button>
  <button onclick="saveTemplate()">Save Template</button>
</div>

<script>
  const iframe = document.getElementById('template-embed');
  const CONFIG_ID = 'YOUR_EMBED_CONFIG_ID';
  const FIRST_TEMPLATE = 'tpl_ABC123';
  
  let layerMoveEnabled = false;
  let layerResizeEnabled = false;
  let textEditingEnabled = false;

  // 1) Initial URL-based load with multiple flags
  const url = new URL(`https://app.templated.io/editor/preview/${FIRST_TEMPLATE}`);
  url.searchParams.set('embed', CONFIG_ID);
  url.searchParams.set('zoom', '50'); // 50 = 100% scale
  url.searchParams.set('allow-layer-move', 'true');
  url.searchParams.set('allow-text-edition', 'true');
  url.searchParams.set('hide-sidebar', 'true');
  url.searchParams.set('clone', 'true'); // Work with a clone
  url.searchParams.set('external-id', 'user-demo-session'); // Persistent session
  iframe.src = url.toString();

  // 2) Listen for editor events
  window.addEventListener('message', (event) => {
    const msg = event.data;
    console.log('Received message:', msg);
    
    switch (msg?.type) {
      case 'EDITOR_READY':
        console.log('✅ Editor ready for interactions');
        // Initialize with some content
        updateContent();
        break;
      
      case 'TEMPLATE_LOADED':
        console.log('📄 Template loaded:', msg.template);
        break;
        
      case 'TEMPLATE_SAVED_SUCCESS':
        console.log('💾 Template saved successfully:', msg.templateId);
        alert('Template saved successfully!');
        break;
        
      case 'TEMPLATE_SAVE_ERROR':
        console.error('❌ Save failed:', msg.error);
        alert('Failed to save template: ' + msg.error);
        break;
        
      case 'LAYERS_UPDATED':
        console.log('✅ Layers updated successfully');
        break;
        
      case 'ALLOW_LAYER_MOVE_UPDATED':
        layerMoveEnabled = msg.allowLayerMove;
        console.log('🚀 Layer move:', layerMoveEnabled ? 'enabled' : 'disabled');
        break;
        
      case 'ALLOW_LAYER_RESIZE_UPDATED':
        layerResizeEnabled = msg.allowLayerResize;
        console.log('🔄 Layer resize:', layerResizeEnabled ? 'enabled' : 'disabled');
        break;
        
      case 'ALLOW_TEXT_EDITION_UPDATED':
        textEditingEnabled = msg.allowTextEdition;
        console.log('✏️ Text editing:', textEditingEnabled ? 'enabled' : 'disabled');
        break;
    }
  });

  // 3) Control functions
  function toggleLayerMove() {
    layerMoveEnabled = !layerMoveEnabled;
    iframe.contentWindow.postMessage({
      type: 'SET_ALLOW_LAYER_MOVE',
      allowLayerMove: layerMoveEnabled
    }, '*');
  }

  function toggleLayerResize() {
    layerResizeEnabled = !layerResizeEnabled;
    iframe.contentWindow.postMessage({
      type: 'SET_ALLOW_LAYER_RESIZE',
      allowLayerResize: layerResizeEnabled
    }, '*');
  }

  function toggleTextEditing() {
    textEditingEnabled = !textEditingEnabled;
    iframe.contentWindow.postMessage({
      type: 'SET_ALLOW_TEXT_EDITION',
      allowTextEdition: textEditingEnabled
    }, '*');
  }

  function updateContent() {
    iframe.contentWindow.postMessage({
      type: 'UPDATE_LAYERS',
      data: {
        'headline': {
          text: 'Updated at ' + new Date().toLocaleTimeString(),
          color: '#FF6B35'
        },
        'description': {
          text: 'This content was updated via postMessage API',
          color: '#333333'
        },
        'background': {
          fill: '#F0F8FF'
        }
      }
    }, '*');
  }

  function saveTemplate() {
    iframe.contentWindow.postMessage({ type: 'SAVE' }, '*');
  }
</script>
```

--------------------------------

### Example Domain Configuration

Source: https://templated.io/docs/embed/configuration.md

Specify the domain where your embed will be displayed. Ensure the protocol (https:// or http://) is included.

```html
https://yourdomain.com
```

--------------------------------

### Grouped Layers Example

Source: https://templated.io/docs/templates/create.md

This example demonstrates how to group layers together by assigning them the same 'group' property. Grouped layers are treated as a single unit in the Editor.

```json
{
  "layers": [
    {
      "layer": "title",
      "type": "text",
      "group": "header",
      "text": "Hello World",
      "x": 100,
      "y": 100,
      "width": 400,
      "height": 90
    },
    {
      "layer": "logo",
      "type": "image",
      "group": "header",
      "image_url": "https://example.com/logo.png",
      "x": 100,
      "y": 220,
      "width": 200,
      "height": 200
    },
    {
      "layer": "footer",
      "type": "text",
      "text": "This layer is not grouped",
      "x": 100,
      "y": 900,
      "width": 500,
      "height": 50
    }
  ]
}
```

--------------------------------

### Render API Response Example

Source: https://templated.io/docs/renders/create.md

This is an example of the JSON response received after a successful render request.

```json
{
  "id": "ce424057-6b54-41bb-afec-adc35a2b9175",
  "url": "https://templated-assets.s3.amazonaws.com/renders/ce424057-6b54-41bb-afec-adc35a2b9175.jpg",
  "width": 1920,
  "height": 1080,
  "format": "jpg",
  "templateId": "1f1231-dasd123-fsdf12312-fds4123-asdas23",
  "templateName": "Sample Template",
  "createdAt": "2025-04-22 08:30:58",
  "externalId": null
}
```

--------------------------------

### List Folders with Query Parameters (Java)

Source: https://templated.io/docs/folders/list.md

This Java example shows how to make an API request to list folders, applying filters for name, page, and limit. It handles HTTP connections and response parsing.

```Java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URLEncoder;

public class ListFolders {
    public static void main(String[] args) {
        try {
            String apiKey = "API_KEY";
            
            // Example with all query parameters
            String queryParams = String.format("?query=%s&page=%d&limit=%d",
                URLEncoder.encode("My Folder", "UTF-8"),
                0,
                25
            );
            
            URL url = new URL("https://api.templated.io/v1/folders" + queryParams);
            
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setRequestProperty("Authorization", "Bearer " + apiKey);

            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                System.out.println(response.toString());
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### List Templates with All Query Parameters in Java

Source: https://templated.io/docs/templates/list.md

This Java example shows how to list templates using HttpURLConnection. It includes all query parameters for detailed filtering and pagination. Remember to replace 'API_KEY' with your valid API key.

```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URLEncoder;

public class ListTemplates {
    public static void main(String[] args) {
        try {
            String apiKey = "API_KEY";
            
            // Example with all query parameters
            String queryParams = String.format("?query=%s&page=%d&limit=%d&width=%d&height=%d&externalId=%s&includeLayers=%b",
                URLEncoder.encode("Template Name", "UTF-8"),
                0,
                25,
                1920,
                1080,
                URLEncoder.encode("my-external-id", "UTF-8"),
                true
            );
            
            URL url = new URL("https://api.templated.io/v1/templates" + queryParams);
            
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setRequestProperty("Authorization", "Bearer " + apiKey);

            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                System.out.println(response.toString());
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Python/Flask Webhook Handler

Source: https://templated.io/docs/embed/webhooks.md

Implement a webhook endpoint with Python and Flask. This example demonstrates receiving JSON payloads, extracting action details, and dispatching to specific event handlers. Ensure Flask is installed and the route is correctly configured.

```python
from flask import Flask, request, jsonify
import json
from datetime import datetime

app = Flask(__name__)

@app.route('/api/templated-webhook', methods=['POST'])
def handle_webhook():
    data = request.get_json()
    
    action = data.get('action')
    template_id = data.get('templateId')
    metadata = data.get('metadata', {})
    
    print(f"Received {action} action for template {template_id}")
    
    if action == 'create':
        handle_create_event(template_id, metadata)
    elif action == 'save':
        handle_save_event(template_id, metadata)
    elif action == 'download':
        handle_download_event(template_id, metadata)
    else:
        print(f"Unknown action type: {action}")
    
    return jsonify({'received': True}), 200

def handle_create_event(template_id, metadata):
    # Your create logic here
    print(f"Template {template_id} created")
    if metadata:
        print(f"Metadata: {metadata}")
    
def handle_save_event(template_id, metadata):
    # Your save logic here
    print(f"Template {template_id} saved")
    if metadata:
        print(f"Metadata: {metadata}")
    
def handle_download_event(template_id, metadata):
    # Your download logic here
    print(f"Template {template_id} downloaded")
    if metadata:
        print(f"Metadata: {metadata}")

if __name__ == '__main__':
    app.run(debug=True)
```

--------------------------------

### List Folders with Query Parameters (Python)

Source: https://templated.io/docs/folders/list.md

This Python code demonstrates how to list folders using the API, including filtering by name, pagination, and limiting results. Ensure you have the 'requests' library installed.

```Python
import requests

api_key = 'API_KEY'
url = 'https://api.templated.io/v1/folders'

# Example with all query parameters
params = {
  'query': 'My Folder',
  'page': 0,
  'limit': 25
}

headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get(url, params=params, headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print('Request failed. Response code:', response.status_code)
    print(response.text)
```

--------------------------------

### Folder Response Structure

Source: https://templated.io/docs/folders/list.md

This is an example of the JSON response structure when listing folders. Each object represents a folder with its details.

```JSON
[
  {
    "id": "fld_123abc",
    "name": "My Templates",
    "templateCount": 12,
    "createdAt": "2024-03-20T10:30:00Z",
    "updatedAt": "2024-03-20T10:30:00Z"
  },
  {
    "id": "fld_456def",
    "name": "Brand Assets",
    "templateCount": 5,
    "createdAt": "2024-03-19T15:45:00Z",
    "updatedAt": "2024-03-20T09:15:00Z"
  }
]
```

--------------------------------

### Fetch Account Information with API Key

Source: https://templated.io/docs/account.md

This JavaScript snippet demonstrates how to make a GET request to the account endpoint, including authorization with an API key.

```javascript
fetch('https://api.templated.io/v1/account', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${API_KEY}`
  }
})
```

--------------------------------

### List Folder Templates - Java

Source: https://templated.io/docs/folders/templates.md

A Java example for retrieving templates from a folder via the Templated.io API. It constructs the URL with query parameters and sets the authorization header. Remember to substitute 'id' and 'API_KEY'.

```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URLEncoder;

public class ListFolderTemplates {
    public static void main(String[] args) {
        try {
            String apiKey = "API_KEY";
            String folderId = "id";
            
            // Example with all query parameters
            String queryParams = String.format("?query=%s&page=%d&limit=%d&width=%d&height=%d&includeLayers=%b",
                URLEncoder.encode("Template Name", "UTF-8"),
                0,
                25,
                1920,
                1080,
                true
            );
            
            URL url = new URL("https://api.templated.io/v1/folder/" + folderId + "/templates" + queryParams);
            
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setRequestProperty("Authorization", "Bearer " + apiKey);

            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                System.out.println(response.toString());
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Verify Node.js Version

Source: https://templated.io/docs/integrations/mcp/setup.md

Check if the installed Node.js version meets the minimum requirement of 18.0.0 for the local MCP server.

```bash
# Verify Node.js version
node --version  # Should be 18.0.0 or higher
```

--------------------------------

### Fully Customized Embed URL

Source: https://templated.io/docs/embed/advanced.md

This example demonstrates how to use multiple URL parameters to fully customize the embedded editor's behavior and appearance, including preview mode, zoom level, layer controls, UI elements, cloning, and data embedding.

```html
<embed 
  src="https://app.templated.io/editor/TEMPLATE_ID?embed=CONFIG_ID
       &preview=true
       &zoom=75
       &allow-layer-move=true
       &allow-layer-resize=true
       &allow-text-edition=true
       &hide-sidebar=true
       &clone=true
       &metadata=ENCODED_METADATA
       &layers=ENCODED_LAYERS" 
  width="100%" 
  height="100%" 
/>
```

--------------------------------

### Render Multi-Page Template (Different Content Per Page)

Source: https://templated.io/docs/renders/create.md

This example shows how to render a multi-page template where each page has distinct layer modifications. The `pages` parameter is used to define content for specific pages.

```APIDOC
## POST /v1/render (Multi-Page)

### Description
Renders a multi-page template, allowing for different layer modifications on each page. This is ideal for creating carousels or multi-page documents.

### Method
POST

### Endpoint
/v1/render

### Request Body
- **template** (string) - Required - The ID of the template to render.
- **pages** (array) - Required - An array of page objects, where each object specifies modifications for a particular page.
  - Each page object can contain:
    - **page** (string) - Required - The identifier for the page (e.g., 'page-1', 'cover').
    - **width** (integer) - Optional - The desired width for this specific page.
    - **height** (integer) - Optional - The desired height for this specific page.
    - **layers** (object) - Optional - Layer modifications specific to this page.

### Request Example
```json
{
  "template": "TEMPLATE_ID",
  "pages": [
    {
      "page": "page-1",
      "layers": {
        "title": { "text": "Welcome to Our Company" },
        "subtitle": { "text": "Page 1 Content" }
      }
    },
    {
      "page": "page-2", 
      "layers": {
        "title": { "text": "Our Services" },
        "content": { "text": "We offer amazing services..." }
      }
    },
    {
      "page": "page-3",
      "layers": {
        "title": { "text": "Contact Us" },
        "contact": { "text": "support@company.com" }
      }
    }
  ]
}
```

### Response
(See Success Response and Response Example for the single-page render endpoint, as the structure is similar for multi-page renders, returning details for the primary render output.)
```

--------------------------------

### Multi-Page Template Example

Source: https://templated.io/docs/templates/create.md

This JSON defines a multi-page template named 'Product Brochure' with a cover page and a details page. Each page has specific layers and dimensions.

```json
{
  "name": "Product Brochure",
  "width": 1080,
  "height": 1080,
  "pages": [
    {
      "page": "cover",
      "layers": {
        "background": {
          "type": "image",
          "x": 0,
          "y": 0,
          "width": 1080,
          "height": 1080,
          "image_url": "https://example.com/cover-bg.jpg"
        },
        "title": {
          "type": "text",
          "x": 100,
          "y": 400,
          "width": 880,
          "height": 200,
          "text": "Product Brochure",
          "color": "#ffffff",
          "font_size": "64px",
          "font_family": "Inter"
        }
      }
    },
    {
      "page": "details",
      "layers": {
        "heading": {
          "type": "text",
          "x": 80,
          "y": 60,
          "width": 920,
          "height": 80,
          "text": "Key Features",
          "color": "#333333",
          "font_size": "48px"
        },
        "body": {
          "type": "text",
          "x": 80,
          "y": 180,
          "width": 920,
          "height": 600,
          "text": "Feature descriptions go here...",
          "color": "#666666",
          "font_size": "24px"
        }
      }
    }
  ]
}
```

--------------------------------

### Render Multi-Page Template (Different Dimensions Per Page)

Source: https://templated.io/docs/renders/create.md

This example demonstrates how to specify unique dimensions (width and height) for each page within a multi-page template render. This allows for mixed formats within a single output collection.

```APIDOC
## POST /v1/render (Multi-Page with Dimensions)

### Description
Renders a multi-page template, allowing for different dimensions (width and height) to be specified for each individual page. This is useful for creating collections with mixed aspect ratios or formats.

### Method
POST

### Endpoint
/v1/render

### Request Body
- **template** (string) - Required - The ID of the template to render.
- **pages** (array) - Required - An array of page objects, where each object specifies modifications and dimensions for a particular page.
  - Each page object can contain:
    - **page** (string) - Required - The identifier for the page (e.g., 'cover', 'content').
    - **width** (integer) - Optional - The desired width for this specific page. Falls back to global width, then template default.
    - **height** (integer) - Optional - The desired height for this specific page. Falls back to global height, then template default.
    - **layers** (object) - Optional - Layer modifications specific to this page.

### Request Example
```json
{
  "template": "TEMPLATE_ID",
  "pages": [
    {
      "page": "cover",
      "width": 1920,
      "height": 1080,
      "layers": {
        "title": { "text": "Welcome" }
      }
    },
    {
      "page": "content",
      "width": 1080,
      "height": 1080,
      "layers": {
        "title": { "text": "Our Services" }
      }
    },
    {
      "page": "story",
      "width": 1080,
      "height": 1920,
      "layers": {
        "title": { "text": "Follow Us" }
      }
    }
  ]
}
```

### Response
(See Success Response and Response Example for the single-page render endpoint, as the structure is similar for multi-page renders, returning details for the primary render output.)
```

--------------------------------

### Render Template (Single Page)

Source: https://templated.io/docs/renders/create.md

This example demonstrates how to render a single-page template with common layer modifications. It sends a POST request to the /v1/render endpoint with template ID and layer data.

```APIDOC
## POST /v1/render

### Description
Renders a template with specified layer modifications. This is the basic endpoint for rendering a single page or applying uniform changes across all pages of a multi-page template.

### Method
POST

### Endpoint
/v1/render

### Request Body
- **template** (string) - Required - The ID of the template to render.
- **layers** (object) - Optional - An object containing layer modifications to apply to the template. Each key is a layer name, and its value is an object with properties to update (e.g., `text`, `image_url`).
- **width** (integer) - Optional - The desired width for the rendered output.
- **height** (integer) - Optional - The desired height for the rendered output.

### Request Example
```json
{
  "template": "TEMPLATE_ID",
  "layers": {
    "company_name": { "text": "ACME Corporation" },
    "logo": { "image_url": "https://example.com/logo.png" }
  }
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the render.
- **url** (string) - The URL to access the rendered output.
- **width** (integer) - The width of the rendered output.
- **height** (integer) - The height of the rendered output.
- **format** (string) - The format of the rendered output (e.g., 'jpg', 'png').
- **templateId** (string) - The ID of the template used for rendering.
- **templateName** (string) - The name of the template.
- **createdAt** (string) - The timestamp when the render was created.
- **externalId** (string | null) - An optional external identifier.

#### Response Example
```json
{
  "id": "ce424057-6b54-41bb-afec-adc35a2b9175",
  "url": "https://templated-assets.s3.amazonaws.com/renders/ce424057-6b54-41bb-afec-adc35a2b9175.jpg",
  "width": 1920,
  "height": 1080,
  "format": "jpg",
  "templateId": "1f1231-dasd123-fsdf12312-fds4123-asdas23",
  "templateName": "Sample Template",
  "createdAt": "2025-04-22 08:30:58",
  "externalId": null
}
```
```

--------------------------------

### Merge Renders with External PDFs

Source: https://templated.io/docs/renders/merge.md

This example demonstrates merging both render IDs and external PDF URLs. The 'host' parameter is set to true, and the response logs the URL of the merged PDF.

```javascript
fetch("https://api.templated.io/v1/render/merge", {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${API_KEY}`
  },
  body: JSON.stringify({
    "ids": [
      "render_id_1",
      "render_id_2"
    ],
    "urls": [
      "https://example.com/document1.pdf",
      "https://example.com/document2.pdf"
    ],
    "host": true
  })
})
.then(response => response.json())
.then(data => {
  console.log('Merged PDF URL:', data.url);
});
```

--------------------------------

### List Folder Templates - PHP

Source: https://templated.io/docs/folders/templates.md

This PHP script shows how to call the Templated.io API to list templates in a folder. It demonstrates setting up query parameters and making an HTTP GET request. Remember to replace 'id' and 'API_KEY'.

```php
<?php
$apiKey = 'API_KEY';
$folderId = 'id';

// Example with all query parameters
$params = array(
    'query' => 'Template Name',
    'page' => 0,
    'limit' => 25,
    'width' => 1920,
    'height' => 1080,
    'includeLayers' => 'true'
);

$url = "https://api.templated.io/v1/folder/{$folderId}/templates?" . http_build_query($params);

$options = [
    'http' => [
        'header' => "Authorization: Bearer {$apiKey}\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);

if ($result === FALSE) {
    echo "Error fetching data";
} else {
    $data = json_decode($result, true);
    print_r($data);
}
?>
```

--------------------------------

### Fetch Folder Renders

Source: https://templated.io/docs/folders/renders.md

Use this JavaScript snippet to make a GET request to the Templated.io API to list renders. Ensure you replace `folderId` and `API_KEY` with your actual values. Pagination parameters `page` and `limit` can be adjusted.

```javascript
fetch(`https://api.templated.io/v1/folder/${folderId}/renders?page=0&limit=25`, {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${API_KEY}`
  }
})
```

--------------------------------

### Example External Assets Endpoint Response

Source: https://templated.io/docs/embed/url-parameters.md

Your endpoint must return a JSON array of asset objects. Each object requires a 'url' and 'type' field, where type is either 'image' or 'video'. Items with missing URLs or invalid types are ignored.

```json
[
  { "url": "https://cdn.example.com/logos/logo-primary.png", "type": "image" },
  { "url": "https://cdn.example.com/photos/product-front.jpg", "type": "image" },
  { "url": "https://cdn.example.com/videos/promo-15s.mp4", "type": "video" }
]
```

--------------------------------

### GET /v1/fonts/gallery Endpoint

Source: https://templated.io/docs/fonts/gallery.md

This snippet shows the basic GET request to retrieve all available fonts from the gallery.

```HTTP
GET /v1/fonts/gallery
```

--------------------------------

### List Templates with All Query Parameters in PHP

Source: https://templated.io/docs/templates/list.md

This PHP script demonstrates fetching a list of templates with all query parameters. It uses stream contexts for making the HTTP request. Ensure your API key is correctly set.

```php
<?php
$apiKey = 'API_KEY';

// Example with all query parameters
$params = array(
    'query' => 'Template Name',
    'page' => 0,
    'limit' => 25,
    'width' => 1920,
    'height' => 1080,
    'externalId' => 'my-external-id',
    'includeLayers' => 'true'
);

$url = "https://api.templated.io/v1/templates?" . http_build_query($params);

$options = [
    'http' => [
        'header' => "Authorization: Bearer {$apiKey}\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);

if ($result === FALSE) {
    echo "Error fetching data";
} else {
    $data = json_decode($result, true);
    print_r($data);
}
?>
```

--------------------------------

### List Uploads Endpoint

Source: https://templated.io/docs/uploads/list.md

The GET endpoint for listing uploads.

```HTTP
GET /v1/uploads
```

--------------------------------

### get_template_layers

Source: https://templated.io/docs/integrations/mcp/tools.md

Gets all layers within a specific template, including their properties.

```APIDOC
## get_template_layers

### Description
Gets all layers in a template with their properties.

### Method
GET

### Endpoint
/templates/{id}/layers

### Parameters
#### Path Parameters
- **id** (string) - Required - Template ID
```

--------------------------------

### Sample Folder Object

Source: https://templated.io/docs/folders.md

This JSON object represents a sample folder with its unique ID, name, and creation/update timestamps.

```json
{
  "id": "3c435c83-6682-4468-939f-6af175caacex",
  "name": "Marketing Folder",
  "createdAt": "2024-03-20T10:30:00Z",
  "updatedAt": "2024-03-20T10:30:00Z"
}
```

--------------------------------

### Fetch User Uploads with Parameters

Source: https://templated.io/docs/uploads/list.md

Demonstrates fetching user uploads with search query, tags, and pagination. Requires an API key for authorization.

```JavaScript
fetch('https://api.templated.io/v1/uploads?query=banner&tags=social,marketing&page=0&limit=10', {
  method: 'GET',
  headers: {
    'Authorization' : `Bearer ${API_KEY}`
  }
})
```

--------------------------------

### List Renders Endpoint

Source: https://templated.io/docs/templates/renders.md

The GET endpoint for listing all renders of a specific template.

```HTTP
GET /v1/template/:id/renders
```

--------------------------------

### Account Information Endpoint

Source: https://templated.io/docs/account.md

Use this GET request to retrieve your account information.

```http
GET /v1/account
```

--------------------------------

### List All User Templates Endpoint

Source: https://templated.io/docs/templates/list.md

This is the API endpoint for listing templates. It is a GET request.

```http
GET /v1/templates
```

--------------------------------

### Agency Client Portal Configuration

Source: https://templated.io/docs/embed/url-parameters.md

Sets up an editor instance for an agency client portal, enabling cloning and disabling template creation, with a specific client external ID.

```url
?embed=CONFIG&folder=CLIENT_FOLDER&clone=true&allow-create-template=false&external-id=client-acme-corp
```

--------------------------------

### List All Fonts Endpoint

Source: https://templated.io/docs/fonts/list.md

Use this GET endpoint to retrieve a list of all available fonts.

```http
GET /v1/fonts
```

--------------------------------

### List All Gallery Templates (Python)

Source: https://templated.io/docs/templates/gallery.md

This Python snippet demonstrates fetching all gallery templates. Replace 'API_KEY' with your valid API key.

```python
import requests

api_key = 'API_KEY'
url = 'https://api.templated.io/v1/templates/gallery'

headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print('Request failed. Response code:', response.status_code)
    print(response.text)
```

--------------------------------

### Retrieve Template Endpoint

Source: https://templated.io/docs/templates/retrieve.md

This snippet shows the HTTP GET endpoint for retrieving a template by its ID.

```HTTP
GET /v1/template/:id
```

--------------------------------

### List All Gallery Templates

Source: https://templated.io/docs/templates/gallery.md

This snippet shows how to fetch all available gallery templates using the API. Ensure you replace 'API_KEY' with your actual API key.

```js
fetch('https://api.templated.io/v1/templates/gallery', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${API_KEY}`
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
```

--------------------------------

### Get All Layers

Source: https://templated.io/docs/embed/preview-mode.md

Request a list of all layers in the template, returning only their names and types. Use the `GET_LAYERS` message.

```javascript
iframe.contentWindow.postMessage({ type: 'GET_LAYERS' }, '*');
```

--------------------------------

### Educational Platform Configuration

Source: https://templated.io/docs/embed/url-parameters.md

Configures the editor for an educational platform, launching in gallery mode with layer unlocking and upload loading enabled.

```url
?embed=CONFIG&launch-mode=gallery&allow-layer-unlock=true&load-uploads=true
```

--------------------------------

### Create Render Request in Python

Source: https://templated.io/docs/renders/create.md

This Python code demonstrates how to make a POST request to create a render. Replace placeholders for API_KEY and TEMPLATE_ID.

```Python
import requests

api_key = 'API_KEY'
template_id = 'TEMPLATE_ID'

url = 'https://api.templated.io/v1/render'
headers = {
  'Content-Type': 'application/json',
  'Authorization': f'Bearer {api_key}'
}

data = {
  'template': template_id,
  'layers': {
    'text-1': {
      'text': 'This is my text to be rendered',
      'color': '#FF0000',
      'background': '#0000FF'
    },
    'image-1': {
      'image_url': 'https://picsum.photos/200/300.jpg'
    }
  }
}

response = requests.post(url, json=data, headers=headers)

if response.status_code == 200:
  print('Render request accepted.')
else:
  print('Render request failed. Response code:', response.status_code)
  print(response.text)
```

--------------------------------

### Sample POST Request Endpoint

Source: https://templated.io/docs/renders/create.md

This snippet shows the HTTP method and endpoint for creating a render.

```HTTP
POST /v1/render;
```

--------------------------------

### Get All Pages with Layers

Source: https://templated.io/docs/embed/preview-mode.md

Retrieve all pages within the template, including their respective layers. Send the `GET_PAGES` message.

```javascript
iframe.contentWindow.postMessage({ type: 'GET_PAGES' }, '*');
```

--------------------------------

### List Templates with All Query Parameters in Python

Source: https://templated.io/docs/templates/list.md

This Python code demonstrates how to list templates using the requests library. It shows how to include all query parameters for comprehensive filtering and pagination. Replace 'API_KEY' with your actual key.

```python
import requests

api_key = 'API_KEY'
url = 'https://api.templated.io/v1/templates'

# Example with all query parameters
params = {
  'query': 'Template Name',
  'page': 0,
  'limit': 25,
  'width': 1920,
  'height': 1080,
  'externalId': 'my-external-id',
  'includeLayers': True
}

headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get(url, params=params, headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print('Request failed. Response code:', response.status_code)
    print(response.text)
```

--------------------------------

### GET /v1/folder/:folderId/renders

Source: https://templated.io/docs/folders/renders.md

Lists all renders of a specified folder. Supports pagination with optional page and limit parameters.

```APIDOC
## GET /v1/folder/:folderId/renders

### Description
Lists all renders of a specified folder. Supports pagination with optional page and limit parameters.

### Method
GET

### Endpoint
/v1/folder/:folderId/renders

### Parameters
#### Path Parameters
- **folderId** (string) - REQUIRED - The folder ID that you want to retrieve the renders from.

#### Query Parameters
- **page** (number) - Optional - The page number for pagination. Defaults to 0.
- **limit** (number) - Optional - The number of renders per page. Defaults to 25.

### Request Example
```js
fetch(`https://api.templated.io/v1/folder/${folderId}/renders?page=0&limit=25`, {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${API_KEY}`
  }
})
```

### Response
#### Success Response (200)
An array of JSON objects with the render details.
- **id** (string) - The unique identifier for the render.
- **url** (string) - The URL path to the render asset.
- **status** (string) - The current status of the render (e.g., 'completed').
- **width** (number) - The width of the render in pixels.
- **height** (number) - The height of the render in pixels.
- **folderId** (string) - The ID of the folder this render belongs to.
- **templateId** (string) - The ID of the template used to create this render.
- **createdAt** (string) - The timestamp when the render was created.
- **updatedAt** (string) - The timestamp when the render was last updated.

#### Response Example
```json
[
  {
    "id": "rnd_123abc",
    "url": "renders/2024/03/my-render.png",
    "status": "completed",
    "width": 1080,
    "height": 1080,
    "folderId": "fld_456def",
    "templateId": "tpl_789ghi",
    "createdAt": "2024-03-20T10:30:00Z",
    "updatedAt": "2024-03-20T10:30:00Z"
  }
]
```
```

--------------------------------

### Delete Render using Java

Source: https://templated.io/docs/renders/delete.md

A Java example for deleting a render. Provide your API key and the render ID to execute.

```Java
import java.net.HttpURLConnection;
import java.net.URL;

public class DeleteRender {
    public static void main(String[] args) {
        try {
            String apiKey = "API_KEY";
            String renderId = "RENDER_ID";
            URL url = new URL("https://api.templated.io/v1/render/" + renderId);
            
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("DELETE");
            connection.setRequestProperty("Authorization", "Bearer " + apiKey);

            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_NO_CONTENT) {
                System.out.println("Render deleted successfully");
            } else {
                System.out.println("Request failed. Response Code: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Configure Local MCP Server with Folder ID

Source: https://templated.io/docs/integrations/mcp/setup.md

Set up a local MCP server using environment variables to scope access by folder ID. This ensures all operations are confined to a specific folder.

```json
{
  "mcpServers": {
    "templated": {
      "command": "npx",
      "args": ["mcp-server-templated"],
      "env": {
        "TEMPLATED_API_KEY": "YOUR_API_KEY",
        "TEMPLATED_FOLDER_ID": "FOLDER_ID"
      }
    }
  }
}
```

--------------------------------

### Create a Render

Source: https://templated.io/docs.md

This endpoint allows you to generate a render (image, video, or PDF) by specifying a template and layer content. It requires an API key for authentication.

```APIDOC
## POST /v1/render

### Description
Generates a render (image, video, or PDF) based on a specified template and layer content.

### Method
POST

### Endpoint
https://api.templated.io/v1/render

### Parameters
#### Request Body
- **template** (string) - Required - The ID of the template to use for rendering.
- **layers** (object) - Required - An object containing the content for each layer in the template.
  - **layer_name** (object) - Required - Represents a specific layer.
    - **text** (string) - Optional - The text content for a text layer.
    - **color** (string) - Optional - The color of the text (e.g., '#FF0000').
    - **background** (string) - Optional - The background color for a text layer.
    - **image_url** (string) - Optional - The URL of an image to use for an image layer.

### Request Example
```json
{
  "template": "TEMPLATE_ID",
  "layers": {
    "text-1": {
      "text": "This is my text to be rendered",
      "color": "#FF0000",
      "background": "#0000FF"
    },
    "image-1": {
      "image_url": "https://picsum.photos/200/300.jpg"
    }
  }
}
```

### Headers
- **Content-Type**: application/json
- **Authorization**: Bearer YOUR_API_KEY

### Response
#### Success Response (200)
(Response details not explicitly provided in the source, but typically would include a URL to the generated render.)

#### Error Response
(Error handling details not explicitly provided in the source.)
```

--------------------------------

### Create Render

Source: https://templated.io/docs/renders/create.md

Creates a render from a template. Renders can be images, videos, or PDFs. The process is synchronous by default, with completion times around 2 seconds for images/PDFs and potentially longer for videos.

```APIDOC
## POST /renders

### Description
Creates a render from a template. The generated output can be an image, video, or PDF. The process is synchronous by default and returns the render URL upon completion.

### Method
POST

### Endpoint
/renders

### Response
#### Success Response (200)
- **render_url** (string) - The URL where the generated render can be accessed.

#### Response Example
{
  "render_url": "https://example.com/renders/your-render-id.png"
}
```

--------------------------------

### Hosted Response Example

Source: https://templated.io/docs/renders/merge.md

When the 'host' parameter is true, the API returns a JSON object containing the URL of the hosted merged PDF.

```json
{
  "url": "https://assets.templated.io/renders/merged/merged-abc123.pdf"
}
```
Tokens:
Raw