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

# Export the Agent configuration as a downloadable archive

GET https://example.ada.support/api/v2/config/

Builds the export in the background and returns a `job_id`
immediately. Poll `GET /v2/config/jobs/{job_id}` until the status is
`completed`, then take the temporary download link from the `result`.

That `result` also carries `secrets`: the Agent's client-secret names, each
`null`. Secret values never leave the source Agent, so this is the list the
target will need — fill it in and send it as the import request's `secrets`.
No download required.

The export is a single timestamped archive, e.g.
`config_20260806-143235.tar.gz`. Unpack it to get:

* `config.json` — the full configuration document, covering the AI Agent
  persona, variables, actions, handoffs, processes, greetings, v2 generative
  playbooks, coaching, custom instructions, glossary, knowledge sources,
  CSAT settings, your custom regex redactions, the image redaction setting (Ada's built-in PII redaction switches are not part of a snapshot), and the enabled action-integration id list.
* `articles/` — the knowledge articles as JSON Lines, one article per line, partitioned by a hash of their `external_id` across
  `articles_*.jsonl` files so no single file has to be read whole.
* `manifest.json` — an index of the above, including the article count and
  the partitioning scheme. It also carries `available`, how many articles
  the Agent has.

Reference: https://docs.ada.cx/reference/snapshot-api/export

## Authentication

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

## Response

### 202

Export accepted for async processing. Poll the returned `job_id` at `GET /v2/config/jobs/{job_id}` for the status and the archive's temporary download link.

- `job_id` (string, required) — The id to poll for the job status and result
- `status` (enum, required) — `queued` for a newly accepted job. An export submitted while one is already running for the Agent returns that job instead of starting a second, so its status may already be `in_progress` — poll the `job_id` either way.
  - Allowed values: `queued`, `in_progress`

## Errors

### 401 Unauthorized Error

Unauthorized

- `errors` (list of ErrorsErrorsItems, required) — A list of errors

### 403 Forbidden Error

Forbidden

- `errors` (list of ErrorsErrorsItems, required) — A list of errors

### 429 Too Many Requests Error

Too Many Requests

- `errors` (list of ErrorsErrorsItems, required) — A list of errors

### 500 Internal Server Error

Internal Server Error

- `errors` (list of ErrorsErrorsItems, required) — A list of errors

## Types

### ErrorsErrorsItems

- `type` (string, required) — The error type
- `message` (string, required) — The error message
- `details` (string, optional, nullable) — Extra information about the error

## Examples

**Response**

```json
{
  "job_id": "config_job_ccc3574a9b9342dbac32c50c0a656b93",
  "status": "queued"
}
```

**SDK Code**

```python
import requests

url = "https://example.ada.support/api/v2/config/"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://example.ada.support/api/v2/config/';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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"
	"net/http"
	"io"
)

func main() {

	url := "https://example.ada.support/api/v2/config/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	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://example.ada.support/api/v2/config/")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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.get("https://example.ada.support/api/v2/config/")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://example.ada.support/api/v2/config/', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://example.ada.support/api/v2/config/");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://example.ada.support/api/v2/config/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```