> 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.

# Create external feed

POST https://api.brevo.com/v3/feeds
Content-Type: application/json

Creates a new external feed for dynamic content in email campaigns.

**Use this to:**
- Set up external data sources for dynamic content
- Configure authentication for protected feeds
- Enable real-time content updates in campaigns
- Establish connections to product catalogs, blogs, or APIs

**Key information returned:**
- Created feed UUID for reference in campaigns
- Success confirmation

**Important considerations:**
- Feed URL must be accessible from Brevo infrastructure
- Authentication credentials are securely encrypted
- Test feed accessibility before campaign use
- Consider feed response time for campaign performance
- Monitor feed reliability and uptime
- Use caching for frequently accessed feeds
- Maximum 5 retry attempts allowed for failed requests
- Custom headers support for API integration requirements


Reference: https://developers.brevo.com/reference/create-external-feed

## Authentication

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

## Request

### Body (application/json)

- `name` (string, required) — Name of the feed
- `url` (string, required) — URL of the external data source
- `authType` (enum, optional, default: noAuth) — Authentication type for accessing the feed
  - Allowed values: `basic`, `token`, `noAuth`
- `username` (string, optional) — Username for basic authentication (required if authType is 'basic')
- `password` (string, optional) — Password for basic authentication (required if authType is 'basic')
- `token` (string, optional) — Token for token-based authentication (required if authType is 'token')
- `maxRetries` (integer, optional, default: 5) — Maximum number of retry attempts for failed requests
- `cache` (boolean, optional, default: true) — Whether to cache the feed response
- `headers` (list of object, optional) — Custom HTTP headers for the feed request
  - `name` (string, required) — Header name
  - `value` (string, required) — Header value

## Response

### 201

External feed created successfully

- `id` (string, required) — UUID of the created feed

## Examples

### Successfully created external feed

**Request**

```json
undefined
```

**Response**

```json
{
  "id": "b1c2d3e4-f5a6-47b8-89c0-d1e2f3a4b5c6"
}
```

**SDK Code**

```typescript Successfully created external feed
import { BrevoClient } from "@getbrevo/brevo";

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

```

```python Successfully created external feed
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.external_feeds.create_external_feed()

```

```php Successfully created external feed
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\ExternalFeeds\Requests\CreateExternalFeedRequest;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->externalFeeds->createExternalFeed(
    new CreateExternalFeedRequest([]),
);

```

```go Successfully created external feed
package main

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

func main() {

	url := "https://api.brevo.com/v3/feeds"

	req, _ := http.NewRequest("POST", 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 Successfully created external feed
require 'uri'
require 'net/http'

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

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

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

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

```java Successfully created external feed
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```csharp Successfully created external feed
using RestSharp;

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

```swift Successfully created external feed
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/feeds")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```

### Basic external feed with no authentication

**Request**

```json
{
  "name": "Public API Feed",
  "url": "https://jsonplaceholder.typicode.com/posts",
  "authType": "noAuth",
  "maxRetries": 3,
  "cache": true
}
```

**Response**

```json
{
  "id": "b1c2d3e4-f5a6-47b8-89c0-d1e2f3a4b5c6"
}
```

**SDK Code**

```typescript Basic external feed with no authentication
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.externalFeeds.createExternalFeed({
        name: "Public API Feed",
        url: "https://jsonplaceholder.typicode.com/posts",
        authType: "noAuth",
        maxRetries: 3,
        cache: true,
    });
}
main();

```

```python Basic external feed with no authentication
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.external_feeds.create_external_feed(
    name="Public API Feed",
    url="https://jsonplaceholder.typicode.com/posts",
    auth_type="noAuth",
    max_retries=3,
    cache=True,
)

```

```php Basic external feed with no authentication
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\ExternalFeeds\Requests\CreateExternalFeedRequest;
use Brevo\ExternalFeeds\Types\CreateExternalFeedRequestAuthType;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->externalFeeds->createExternalFeed(
    new CreateExternalFeedRequest([
        'name' => 'Public API Feed',
        'url' => 'https://jsonplaceholder.typicode.com/posts',
        'authType' => CreateExternalFeedRequestAuthType::NoAuth->value,
        'maxRetries' => 3,
        'cache' => true,
    ]),
);

```

```go Basic external feed with no authentication
package main

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

func main() {

	url := "https://api.brevo.com/v3/feeds"

	payload := strings.NewReader("{\n  \"name\": \"Public API Feed\",\n  \"url\": \"https://jsonplaceholder.typicode.com/posts\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Basic external feed with no authentication
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Public API Feed\",\n  \"url\": \"https://jsonplaceholder.typicode.com/posts\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}"

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

```java Basic external feed with no authentication
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.brevo.com/v3/feeds")
  .header("api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Public API Feed\",\n  \"url\": \"https://jsonplaceholder.typicode.com/posts\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}")
  .asString();
```

```csharp Basic external feed with no authentication
using RestSharp;

var client = new RestClient("https://api.brevo.com/v3/feeds");
var request = new RestRequest(Method.POST);
request.AddHeader("api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Public API Feed\",\n  \"url\": \"https://jsonplaceholder.typicode.com/posts\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Basic external feed with no authentication
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "name": "Public API Feed",
  "url": "https://jsonplaceholder.typicode.com/posts",
  "authType": "noAuth",
  "maxRetries": 3,
  "cache": true
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/feeds")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

### Feed with token authentication

**Request**

```json
{
  "name": "Product Catalog",
  "url": "https://api.example.com/products",
  "authType": "noAuth",
  "maxRetries": 3,
  "cache": true
}
```

**Response**

```json
{
  "id": "b1c2d3e4-f5a6-47b8-89c0-d1e2f3a4b5c6"
}
```

**SDK Code**

```typescript Feed with token authentication
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.externalFeeds.createExternalFeed({
        name: "Product Catalog",
        url: "https://api.example.com/products",
        authType: "noAuth",
        maxRetries: 3,
        cache: true,
    });
}
main();

```

```python Feed with token authentication
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.external_feeds.create_external_feed(
    name="Product Catalog",
    url="https://api.example.com/products",
    auth_type="noAuth",
    max_retries=3,
    cache=True,
)

```

```php Feed with token authentication
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\ExternalFeeds\Requests\CreateExternalFeedRequest;
use Brevo\ExternalFeeds\Types\CreateExternalFeedRequestAuthType;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->externalFeeds->createExternalFeed(
    new CreateExternalFeedRequest([
        'name' => 'Product Catalog',
        'url' => 'https://api.example.com/products',
        'authType' => CreateExternalFeedRequestAuthType::NoAuth->value,
        'maxRetries' => 3,
        'cache' => true,
    ]),
);

```

```go Feed with token authentication
package main

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

func main() {

	url := "https://api.brevo.com/v3/feeds"

	payload := strings.NewReader("{\n  \"name\": \"Product Catalog\",\n  \"url\": \"https://api.example.com/products\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Feed with token authentication
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Product Catalog\",\n  \"url\": \"https://api.example.com/products\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}"

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

```java Feed with token authentication
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.brevo.com/v3/feeds")
  .header("api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Product Catalog\",\n  \"url\": \"https://api.example.com/products\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}")
  .asString();
```

```csharp Feed with token authentication
using RestSharp;

var client = new RestClient("https://api.brevo.com/v3/feeds");
var request = new RestRequest(Method.POST);
request.AddHeader("api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Product Catalog\",\n  \"url\": \"https://api.example.com/products\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Feed with token authentication
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "name": "Product Catalog",
  "url": "https://api.example.com/products",
  "authType": "noAuth",
  "maxRetries": 3,
  "cache": true
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/feeds")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

### Feed with basic authentication

**Request**

```json
{
  "name": "Internal Blog Feed",
  "url": "https://blog.example.com/api/posts",
  "authType": "noAuth",
  "maxRetries": 3,
  "cache": true
}
```

**Response**

```json
{
  "id": "b1c2d3e4-f5a6-47b8-89c0-d1e2f3a4b5c6"
}
```

**SDK Code**

```typescript Feed with basic authentication
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.externalFeeds.createExternalFeed({
        name: "Internal Blog Feed",
        url: "https://blog.example.com/api/posts",
        authType: "noAuth",
        maxRetries: 3,
        cache: true,
    });
}
main();

```

```python Feed with basic authentication
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.external_feeds.create_external_feed(
    name="Internal Blog Feed",
    url="https://blog.example.com/api/posts",
    auth_type="noAuth",
    max_retries=3,
    cache=True,
)

```

```php Feed with basic authentication
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\ExternalFeeds\Requests\CreateExternalFeedRequest;
use Brevo\ExternalFeeds\Types\CreateExternalFeedRequestAuthType;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->externalFeeds->createExternalFeed(
    new CreateExternalFeedRequest([
        'name' => 'Internal Blog Feed',
        'url' => 'https://blog.example.com/api/posts',
        'authType' => CreateExternalFeedRequestAuthType::NoAuth->value,
        'maxRetries' => 3,
        'cache' => true,
    ]),
);

```

```go Feed with basic authentication
package main

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

func main() {

	url := "https://api.brevo.com/v3/feeds"

	payload := strings.NewReader("{\n  \"name\": \"Internal Blog Feed\",\n  \"url\": \"https://blog.example.com/api/posts\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Feed with basic authentication
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Internal Blog Feed\",\n  \"url\": \"https://blog.example.com/api/posts\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}"

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

```java Feed with basic authentication
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.brevo.com/v3/feeds")
  .header("api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Internal Blog Feed\",\n  \"url\": \"https://blog.example.com/api/posts\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}")
  .asString();
```

```csharp Feed with basic authentication
using RestSharp;

var client = new RestClient("https://api.brevo.com/v3/feeds");
var request = new RestRequest(Method.POST);
request.AddHeader("api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Internal Blog Feed\",\n  \"url\": \"https://blog.example.com/api/posts\",\n  \"authType\": \"noAuth\",\n  \"maxRetries\": 3,\n  \"cache\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Feed with basic authentication
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "name": "Internal Blog Feed",
  "url": "https://blog.example.com/api/posts",
  "authType": "noAuth",
  "maxRetries": 3,
  "cache": true
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/feeds")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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