> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tess.im/llms.txt
> Use this file to discover all available pages before exploring further.

# Restore Artifact Version

> Writes an earlier version again as the new latest version; history is kept. The restored version is not shared until you publish it.

Authenticate with a Tess API token in the `Authorization: Bearer` header. See the [Artifacts API guide](https://docs.tess.im/en/artifacts-api.md) for the full flow, permissions and ownership rules.

### **Code Examples**

```http cURL theme={null}
curl --request POST \
  --url 'https://api.tess.im/artifacts/artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f/restore' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'x-workspace-id: YOUR_WORKSPACE_ID' \
  --header 'Content-Type: application/json' \
  --data '{
    "version": 1
  }'
```

```json Node.js theme={null}
const axios = require('axios');

const config = {
  method: 'post',
  url: 'https://api.tess.im/artifacts/artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f/restore',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'x-workspace-id': 'YOUR_WORKSPACE_ID',
    'Content-Type': 'application/json'
  },
  data: {
    "version": 1
  }
};

try {
  const response = await axios(config);
  console.log(response.data);
} catch (error) {
  console.error(error);
}
```

```python Python theme={null}
import requests

url = "https://api.tess.im/artifacts/artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f/restore"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "x-workspace-id": "YOUR_WORKSPACE_ID",
    "Content-Type": "application/json"
}
payload = {
  "version": 1
}

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

```php PHP theme={null}
<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.tess.im/artifacts/artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f/restore",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode(["version" => 1]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer YOUR_API_KEY",
    "x-workspace-id: YOUR_WORKSPACE_ID",
    "Content-Type: application/json"
  ]
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "Error: " . $err;
} else {
  echo $response;
}
```

```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.tess.im/artifacts/artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f/restore"))
    .header("Authorization", "Bearer YOUR_API_KEY")
    .header("x-workspace-id", "YOUR_WORKSPACE_ID")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"version\": 1\n}"))
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```

```go Go theme={null}
package main

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

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("POST", "https://api.tess.im/artifacts/artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f/restore", strings.NewReader(`{
  "version": 1
}`))
    if err != nil {
        fmt.Println(err)
        return
    }

    req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
    req.Header.Add("Content-Type", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(body))
}
```

```jsonnet .NET theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
            client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
            var content = new StringContent(@"{
  ""version"": 1
}", Encoding.UTF8, "application/json");

            var response = await client.PostAsync("https://api.tess.im/artifacts/artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f/restore", content);
            string responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
    }
}
```

```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'json'

uri = URI('https://api.tess.im/artifacts/artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f/restore')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'
request['Content-Type'] = 'application/json'
request.body = { 'version' => 1 }.to_json

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

### **Path Parameters**

**universal\_id** `string` *required*

The artifact ID (`universal_id`), for example `artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f`.

### **Headers**

**x-workspace-id** `integer` *required*

Workspace ID. **Required as of 2026-09-01.** Until then, if omitted, the user's selected workspace is used (deprecated). After the cutoff, a missing header returns **422**.

### **Request Body**

**version** `integer` *required*

Version to restore (minimum 1).

### **Response**

**201**

```json theme={null}
{
  "universal_id": "artifact_5d1f0c2e-8a3b-4c6d-9e7f-1a2b3c4d5e6f",
  "version": 3,
  "title": "Weekly pipeline (final)",
  "restored_from_version": 1
}
```

### **Response fields**

**version** `integer`

The new version number.

**restored\_from\_version** `integer`

The version that was restored.

### **Errors**

| Status | Meaning |
| - | - |
| `401` | Missing or invalid API token. |
| `403` | `ARTIFACT_EDIT_FORBIDDEN`: you can read the artifact but you are not its owner. Also `ARTIFACT_FEATURE_DISABLED`, `ARTIFACT_PLAN_NOT_ALLOWED` or `ARTIFACT_ROLE_NOT_ALLOWED` when the feature, plan or role does not allow artifacts. |
| `404` | `ARTIFACT_NOT_FOUND` or `ARTIFACT_VERSION_NOT_FOUND`. |
| `422` | Validation error. |
| `429` | Too many requests. Retry after a short wait. |


## OpenAPI

````yaml api-reference/tess-public-api.openapi.json POST /artifacts/{universal_id}/restore
openapi: 3.0.0
info:
  title: Tess API
  version: '0.1'
servers:
  - url: https://api.tess.im
security: []
paths:
  /artifacts/{universal_id}/restore:
    post:
      tags:
        - Artifacts
      summary: Restore an artifact version
      description: >-
        Writes an earlier version again as the new head; history is kept. The
        restored head is not shared until published.
      operationId: ce83d00d372a5fcb5d8eb1b53cd4aa90
      parameters:
        - name: universal_id
          in: path
          required: true
          schema:
            type: string
        - name: x-workspace-id
          in: header
          description: >-
            Workspace id. If not provided, the user's selected workspace is
            used.
          required: false
          schema:
            type: integer
      requestBody:
        required: true
        content:
          application/json:
            schema:
              required:
                - version
              properties:
                version:
                  type: integer
                  minimum: 1
              type: object
      responses:
        '201':
          description: New head version
          content:
            application/json:
              schema:
                properties:
                  universal_id:
                    type: string
                  version:
                    type: integer
                  title:
                    type: string
                  restored_from_version:
                    type: integer
                type: object
        '403':
          description: >-
            ARTIFACT_EDIT_FORBIDDEN (the caller can read the artifact but is not
            its owner), ARTIFACT_FEATURE_DISABLED, ARTIFACT_PLAN_NOT_ALLOWED or
            ARTIFACT_ROLE_NOT_ALLOWED
        '404':
          description: ARTIFACT_NOT_FOUND or ARTIFACT_VERSION_NOT_FOUND
        '422':
          description: Validation error
        '429':
          description: Too many requests
      security:
        - token: []
components:
  securitySchemes:
    token:
      type: http
      bearerFormat: Bearer
      scheme: bearer

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.