> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.talkif.ai/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.talkif.ai/_mcp/server.

# List system templates

GET https://api.talkif.ai/api/v1/flow-templates

GET /api/v1/flow-templates

Reference: https://docs.talkif.ai/api-reference/flow-templates/list-system-templates

## Request

### Query parameters

- `category` (string, optional) — Filter by category
- `limit` (long, optional) — Page size
- `offset` (long, optional, default: 0) — Page offset

## Response

### 200

Paginated list of system-wide flow templates

- `meta` (PaginationMeta, required) — Pagination metadata
- `templates` (list of FlowTemplate, required) — Items on this page

## Types

### PaginationMeta

Pagination metadata in responses

- `limit` (long, required) — Number of items in current response
- `offset` (long, required) — Number of items skipped
- `total` (long, required) — Total number of items available

### FlowTemplate

Flow template - can be system-wide (account_id = None) or account-specific

- `category` (string, required) — Template category for filtering
- `createdAt` (datetime, required) — When the template was created
- `displayOrder` (integer, required) — Sort order for template listing (lower = first)
- `edges` (FlowTemplateEdges, required) — Flow edge connections between nodes
- `id` (string, required) — Unique template identifier
- `initialNode` (string, required) — ID of the first node to execute
- `isActive` (boolean, required) — Whether this template is available for use
- `name` (string, required) — Template display name
- `nodes` (FlowTemplateNodes, required) — Flow node definitions
- `slug` (string, required) — URL-safe slug for the template
- `updatedAt` (datetime, required) — When the template was last modified
- `accountId` (string, optional, nullable) — Account that owns this template (null for system templates)
- `createdBy` (string, optional, nullable) — User who created this template
- `definition` (FlowTemplateDefinition, optional, nullable) — Runtime FlowDefinition (initialNode + services + nodes). This is what instantiation copies into the new flow's definition. Null on legacy templates that only carry builder nodes/edges.
- `description` (string, optional, nullable) — Brief description of what the template does
- `icon` (string, optional, nullable) — Icon identifier or emoji for display
- `previewImageUrl` (string, optional, nullable) — URL to a preview image for the template
- `tags` (list of string, optional) — Searchable tags

### FlowTemplateEdges

Flow edge connections between nodes

### FlowTemplateNodes

Flow node definitions

### FlowTemplateDefinition

Runtime FlowDefinition (initialNode + services + nodes). This is what instantiation copies into the new flow's definition. Null on legacy templates that only carry builder nodes/edges.

## Examples

**Response**

```json
{
  "meta": {
    "limit": 20,
    "offset": 0,
    "total": 142
  },
  "templates": [
    {
      "category": "appointment",
      "createdAt": "2026-01-15T10:30:00Z",
      "displayOrder": 1,
      "edges": {},
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "initialNode": "main_agent_1",
      "isActive": true,
      "name": "Appointment Reminder",
      "nodes": {},
      "slug": "appointment-reminder",
      "updatedAt": "2026-02-20T14:45:00Z",
      "accountId": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
      "createdBy": "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d",
      "definition": {},
      "description": "Automated appointment confirmation and rescheduling flow",
      "icon": "calendar",
      "previewImageUrl": "https://cdn.talkif.com/templates/appointment-reminder.png",
      "tags": [
        "healthcare",
        "scheduling"
      ]
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.talkif.ai/api/v1/flow-templates"

response = requests.get(url)

print(response.json())
```

```javascript
const url = 'https://api.talkif.ai/api/v1/flow-templates';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.talkif.ai/api/v1/flow-templates"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.talkif.ai/api/v1/flow-templates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.talkif.ai/api/v1/flow-templates")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.talkif.ai/api/v1/flow-templates');

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.talkif.ai/api/v1/flow-templates");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.talkif.ai/api/v1/flow-templates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```