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

# Get the list of email templates

GET https://api.brevo.com/v3/smtp/templates

Retrieve a paginated list of all transactional email templates (including automation templates) with their details such as name, subject, sender, status, HTML content, and timestamps. Results default to 50 per page (max 1000) and are sorted in descending creation order unless overridden. You can filter by active/inactive status using `templateStatus` and by editor type using `editorType` (currently only `richTextEditor` is supported).

Reference: https://developers.brevo.com/reference/get-smtp-templates

## Authentication

- `api-key` header (required) — The API key should be passed in the request headers as `api-key` for authentication.

## Request

### Query parameters

- `templateStatus` (boolean, optional) — Filter on the status of the template. Active = true, inactive = false
- `limit` (long, optional, default: 50) — Number of documents returned per page
- `offset` (long, optional, default: 0) — Index of the first document in the page
- `sort` (enum, optional, default: desc) — Sort the results in the ascending/descending order of record creation. Default order is **descending** if `sort` is not passed
  - Allowed values: `asc`, `desc`
- `editorType` (enum, optional) — Filter on the editor type used to create the template. Currently only `richTextEditor` is supported as a filter value.
  - Allowed values: `richTextEditor`

## Response

### 200

transactional email templates informations

- `count` (long, optional) — Count of transactional email templates
- `templates` (list of object, optional)
  - `createdAt` (string, required) — Creation UTC date-time of the template (YYYY-MM-DDTHH:mm:ss.SSSZ)
  - `htmlContent` (string, required) — HTML content of the template
  - `id` (long, required) — ID of the template
  - `isActive` (boolean, required) — Status of template (true=active, false=inactive)
  - `modifiedAt` (string, required) — Last modification UTC date-time of the template (YYYY-MM-DDTHH:mm:ss.SSSZ)
  - `name` (string, required) — Name of the template
  - `replyTo` (string, required) — Email defined as the "Reply to" for the template
  - `sender` (object, required)
    - `email` (string, optional) — From email for the template
    - `id` (string, optional) — Sender id of the template
    - `name` (string, optional) — Sender name for the template
  - `subject` (string, required) — Subject of the template
  - `tag` (string, required) — Tag of the template
  - `testSent` (boolean, required) — Status of test sending for the template (true=test email has been sent, false=test email has not been sent)
  - `toField` (string, required) — Customisation of the "to" field for the template
  - `doiTemplate` (boolean, optional) — It is true if template is a valid Double opt-in (DOI) template, otherwise it is false. This field will be available only in case of single template detail call.
  - `customTemplateId` (string, optional) — Custom template identifier, if one was assigned during template creation. Only present when the template has a custom ID.

## Examples

**Response**

```json
{
  "count": 2,
  "templates": [
    {
      "createdAt": "2016-02-24T14:44:24Z",
      "htmlContent": "HTML CONTENT 1",
      "id": 5,
      "isActive": false,
      "modifiedAt": "2016-02-24T15:37:11Z",
      "name": "ChristomasTimeTemplate",
      "replyTo": "replyto@domain.com",
      "sender": {
        "email": "john.smith@example.com",
        "id": "23",
        "name": "John"
      },
      "subject": "Merry Christmas",
      "tag": "Festival",
      "testSent": false,
      "toField": ""
    },
    {
      "createdAt": "2016-02-25T11:53:26Z",
      "htmlContent": "HTML CONTENT 2",
      "id": 12,
      "isActive": true,
      "modifiedAt": "2016-02-25T11:53:26Z",
      "name": "SummerSales2017Template",
      "replyTo": "replyto@domain.com",
      "sender": {
        "email": "john.smith@example.com",
        "id": "23",
        "name": "John"
      },
      "subject": "Enjoy our summer Sales !",
      "tag": "Summer",
      "testSent": false,
      "toField": ""
    }
  ]
}
```

**SDK Code**

```typescript response
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.transactionalEmails.getSmtpTemplates({});
}
main();

```

```python response
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.transactional_emails.get_smtp_templates()

```

```php response
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\TransactionalEmails\Requests\GetSmtpTemplatesRequest;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->transactionalEmails->getSmtpTemplates(
    new GetSmtpTemplatesRequest([]),
);

```

```go response
package main

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

func main() {

	url := "https://api.brevo.com/v3/smtp/templates"

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

	req.Header.Add("api-key", "<apiKey>")

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

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

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

}
```

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

url = URI("https://api.brevo.com/v3/smtp/templates")

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

request = Net::HTTP::Get.new(url)
request["api-key"] = '<apiKey>'

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

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

HttpResponse<String> response = Unirest.get("https://api.brevo.com/v3/smtp/templates")
  .header("api-key", "<apiKey>")
  .asString();
```

```csharp response
using RestSharp;

var client = new RestClient("https://api.brevo.com/v3/smtp/templates");
var request = new RestRequest(Method.GET);
request.AddHeader("api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift response
import Foundation

let headers = ["api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/smtp/templates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```