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

# Partially update an asset (RFC 7386 JSON Merge Patch)

PATCH https://{tenant}.atomicwork.com/api/v1/assets/{asset_id}
Content-Type: application/json

Partially updates an asset using JSON Merge Patch semantics (RFC 7386). Send only the
fields you want to change under `form_fields`: a field present with a value sets it, a field
present with `null` clears it, and an omitted field is left untouched. Unlike PUT, you do
not need to resend the entire form. Concurrent updates are guarded by optimistic locking and
retried automatically.


Reference: https://support.atomicwork.com/api-reference/atomicwork-public-api/assets/patchapi-v-1-assets-asset-id

## Authentication

- `X-Api-Key` header (required) — API Key authentication via header

## Request

### Path parameters

- `asset_id` (long, required) — assetId

### Headers

- `X-Workspace-Id` (string, optional)

## Response

### 200

Successful response

## Examples

**Request**

```json
{}
```

**Response**

```json
{}
```

**SDK Code**

```python Assets_patchapi_v1_assets__asset_id_example
import requests

url = "https://{tenant}.atomicwork.com/api/v1/assets/1"

payload = {}
headers = {
    "X-Workspace-Id": "{{workspace_id}}",
    "X-Api-Key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Assets_patchapi_v1_assets__asset_id_example
const url = 'https://{tenant}.atomicwork.com/api/v1/assets/1';
const options = {
  method: 'PATCH',
  headers: {
    'X-Workspace-Id': '{{workspace_id}}',
    'X-Api-Key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: '{}'
};

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

```go Assets_patchapi_v1_assets__asset_id_example
package main

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

func main() {

	url := "https://{tenant}.atomicwork.com/api/v1/assets/1"

	payload := strings.NewReader("{}")

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

	req.Header.Add("X-Workspace-Id", "{{workspace_id}}")
	req.Header.Add("X-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 Assets_patchapi_v1_assets__asset_id_example
require 'uri'
require 'net/http'

url = URI("https://{tenant}.atomicwork.com/api/v1/assets/1")

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

request = Net::HTTP::Patch.new(url)
request["X-Workspace-Id"] = '{{workspace_id}}'
request["X-Api-Key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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

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

HttpResponse<String> response = Unirest.patch("https://{tenant}.atomicwork.com/api/v1/assets/1")
  .header("X-Workspace-Id", "{{workspace_id}}")
  .header("X-Api-Key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://{tenant}.atomicwork.com/api/v1/assets/1', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-Api-Key' => '<apiKey>',
    'X-Workspace-Id' => '{{workspace_id}}',
  ],
]);

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

```csharp Assets_patchapi_v1_assets__asset_id_example
using RestSharp;

var client = new RestClient("https://{tenant}.atomicwork.com/api/v1/assets/1");
var request = new RestRequest(Method.PATCH);
request.AddHeader("X-Workspace-Id", "{{workspace_id}}");
request.AddHeader("X-Api-Key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Assets_patchapi_v1_assets__asset_id_example
import Foundation

let headers = [
  "X-Workspace-Id": "{{workspace_id}}",
  "X-Api-Key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://{tenant}.atomicwork.com/api/v1/assets/1")! 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()
```