> 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 email sender

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

Creates a new email sender in your Brevo account.

**Use this to:**
- Add new senders for email campaigns
- Configure sender identity (name and email)
- Associate dedicated IPs with the sender (for dedicated IP accounts)
- Set up domain-based sender configurations

**Key information returned:**
- Created sender ID
- DKIM and SPF configuration status
- Success confirmation

**Important considerations:**
- Verification email sent to specified sender address
- DKIM and SPF configuration affects deliverability
- Dedicated IP accounts require IP association during creation
- IP weights must sum to 100 when specified
- Sender must be verified before use in campaigns


Reference: https://developers.brevo.com/reference/create-sender

## Authentication

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

## Request

### Body (application/json)

This endpoint expects an object.

- `email` (string, required) — From email to use for the sender. A verification email will be sent to this address.
- `name` (string, required) — From Name to use for the sender
- `ips` (list of object, optional) — **Mandatory in case of dedicated IP**. IPs to associate to the sender. Not required for standard accounts.
  - `domain` (string, required) — Domain of the IP
  - `ip` (string, required) — Dedicated IP available in your account
  - `weight` (long, optional) — Weight to apply to the IP. Sum of all IP weights must be 100. Should be passed for either ALL or NONE of the IPs. If it's not passed, the sending will be equally balanced on all IPs.

## Response

### 201

Sender created successfully

- `id` (long, required) — ID of the Sender created
- `dkimError` (boolean, optional) — Status of DKIM configuration for the sender (true = DKIM not well configured, false = DKIM well configured)
- `spfError` (boolean, optional) — Status of SPF configuration for the sender (true = SPF not well configured, false = SPF well configured)

## Errors

### 400 Bad Request Error

bad request

- `code` (enum, required) — Error code displayed in case of a failure
  - Allowed values: `invalid_parameter`, `missing_parameter`, `out_of_range`, `campaign_processing`, `campaign_sent`, `document_not_found`, `not_enough_credits`, `permission_denied`, `duplicate_parameter`, `duplicate_request`, `method_not_allowed`, `unauthorized`, `account_under_validation`, `not_acceptable`, `bad_request`, `unprocessable_entity`, `Domain does not exist`, `Contact email not found`, `Attribute not found`, `Category id not found`, `Invalid parameters passed`, `Record(s) for identifier not found`, `Returned when query params are invalid`, `Returned when invalid data posted`, `Feed not found`, `Campaign ID not found`, `api-key not found`, `DMARC policy requires domain authentication`, `DNS records not properly configured`, `Invalid OTP code provided`, `OTP code has expired`, `Domain already exists in your account`, `The sum of all IP weights must equal 100`, `Authentication failed`, `Insufficient credits`, `Request already processed`
- `message` (string, required) — Readable message associated to the failure

## Examples

### Successful sender creation response

**Request**

```json
undefined
```

**Response**

```json
{
  "id": 15,
  "dkimError": false,
  "spfError": false
}
```

**SDK Code**

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

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

```

```python Successful sender creation response
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.create_sender()

```

```php Successful sender creation response
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\CreateSenderRequest;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->createSender(
    new CreateSenderRequest([]),
);

```

```go Successful sender creation response
package main

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

func main() {

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

	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 Successful sender creation response
require 'uri'
require 'net/http'

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

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 Successful sender creation response
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```csharp Successful sender creation response
using RestSharp;

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

```swift Successful sender creation response
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/senders")! 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()
```

### Sender created but with configuration warnings

**Request**

```json
undefined
```

**Response**

```json
{
  "id": 16,
  "dkimError": true,
  "spfError": false
}
```

**SDK Code**

```typescript Sender created but with configuration warnings
import { BrevoClient } from "@getbrevo/brevo";

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

```

```python Sender created but with configuration warnings
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.create_sender()

```

```php Sender created but with configuration warnings
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\CreateSenderRequest;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->createSender(
    new CreateSenderRequest([]),
);

```

```go Sender created but with configuration warnings
package main

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

func main() {

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

	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 Sender created but with configuration warnings
require 'uri'
require 'net/http'

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

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 Sender created but with configuration warnings
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```csharp Sender created but with configuration warnings
using RestSharp;

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

```swift Sender created but with configuration warnings
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/senders")! 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 sender creation (standard account)

**Request**

```json
{
  "email": "support@example.com",
  "name": "Support Team"
}
```

**Response**

```json
{
  "id": 15,
  "dkimError": false,
  "spfError": false
}
```

**SDK Code**

```typescript Basic sender creation (standard account)
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.senders.createSender({
        email: "support@example.com",
        name: "Support Team",
    });
}
main();

```

```python Basic sender creation (standard account)
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.create_sender(
    email="support@example.com",
    name="Support Team",
)

```

```php Basic sender creation (standard account)
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\CreateSenderRequest;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->createSender(
    new CreateSenderRequest([
        'email' => 'support@example.com',
        'name' => 'Support Team',
    ]),
);

```

```go Basic sender creation (standard account)
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"email\": \"support@example.com\",\n  \"name\": \"Support Team\"\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 sender creation (standard account)
require 'uri'
require 'net/http'

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

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  \"email\": \"support@example.com\",\n  \"name\": \"Support Team\"\n}"

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

```java Basic sender creation (standard account)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.brevo.com/v3/senders")
  .header("api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"email\": \"support@example.com\",\n  \"name\": \"Support Team\"\n}")
  .asString();
```

```csharp Basic sender creation (standard account)
using RestSharp;

var client = new RestClient("https://api.brevo.com/v3/senders");
var request = new RestRequest(Method.POST);
request.AddHeader("api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"support@example.com\",\n  \"name\": \"Support Team\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Basic sender creation (standard account)
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "email": "support@example.com",
  "name": "Support Team"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/senders")! 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()
```

### Sender with dedicated IP configuration

**Request**

```json
{
  "email": "marketing@example.com",
  "name": "Marketing Team",
  "ips": [
    {
      "domain": "example.com",
      "ip": "203.0.113.100",
      "weight": 100
    }
  ]
}
```

**Response**

```json
{
  "id": 15,
  "dkimError": false,
  "spfError": false
}
```

**SDK Code**

```typescript Sender with dedicated IP configuration
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.senders.createSender({
        email: "marketing@example.com",
        ips: [
            {
                domain: "example.com",
                ip: "203.0.113.100",
                weight: 100,
            },
        ],
        name: "Marketing Team",
    });
}
main();

```

```python Sender with dedicated IP configuration
from brevo import Brevo
from brevo.senders import CreateSenderRequestIpsItem

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.create_sender(
    email="marketing@example.com",
    ips=[
        CreateSenderRequestIpsItem(
            domain="example.com",
            ip="203.0.113.100",
            weight=100,
        )
    ],
    name="Marketing Team",
)

```

```php Sender with dedicated IP configuration
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\CreateSenderRequest;
use Brevo\Senders\Types\CreateSenderRequestIpsItem;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->createSender(
    new CreateSenderRequest([
        'email' => 'marketing@example.com',
        'ips' => [
            new CreateSenderRequestIpsItem([
                'domain' => 'example.com',
                'ip' => '203.0.113.100',
                'weight' => 100,
            ]),
        ],
        'name' => 'Marketing Team',
    ]),
);

```

```go Sender with dedicated IP configuration
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"email\": \"marketing@example.com\",\n  \"name\": \"Marketing Team\",\n  \"ips\": [\n    {\n      \"domain\": \"example.com\",\n      \"ip\": \"203.0.113.100\",\n      \"weight\": 100\n    }\n  ]\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 Sender with dedicated IP configuration
require 'uri'
require 'net/http'

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

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  \"email\": \"marketing@example.com\",\n  \"name\": \"Marketing Team\",\n  \"ips\": [\n    {\n      \"domain\": \"example.com\",\n      \"ip\": \"203.0.113.100\",\n      \"weight\": 100\n    }\n  ]\n}"

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

```java Sender with dedicated IP configuration
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.brevo.com/v3/senders")
  .header("api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"email\": \"marketing@example.com\",\n  \"name\": \"Marketing Team\",\n  \"ips\": [\n    {\n      \"domain\": \"example.com\",\n      \"ip\": \"203.0.113.100\",\n      \"weight\": 100\n    }\n  ]\n}")
  .asString();
```

```csharp Sender with dedicated IP configuration
using RestSharp;

var client = new RestClient("https://api.brevo.com/v3/senders");
var request = new RestRequest(Method.POST);
request.AddHeader("api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"marketing@example.com\",\n  \"name\": \"Marketing Team\",\n  \"ips\": [\n    {\n      \"domain\": \"example.com\",\n      \"ip\": \"203.0.113.100\",\n      \"weight\": 100\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Sender with dedicated IP configuration
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "email": "marketing@example.com",
  "name": "Marketing Team",
  "ips": [
    [
      "domain": "example.com",
      "ip": "203.0.113.100",
      "weight": 100
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/senders")! 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()
```

### Sender with multiple dedicated IPs and weight distribution

**Request**

```json
{
  "email": "newsletter@example.com",
  "name": "Newsletter",
  "ips": [
    {
      "domain": "example.com",
      "ip": "203.0.113.100",
      "weight": 60
    },
    {
      "domain": "news.example.com",
      "ip": "203.0.113.101",
      "weight": 40
    }
  ]
}
```

**Response**

```json
{
  "id": 15,
  "dkimError": false,
  "spfError": false
}
```

**SDK Code**

```typescript Sender with multiple dedicated IPs and weight distribution
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.senders.createSender({
        email: "newsletter@example.com",
        ips: [
            {
                domain: "example.com",
                ip: "203.0.113.100",
                weight: 60,
            },
            {
                domain: "news.example.com",
                ip: "203.0.113.101",
                weight: 40,
            },
        ],
        name: "Newsletter",
    });
}
main();

```

```python Sender with multiple dedicated IPs and weight distribution
from brevo import Brevo
from brevo.senders import CreateSenderRequestIpsItem

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.create_sender(
    email="newsletter@example.com",
    ips=[
        CreateSenderRequestIpsItem(
            domain="example.com",
            ip="203.0.113.100",
            weight=60,
        ),
        CreateSenderRequestIpsItem(
            domain="news.example.com",
            ip="203.0.113.101",
            weight=40,
        )
    ],
    name="Newsletter",
)

```

```php Sender with multiple dedicated IPs and weight distribution
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\CreateSenderRequest;
use Brevo\Senders\Types\CreateSenderRequestIpsItem;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->createSender(
    new CreateSenderRequest([
        'email' => 'newsletter@example.com',
        'ips' => [
            new CreateSenderRequestIpsItem([
                'domain' => 'example.com',
                'ip' => '203.0.113.100',
                'weight' => 60,
            ]),
            new CreateSenderRequestIpsItem([
                'domain' => 'news.example.com',
                'ip' => '203.0.113.101',
                'weight' => 40,
            ]),
        ],
        'name' => 'Newsletter',
    ]),
);

```

```go Sender with multiple dedicated IPs and weight distribution
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"email\": \"newsletter@example.com\",\n  \"name\": \"Newsletter\",\n  \"ips\": [\n    {\n      \"domain\": \"example.com\",\n      \"ip\": \"203.0.113.100\",\n      \"weight\": 60\n    },\n    {\n      \"domain\": \"news.example.com\",\n      \"ip\": \"203.0.113.101\",\n      \"weight\": 40\n    }\n  ]\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 Sender with multiple dedicated IPs and weight distribution
require 'uri'
require 'net/http'

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

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  \"email\": \"newsletter@example.com\",\n  \"name\": \"Newsletter\",\n  \"ips\": [\n    {\n      \"domain\": \"example.com\",\n      \"ip\": \"203.0.113.100\",\n      \"weight\": 60\n    },\n    {\n      \"domain\": \"news.example.com\",\n      \"ip\": \"203.0.113.101\",\n      \"weight\": 40\n    }\n  ]\n}"

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

```java Sender with multiple dedicated IPs and weight distribution
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.brevo.com/v3/senders")
  .header("api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"email\": \"newsletter@example.com\",\n  \"name\": \"Newsletter\",\n  \"ips\": [\n    {\n      \"domain\": \"example.com\",\n      \"ip\": \"203.0.113.100\",\n      \"weight\": 60\n    },\n    {\n      \"domain\": \"news.example.com\",\n      \"ip\": \"203.0.113.101\",\n      \"weight\": 40\n    }\n  ]\n}")
  .asString();
```

```csharp Sender with multiple dedicated IPs and weight distribution
using RestSharp;

var client = new RestClient("https://api.brevo.com/v3/senders");
var request = new RestRequest(Method.POST);
request.AddHeader("api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"newsletter@example.com\",\n  \"name\": \"Newsletter\",\n  \"ips\": [\n    {\n      \"domain\": \"example.com\",\n      \"ip\": \"203.0.113.100\",\n      \"weight\": 60\n    },\n    {\n      \"domain\": \"news.example.com\",\n      \"ip\": \"203.0.113.101\",\n      \"weight\": 40\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Sender with multiple dedicated IPs and weight distribution
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "email": "newsletter@example.com",
  "name": "Newsletter",
  "ips": [
    [
      "domain": "example.com",
      "ip": "203.0.113.100",
      "weight": 60
    ],
    [
      "domain": "news.example.com",
      "ip": "203.0.113.101",
      "weight": 40
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.brevo.com/v3/senders")! 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()
```