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

# Update a client data list by external ID

POST https://api.yunojuno.com/client_data_lists/by_external_id/{external_id}/
Content-Type: application/json

Update a client data list using its external ID.

Update a client data list asynchronously using your external ID for the list. The external ID is set by you. The operation is queued and the response includes an async request you can poll for completion.

Reference: https://docs.yunojuno.com/client-api/client-data-lists/by-external-id-create

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `external_id` (string, required)

### Body (application/json)

This endpoint expects an UpdateClientDataList.

- `data_list_options` (list of DataListOption, required) — Array of options to update in the data list

## Response

### 202

- `async_request` (AsyncRequest, required) — The asynchronous request object. This object represents a request that has been submitted for further background processing.

## Types

### DataListOption

- `value` (string, required) — The value/key for this option
- `label` (string, required) — The human-readable label for this option
- `parent` (string, optional) — The value of a parent option from another data list that this option is a child of
- `metadata` (any, optional) — Additional metadata for this option. Must conform to the data list's metadata schema

### AsyncRequest

The asynchronous request object. This object represents a request that has been submitted for further background processing.

- `async_request_id` (string, required)
- `async_request_url` (string, required) — Get the fully qualified URL for this async request.
- `state` (string, required)
- `source` (string, required)
- `created_at` (string, required)
- `processed_at` (string, required, nullable) — Get the timestamp when the request was processed.
- `error_message` (string, required)

## Examples

**Request**

```json
{
  "data_list_options": [
    {
      "value": "string",
      "label": "string"
    }
  ]
}
```

**Response**

```json
{
  "async_request": {
    "async_request_id": "string",
    "async_request_url": "string",
    "state": "string",
    "source": "string",
    "created_at": "2024-01-15T09:30:00Z",
    "processed_at": "2024-01-15T09:30:00Z",
    "error_message": "string"
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.yunojuno.com/client_data_lists/by_external_id/external_id/"

payload = { "data_list_options": [
        {
            "value": "string",
            "label": "string"
        }
    ] }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://api.yunojuno.com/client_data_lists/by_external_id/external_id/';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"data_list_options":[{"value":"string","label":"string"}]}'
};

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

```go
package main

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

func main() {

	url := "https://api.yunojuno.com/client_data_lists/by_external_id/external_id/"

	payload := strings.NewReader("{\n  \"data_list_options\": [\n    {\n      \"value\": \"string\",\n      \"label\": \"string\"\n    }\n  ]\n}")

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

url = URI("https://api.yunojuno.com/client_data_lists/by_external_id/external_id/")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"data_list_options\": [\n    {\n      \"value\": \"string\",\n      \"label\": \"string\"\n    }\n  ]\n}"

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

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

HttpResponse<String> response = Unirest.post("https://api.yunojuno.com/client_data_lists/by_external_id/external_id/")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"data_list_options\": [\n    {\n      \"value\": \"string\",\n      \"label\": \"string\"\n    }\n  ]\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.yunojuno.com/client_data_lists/by_external_id/external_id/', [
  'body' => '{
  "data_list_options": [
    {
      "value": "string",
      "label": "string"
    }
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.yunojuno.com/client_data_lists/by_external_id/external_id/");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"data_list_options\": [\n    {\n      \"value\": \"string\",\n      \"label\": \"string\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["data_list_options": [
    [
      "value": "string",
      "label": "string"
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.yunojuno.com/client_data_lists/by_external_id/external_id/")! 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()
```