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

# Update a sender

PUT https://api.brevo.com/v3/senders/{senderId}
Content-Type: application/json

Updates an existing email sender's configuration.

Use this to:
- Modify sender display name or email address
- Update dedicated IP associations
- Change sender configuration settings
- Correct sender information

Key information returned:
- Success confirmation
- Updated sender details

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

## Authentication

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

## Request

### Path parameters

- `senderId` (long, required) — Id of the sender

### Body (application/json)

This endpoint expects an object.

- `email` (string, optional) — From Email to update the sender
- `ips` (list of object, optional) — **Only in case of dedicated IP**. IPs to associate to the sender. If passed, will replace all the existing IPs. 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.
- `name` (string, optional) — From Name to update the sender

## Response

### 204

Sender updated successfully

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

### 404 Not Found Error

Sender ID not found

- `message` (string, required) — Readable message associated to the failure
- `code` (string, optional) — Error code displayed in case of a failure

## Examples

### Update sender name only

**Request**

```json
{
  "name": "New Support Team"
}
```

**SDK Code**

```typescript Update sender name only
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.senders.updateSender({
        senderId: 1,
        name: "New Support Team",
    });
}
main();

```

```python Update sender name only
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.update_sender(
    sender_id=1,
    name="New Support Team",
)

```

```php Update sender name only
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\UpdateSenderRequest;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->updateSender(
    1,
    new UpdateSenderRequest([
        'name' => 'New Support Team',
    ]),
);

```

```go Update sender name only
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"name\": \"New Support Team\"\n}")

	req, _ := http.NewRequest("PUT", 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 Update sender name only
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"New Support Team\"\n}"

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

```java Update sender name only
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```csharp Update sender name only
using RestSharp;

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

```swift Update sender name only
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["name": "New Support Team"] as [String : Any]

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

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

### Update sender email only

**Request**

```json
{
  "email": "newsupport@mycompany.com"
}
```

**SDK Code**

```typescript Update sender email only
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.senders.updateSender({
        senderId: 1,
        email: "newsupport@mycompany.com",
    });
}
main();

```

```python Update sender email only
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.update_sender(
    sender_id=1,
    email="newsupport@mycompany.com",
)

```

```php Update sender email only
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\UpdateSenderRequest;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->updateSender(
    1,
    new UpdateSenderRequest([
        'email' => 'newsupport@mycompany.com',
    ]),
);

```

```go Update sender email only
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"email\": \"newsupport@mycompany.com\"\n}")

	req, _ := http.NewRequest("PUT", 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 Update sender email only
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"email\": \"newsupport@mycompany.com\"\n}"

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

```java Update sender email only
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.brevo.com/v3/senders/1")
  .header("api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"email\": \"newsupport@mycompany.com\"\n}")
  .asString();
```

```csharp Update sender email only
using RestSharp;

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

```swift Update sender email only
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["email": "newsupport@mycompany.com"] as [String : Any]

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

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

### Update both name and email

**Request**

```json
{
  "email": "marketing@mycompany.com",
  "name": "Marketing Team"
}
```

**SDK Code**

```typescript Update both name and email
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.senders.updateSender({
        senderId: 1,
        email: "marketing@mycompany.com",
        name: "Marketing Team",
    });
}
main();

```

```python Update both name and email
from brevo import Brevo

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.update_sender(
    sender_id=1,
    email="marketing@mycompany.com",
    name="Marketing Team",
)

```

```php Update both name and email
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\UpdateSenderRequest;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->updateSender(
    1,
    new UpdateSenderRequest([
        'email' => 'marketing@mycompany.com',
        'name' => 'Marketing Team',
    ]),
);

```

```go Update both name and email
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"email\": \"marketing@mycompany.com\",\n  \"name\": \"Marketing Team\"\n}")

	req, _ := http.NewRequest("PUT", 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 Update both name and email
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"email\": \"marketing@mycompany.com\",\n  \"name\": \"Marketing Team\"\n}"

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

```java Update both name and email
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```csharp Update both name and email
using RestSharp;

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

```swift Update both name and email
import Foundation

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

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

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

### Update sender with dedicated IP configuration

**Request**

```json
{
  "email": "marketing@enterprise.com",
  "ips": [
    {
      "domain": "enterprise.com",
      "ip": "192.168.1.100",
      "weight": 100
    }
  ],
  "name": "Enterprise Marketing"
}
```

**SDK Code**

```typescript Update 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.updateSender({
        senderId: 1,
        email: "marketing@enterprise.com",
        ips: [
            {
                domain: "enterprise.com",
                ip: "192.168.1.100",
                weight: 100,
            },
        ],
        name: "Enterprise Marketing",
    });
}
main();

```

```python Update sender with dedicated IP configuration
from brevo import Brevo
from brevo.senders import UpdateSenderRequestIpsItem

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.update_sender(
    sender_id=1,
    email="marketing@enterprise.com",
    ips=[
        UpdateSenderRequestIpsItem(
            domain="enterprise.com",
            ip="192.168.1.100",
            weight=100,
        )
    ],
    name="Enterprise Marketing",
)

```

```php Update sender with dedicated IP configuration
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\UpdateSenderRequest;
use Brevo\Senders\Types\UpdateSenderRequestIpsItem;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->updateSender(
    1,
    new UpdateSenderRequest([
        'email' => 'marketing@enterprise.com',
        'ips' => [
            new UpdateSenderRequestIpsItem([
                'domain' => 'enterprise.com',
                'ip' => '192.168.1.100',
                'weight' => 100,
            ]),
        ],
        'name' => 'Enterprise Marketing',
    ]),
);

```

```go Update sender with dedicated IP configuration
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"email\": \"marketing@enterprise.com\",\n  \"ips\": [\n    {\n      \"domain\": \"enterprise.com\",\n      \"ip\": \"192.168.1.100\",\n      \"weight\": 100\n    }\n  ],\n  \"name\": \"Enterprise Marketing\"\n}")

	req, _ := http.NewRequest("PUT", 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 Update sender with dedicated IP configuration
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"email\": \"marketing@enterprise.com\",\n  \"ips\": [\n    {\n      \"domain\": \"enterprise.com\",\n      \"ip\": \"192.168.1.100\",\n      \"weight\": 100\n    }\n  ],\n  \"name\": \"Enterprise Marketing\"\n}"

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

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

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

```csharp Update sender with dedicated IP configuration
using RestSharp;

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

```swift Update sender with dedicated IP configuration
import Foundation

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

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

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

### Update sender with multiple dedicated IPs

**Request**

```json
{
  "email": "campaigns@enterprise.com",
  "ips": [
    {
      "domain": "enterprise.com",
      "ip": "192.168.1.100",
      "weight": 70
    },
    {
      "domain": "mail.enterprise.com",
      "ip": "192.168.1.101",
      "weight": 30
    }
  ],
  "name": "Multi-IP Sender"
}
```

**SDK Code**

```typescript Update sender with multiple dedicated IPs
import { BrevoClient } from "@getbrevo/brevo";

async function main() {
    const client = new BrevoClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.senders.updateSender({
        senderId: 1,
        email: "campaigns@enterprise.com",
        ips: [
            {
                domain: "enterprise.com",
                ip: "192.168.1.100",
                weight: 70,
            },
            {
                domain: "mail.enterprise.com",
                ip: "192.168.1.101",
                weight: 30,
            },
        ],
        name: "Multi-IP Sender",
    });
}
main();

```

```python Update sender with multiple dedicated IPs
from brevo import Brevo
from brevo.senders import UpdateSenderRequestIpsItem

client = Brevo(
    api_key="YOUR_API_KEY_HERE",
)

client.senders.update_sender(
    sender_id=1,
    email="campaigns@enterprise.com",
    ips=[
        UpdateSenderRequestIpsItem(
            domain="enterprise.com",
            ip="192.168.1.100",
            weight=70,
        ),
        UpdateSenderRequestIpsItem(
            domain="mail.enterprise.com",
            ip="192.168.1.101",
            weight=30,
        )
    ],
    name="Multi-IP Sender",
)

```

```php Update sender with multiple dedicated IPs
<?php

namespace Example;

use Brevo\Brevo;
use Brevo\Senders\Requests\UpdateSenderRequest;
use Brevo\Senders\Types\UpdateSenderRequestIpsItem;

$client = new Brevo(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->senders->updateSender(
    1,
    new UpdateSenderRequest([
        'email' => 'campaigns@enterprise.com',
        'ips' => [
            new UpdateSenderRequestIpsItem([
                'domain' => 'enterprise.com',
                'ip' => '192.168.1.100',
                'weight' => 70,
            ]),
            new UpdateSenderRequestIpsItem([
                'domain' => 'mail.enterprise.com',
                'ip' => '192.168.1.101',
                'weight' => 30,
            ]),
        ],
        'name' => 'Multi-IP Sender',
    ]),
);

```

```go Update sender with multiple dedicated IPs
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"email\": \"campaigns@enterprise.com\",\n  \"ips\": [\n    {\n      \"domain\": \"enterprise.com\",\n      \"ip\": \"192.168.1.100\",\n      \"weight\": 70\n    },\n    {\n      \"domain\": \"mail.enterprise.com\",\n      \"ip\": \"192.168.1.101\",\n      \"weight\": 30\n    }\n  ],\n  \"name\": \"Multi-IP Sender\"\n}")

	req, _ := http.NewRequest("PUT", 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 Update sender with multiple dedicated IPs
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"email\": \"campaigns@enterprise.com\",\n  \"ips\": [\n    {\n      \"domain\": \"enterprise.com\",\n      \"ip\": \"192.168.1.100\",\n      \"weight\": 70\n    },\n    {\n      \"domain\": \"mail.enterprise.com\",\n      \"ip\": \"192.168.1.101\",\n      \"weight\": 30\n    }\n  ],\n  \"name\": \"Multi-IP Sender\"\n}"

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

```java Update sender with multiple dedicated IPs
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.brevo.com/v3/senders/1")
  .header("api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"email\": \"campaigns@enterprise.com\",\n  \"ips\": [\n    {\n      \"domain\": \"enterprise.com\",\n      \"ip\": \"192.168.1.100\",\n      \"weight\": 70\n    },\n    {\n      \"domain\": \"mail.enterprise.com\",\n      \"ip\": \"192.168.1.101\",\n      \"weight\": 30\n    }\n  ],\n  \"name\": \"Multi-IP Sender\"\n}")
  .asString();
```

```csharp Update sender with multiple dedicated IPs
using RestSharp;

var client = new RestClient("https://api.brevo.com/v3/senders/1");
var request = new RestRequest(Method.PUT);
request.AddHeader("api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"campaigns@enterprise.com\",\n  \"ips\": [\n    {\n      \"domain\": \"enterprise.com\",\n      \"ip\": \"192.168.1.100\",\n      \"weight\": 70\n    },\n    {\n      \"domain\": \"mail.enterprise.com\",\n      \"ip\": \"192.168.1.101\",\n      \"weight\": 30\n    }\n  ],\n  \"name\": \"Multi-IP Sender\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update sender with multiple dedicated IPs
import Foundation

let headers = [
  "api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "email": "campaigns@enterprise.com",
  "ips": [
    [
      "domain": "enterprise.com",
      "ip": "192.168.1.100",
      "weight": 70
    ],
    [
      "domain": "mail.enterprise.com",
      "ip": "192.168.1.101",
      "weight": 30
    ]
  ],
  "name": "Multi-IP Sender"
] as [String : Any]

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

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