# Exporting Data

Export channels and users to retrieve messages, metadata, and associated data. All exports run asynchronously and return a task ID for tracking status.

<admonition type="note">

All export endpoints require server-side authentication.

</admonition>

## Exporting Channels

<Tabs>

```js label="JavaScript"
// Export a single channel
const response = await serverClient.exportChannel(
  {
    type: "livestream",
    id: "white-room",
    messages_since: "2020-11-10T09:30:00.000Z",
    messages_until: "2020-11-10T11:30:00.000Z",
  },
  {
    include_truncated_messages: true,
    include_soft_deleted_channels: true,
  },
);

const taskID = response.task_id;

// Export multiple channels
const response = await serverClient.exportChannels(
  [
    {
      type: "livestream",
      id: "white-room",
      messages_since: "2020-11-10T09:30:00.000Z",
      messages_until: "2020-11-10T11:30:00.000Z",
    },
    {
      type: "livestream",
      id: "white-room2",
    },
  ],
  {
    include_truncated_messages: true,
    include_soft_deleted_channels: true,
  },
);
const taskID = response.task_id;
```

```python label="Python"
from getstream.models import ChannelExport

# Export a single channel
response = client.chat.export_channels(
    channels=[
        ChannelExport(
            type="livestream",
            id="white-room",
        ),
    ],
    include_truncated_messages=True,
    include_soft_deleted_channels=True,
)

task_id = response.data.task_id

# Export multiple channels
response = client.chat.export_channels(
    channels=[
        ChannelExport(type="livestream", id="white-room"),
        ChannelExport(type="livestream", id="white-room2"),
    ],
)

task_id = response.data.task_id
```

```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models

response = client.chat.export_channels(Models::ExportChannelsRequest.new(
  channels: [
    Models::ChannelExport.new(type: 'livestream', id: 'white-room')
  ],
  include_truncated_messages: true
))

task_id = response.task_id
```

```php label="PHP"
$response = $client->exportChannels(new Models\ExportChannelsRequest(
    channels: [
        new Models\ChannelExport(
            type: "livestream",
            id: "white-room",
            messagesSince: new \DateTime("2020-11-10T09:30:00Z"),
            messagesUntil: new \DateTime("2020-11-10T11:30:00Z"),
        ),
    ],
    includeTruncatedMessages: true,
));

$taskId = $response->getData()->taskID;
```

```go label="Go"
since := time.Date(2020, time.November, 10, 9, 30, 0, 0, time.UTC)
until := time.Date(2020, time.November, 10, 11, 30, 0, 0, time.UTC)

response, err := client.Chat().ExportChannels(ctx, &getstream.ExportChannelsRequest{
  Channels: []getstream.ChannelExport{
    {
      Type:          getstream.PtrTo("livestream"),
      ID:            getstream.PtrTo("white-room"),
      MessagesSince: &getstream.Timestamp{Time: &since},
      MessagesUntil: &getstream.Timestamp{Time: &until},
    },
  },
  IncludeTruncatedMessages: getstream.PtrTo(true),
})

taskId := response.Data.TaskID
```

```csharp label="C#"
var response = await chat.ExportChannelsAsync(new ExportChannelsRequest
{
    Channels = new List<ChannelExport>
    {
        new ChannelExport
        {
            ID = "white-room",
            Type = "livestream",
            MessagesSince = new DateTime(2020, 11, 10, 9, 30, 0, DateTimeKind.Utc),
            MessagesUntil = new DateTime(2020, 11, 10, 11, 30, 0, DateTimeKind.Utc),
        },
    },
    IncludeTruncatedMessages = true,
});

var taskId = response.Data.TaskID;
```

```java label="Java"
chat.exportChannels(ExportChannelsRequest.builder()
    .channels(List.of(ChannelExport.builder()
        .type("channel-type")
        .id("channel-id")
        .build()))
    .build()).execute();
```

</Tabs>

### Channel Export Options

| Parameter                       | Description                                                 |
| ------------------------------- | ----------------------------------------------------------- |
| `type`                          | Channel type (required)                                     |
| `id`                            | Channel ID (required)                                       |
| `messages_since`                | Export messages after this timestamp (RFC3339 format)       |
| `messages_until`                | Export messages before this timestamp (RFC3339 format)      |
| `include_truncated_messages`    | Include messages that were truncated (default: `false`)     |
| `include_soft_deleted_channels` | Include soft-deleted channels (default: `false`)            |
| `version`                       | Export format: `v1` (default) or `v2` (line-separated JSON) |

<admonition type="info">

A single request can export up to 25 channels.

</admonition>

### Export Format (v2)

Add `version: "v2"` for line-separated JSON output, where each entity appears on its own line.

<Tabs>

```js label="JavaScript"
const response = await serverClient.exportChannel(
  {
    type: "livestream",
    id: "white-room",
  },
  {
    version: "v2",
  },
);
```

```python label="Python"
from getstream.models import ChannelExport

response = client.chat.export_channels(
    channels=[
        ChannelExport(type="livestream", id="white-room"),
    ],
    version="v2",
)
```

```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models

response = client.chat.export_channels(Models::ExportChannelsRequest.new(
  channels: [
    Models::ChannelExport.new(type: 'livestream', id: 'white-room')
  ],
  version: 'v2'
))
```

```php label="PHP"
$response = $client->exportChannels(new Models\ExportChannelsRequest(
    channels: [new Models\ChannelExport(type: "livestream", id: "white-room")],
    version: "v2",
));
```

```go label="Go"
response, err := client.Chat().ExportChannels(ctx, &getstream.ExportChannelsRequest{
  Channels: []getstream.ChannelExport{
    {
      Type: getstream.PtrTo("livestream"),
      ID:   getstream.PtrTo("white-room"),
    },
  },
  Version: getstream.PtrTo("v2"),
})
```

```csharp label="C#"
var response = await chat.ExportChannelsAsync(new ExportChannelsRequest
{
    Channels = new List<ChannelExport>
    {
        new ChannelExport
        {
            ID = "white-room",
            Type = "livestream",
        },
    },
    Version = "v2",
});
```

```java label="Java"
chat.exportChannels(ExportChannelsRequest.builder()
    .channels(List.of(ChannelExport.builder()
        .type("channel-type")
        .id("channel-id")
        .build()))
    .version("v2")
    .build()).execute();
```

</Tabs>

### Checking Export Status

Poll the task status using the returned task ID. When the task completes, the response includes a URL to download the JSON export file.

<Tabs>

```js label="JavaScript"
const response = await serverClient.getExportChannelStatus(taskId);

console.log(response.status); // Task status
console.log(response.result); // Result object (when completed)
console.log(response.result.url); // Download URL
console.log(response.error); // Error description (if failed)
```

```python label="Python"
response = client.get_task(id=task_id)

print(response.data.status)          # Task status
print(response.data.result)          # Result object (when completed)
print(response.data.result["url"])   # Download URL
print(response.data.error)           # Error description (if failed)
```

```ruby label="Ruby"
require 'getstream_ruby'

response = client.common.get_task(task_id)

puts response.status            # Task status
puts response.result            # Result object (when completed)
puts response.result['url']     # Download URL
puts response.error             # Error description (if failed)
```

```php label="PHP"
$response = $client->getTask($taskId);

echo $response->getData()->status;
```

```go label="Go"
task, err := client.GetTask(ctx, response.Data.TaskID, &getstream.GetTaskRequest{})

fmt.Println(task.Data.Status)           // Task status
fmt.Println(task.Data.Result)           // Result object (when completed)
fmt.Println(task.Data.Result["url"])    // Download URL
fmt.Println(task.Data.Error)            // Error description (if failed)
```

```csharp label="C#"
var response = await client.GetTaskAsync(taskId);

Console.WriteLine(response.Data.Status);          // Task status
Console.WriteLine(response.Data.Result);          // Result object (when completed)
Console.WriteLine(response.Data.Result["url"]);   // Download URL
Console.WriteLine(response.Data.Error);           // Error description (if failed)
```

```java label="Java"
var response = client.getTask(taskId, GetTaskRequest.builder().build()).execute().getData();

System.out.println(response.getStatus());          // Task status
System.out.println(response.getResult());          // Result object (when completed)
System.out.println(response.getResult().get("url")); // Download URL
System.out.println(response.getError());           // Error description (if failed)
```

</Tabs>

<admonition type="info">

- Download URLs expire after 24 hours but are regenerated on each status request
- Export files remain available for 60 days
- Timestamps use UTC in RFC3339 format (e.g., `2021-02-17T08:17:49.745857Z`)

</admonition>

## Exporting Users

Export user data including messages, reactions, calls, and custom data. The export uses line-separated JSON format (same as channel export v2).

<Tabs>

```js label="JavaScript"
const response = await serverClient.exportUsers({
  user_ids: [user1.id, user2.id],
});
const taskID = response.task_id;
```

```csharp label="C#"
var exportResponse = await client.ExportUsersAsync(new ExportUsersRequest
{
    UserIds = new List<string> { "user-id-1", "user-id-2" },
});
var taskId = exportResponse.Data.TaskID;
```

</Tabs>

<admonition type="info">

A single request can export up to 25 users with a maximum of 10,000 messages per user. [Contact support](https://getstream.io/contact/support/) to export users with more than 10,000 messages.

</admonition>

### Checking Export Status

<Tabs>

```js label="JavaScript"
const response = await serverClient.getTask(taskId);

if (response.status === "completed") {
  console.log(response.result.url);
}
```

```python label="Python"
response = client.get_task(id=task_id)

if response.data.status == "completed":
    print(response.data.result["url"])
```

```go label="Go"
resp, err := client.GetTask(ctx, taskID, &getstream.GetTaskRequest{})
if err != nil {
  return err
}

if resp.Data.Status == "completed" {
  fmt.Println(resp.Data.Result["url"])
}
```

```php label="PHP"
$response = $client->getTask($taskId);

if ($response->getData()->status === "completed") {
    echo $response->getData()->result["url"];
}
```

```ruby label="Ruby"
require 'getstream_ruby'

response = client.common.get_task(task_id)

if response.status == 'completed'
  puts(response.result['url'])
end
```

```java label="Java"
var taskStatusResponse = client.getTask(taskId, GetTaskRequest.builder().build()).execute().getData();
// "completed".equals(taskStatusResponse.getStatus());
```

```csharp label="C#"
var taskStatus = await client.GetTaskAsync(taskId);
if (taskStatus.Data.Status == "completed")
{
    var exportedFileUrl = taskStatus.Data.Result["url"].ToString();
}
```

</Tabs>


---

This page was last updated at 2026-05-22T16:32:21.528Z.

For the most recent version of this documentation, visit [https://getstream.io/chat/docs/unity/exporting-channels/](https://getstream.io/chat/docs/unity/exporting-channels/).