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

# Firmware update NVLink Domains

PATCH https://nico-rest-api.nico.svc.cluster.local/v2/org/{org}/nico/domain/nvlink/firmware
Content-Type: application/json

Update firmware for one or more NVLink Domains identified by UUID. Flow resolves each NVLink Domain to its member Racks and creates one task per Rack.

Org must have an Infrastructure Provider entity. User must have authorization role with `PROVIDER_ADMIN` suffix.

Reference: https://docs.nvidia.com/infra-controller/rest-api-reference/api-reference/nv-link-domain/firmware-update-nvlink-domains

## Authentication

- `Authorization` header (bearer token, required) — ``` export JWT_BEARER_TOKEN="<jwt-bearer-token>" # Example org name: "acme-inc export ORG_NAME=<org-name> # Use the JWT bearer token in your API request auth header: curl -v -X GET -H "Content-Type: application/json" -H "Authorization: Bearer $JWT_BEARER_TOKEN" https://nico-rest-api.nico.svc.cluster.local/v2/org/$ORG_NAME/nico/user/current ```

## Request

### Path parameters

- `org` (string, required) — Name of the Org

### Body (application/json)

- `siteId` (string, required) — ID of the Site
- `domainIds` (list of string, required) — UUIDs of the NVLink Domains to update. IDs must be unique after UUID normalization (case-insensitive).
- `version` (string, optional, nullable) — Target firmware version. When empty, null, or omitted, use the default firmware version for each targeted component.
- `ruleId` (string, optional) — Optional Operation Rule UUID. When set, pins every task spawned by this operation to the named rule and overrides Flow's default rule resolution.
- `overrideReadinessCheck` (boolean, optional, default: false) — When true, proceed even if one or more target components (or hosts on the owning rack for rack-scoped components) are reported as not ready by their persisted status. Intended for operator-supervised maintenance.

## Response

### 200

OK

- `taskIds` (list of string, optional) — List of task IDs created for the firmware update operation

## Examples

**Request**

```json
{
  "siteId": "550e8400-e29b-41d4-a716-446655440000",
  "domainIds": [
    "650e8400-e29b-41d4-a716-446655440001",
    "750e8400-e29b-41d4-a716-446655440002"
  ],
  "version": "24.11.0"
}
```

**Response**

```json
{
  "taskIds": [
    "550e8400-e29b-41d4-a716-446655440000"
  ]
}
```

**SDK Code**

```python update-domains
import requests

url = "https://nico-rest-api.nico.svc.cluster.local/v2/org/org/nico/domain/nvlink/firmware"

payload = {
    "siteId": "550e8400-e29b-41d4-a716-446655440000",
    "domainIds": ["650e8400-e29b-41d4-a716-446655440001", "750e8400-e29b-41d4-a716-446655440002"],
    "version": "24.11.0"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())
```

```javascript update-domains
const url = 'https://nico-rest-api.nico.svc.cluster.local/v2/org/org/nico/domain/nvlink/firmware';
const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"siteId":"550e8400-e29b-41d4-a716-446655440000","domainIds":["650e8400-e29b-41d4-a716-446655440001","750e8400-e29b-41d4-a716-446655440002"],"version":"24.11.0"}'
};

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

```go update-domains
package main

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

func main() {

	url := "https://nico-rest-api.nico.svc.cluster.local/v2/org/org/nico/domain/nvlink/firmware"

	payload := strings.NewReader("{\n  \"siteId\": \"550e8400-e29b-41d4-a716-446655440000\",\n  \"domainIds\": [\n    \"650e8400-e29b-41d4-a716-446655440001\",\n    \"750e8400-e29b-41d4-a716-446655440002\"\n  ],\n  \"version\": \"24.11.0\"\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	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-domains
require 'uri'
require 'net/http'

url = URI("https://nico-rest-api.nico.svc.cluster.local/v2/org/org/nico/domain/nvlink/firmware")

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

request = Net::HTTP::Patch.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"siteId\": \"550e8400-e29b-41d4-a716-446655440000\",\n  \"domainIds\": [\n    \"650e8400-e29b-41d4-a716-446655440001\",\n    \"750e8400-e29b-41d4-a716-446655440002\"\n  ],\n  \"version\": \"24.11.0\"\n}"

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

```java update-domains
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.patch("https://nico-rest-api.nico.svc.cluster.local/v2/org/org/nico/domain/nvlink/firmware")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"siteId\": \"550e8400-e29b-41d4-a716-446655440000\",\n  \"domainIds\": [\n    \"650e8400-e29b-41d4-a716-446655440001\",\n    \"750e8400-e29b-41d4-a716-446655440002\"\n  ],\n  \"version\": \"24.11.0\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://nico-rest-api.nico.svc.cluster.local/v2/org/org/nico/domain/nvlink/firmware', [
  'body' => '{
  "siteId": "550e8400-e29b-41d4-a716-446655440000",
  "domainIds": [
    "650e8400-e29b-41d4-a716-446655440001",
    "750e8400-e29b-41d4-a716-446655440002"
  ],
  "version": "24.11.0"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp update-domains
using RestSharp;

var client = new RestClient("https://nico-rest-api.nico.svc.cluster.local/v2/org/org/nico/domain/nvlink/firmware");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"siteId\": \"550e8400-e29b-41d4-a716-446655440000\",\n  \"domainIds\": [\n    \"650e8400-e29b-41d4-a716-446655440001\",\n    \"750e8400-e29b-41d4-a716-446655440002\"\n  ],\n  \"version\": \"24.11.0\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift update-domains
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "siteId": "550e8400-e29b-41d4-a716-446655440000",
  "domainIds": ["650e8400-e29b-41d4-a716-446655440001", "750e8400-e29b-41d4-a716-446655440002"],
  "version": "24.11.0"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://nico-rest-api.nico.svc.cluster.local/v2/org/org/nico/domain/nvlink/firmware")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()
```