# 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

<codetabs>

<codetabs-item value="javascript" label="JavaScript">

```js
// 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;
```

</codetabs-item>

<codetabs-item value="python" label="Python">

```python
response = client.export_channel(
  "livestream",
  "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,
)

task_id = response["task_id"]

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

task_id = response["task_id"]
```

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
channel_ids = client.query_channels({}, limit:, offset:)['channels'].pluck('channel').pluck('id')
channel_map = channel_ids.map { |e| [[:type, 'messaging'], [:id, e]].to_h }
options = { include_truncated_messages: true }
response = client.export_channels(*channel_map, **options)
```

</codetabs-item>

<codetabs-item value="php" label="PHP">

```php
$response = $client->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]
);

$taskId = $response['task_id'];
```

</codetabs-item>

<codetabs-item value="go" label="Go">

```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)
opts := &ExportChannelOptions{IncludeTruncatedMessages: &includeTruncated}

expChannels := []*ExportableChannel{
	{Type: "livestream", ID: "white-room", MessagesSince: &since, MessagesUntil: &until},
}

response, err := c.ExportChannels(ctx, expChannels, opts)

taskId := response.TaskID
```

</codetabs-item>

<codetabs-item value="csharp" label="C#">

```csharp
var response = await channelClient.ExportChannelsAsync(new ExportChannelRequest
{
  Channels = new[] { new ExportChannelItem
  {
    Id = "white-room",
    Type = "livestream",
    MessagesSince = new DateTimeOffset(2020, 11, 10, 9, 30, 0, TimeSpan.Zero),
    MessagesUntil = new DateTimeOffset(2020, 11, 10, 11, 30, 0, TimeSpan.Zero),
  }},
  IncludeTruncatedMessages = true,
});

var taskId = response.TaskId;
```

</codetabs-item>

<codetabs-item value="java" label="Java">

```java
Channel.export()
  .channel(
    ChannelExportRequestObject.builder()
      .type("channel-type")
      .id("channel-id")
      .build())
  .request();
```

</codetabs-item>

</codetabs>

### 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.

<codetabs>

<codetabs-item value="javascript" label="JavaScript">

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

</codetabs-item>

<codetabs-item value="python" label="Python">

```python
response = client.export_channel(
  "livestream",
  "white-room",
  version="v2",
)
```

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
options = { version: 'v2' }
resp = client.export_channels({
  type: 'livestream',
  id: 'white-room',
}, **options)
```

</codetabs-item>

<codetabs-item value="php" label="PHP">

```php
$response = $client->exportChannel([
  'type' => 'livestream',
  'id' => 'white-room',
  ],
  ['version' => 'v2']
);
```

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
opts := &ExportChannelOptions{Version: "v2"}

expChannels := []*ExportableChannel{
	{Type: "livestream", ID: "white-room"},
}

response, err := c.ExportChannels(ctx, expChannels, opts)
```

</codetabs-item>

<codetabs-item value="csharp" label="C#">

```csharp
var response = await channelClient.ExportChannelsAsync(new ExportChannelRequest
{
  Channels = new[] { new ExportChannelItem
  {
    Id = "white-room",
    Type = "livestream",
  }},
  Version = "v2",
});
```

</codetabs-item>

<codetabs-item value="java" label="Java">

```java
Channel.export()
  .channel(
    ChannelExportRequestObject.builder()
      .type("channel-type")
      .id("channel-id")
      .build())
  .version("v2")
  .request();
```

</codetabs-item>

</codetabs>

### 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.

<codetabs>

<codetabs-item value="javascript" label="JavaScript">

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

</codetabs-item>

<codetabs-item value="python" label="Python">

```python
response = client.get_export_channel_status(task_id)

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
response = client.get_export_channel_status(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)
```

</codetabs-item>

<codetabs-item value="php" label="PHP">

```php
$response = $client->getExportChannelStatus($taskId);

echo $response['status'];          // Task status
echo $response['result'];          // Result object (when completed)
echo $response['result']['url'];   // Download URL
echo $response['error'];           // Error description (if failed)
```

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
task, err := c.GetExportChannelsTask(ctx, response.TaskID)

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

</codetabs-item>

<codetabs-item value="csharp" label="C#">

```csharp
var response = await channelClient.GetExportChannelsStatusAsync(taskId);

Console.WriteLine(response.Status);      // Task status
Console.WriteLine(response.Result);      // Result object (when completed)
Console.WriteLine(response.Result.Url);  // Download URL
Console.WriteLine(response.Error);       // Error description (if failed)
```

</codetabs-item>

<codetabs-item value="java" label="Java">

```java
var response = Channel.exportStatus(taskId).request();

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

</codetabs-item>

</codetabs>

<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).

<codetabs>

<codetabs-item value="javascript" label="JavaScript">

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

</codetabs-item>

<codetabs-item value="csharp" label="C#">

```csharp
var exportResponse = await _userClient.ExportUsersAsync(new[] { "user-id-1", "user-id-2" });
var taskId = exportResponse.TaskId;
```

</codetabs-item>

</codetabs>

<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

<codetabs>

<codetabs-item value="javascript" label="JavaScript">

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

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

</codetabs-item>

<codetabs-item value="python" label="Python">

```python
response = client.get_task(task_id)

if response['status'] == 'completed':
  print(response['result']['url'])
```

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
resp, err := client.GetTask(taskID)
if err != nil {
  return err
}

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

</codetabs-item>

<codetabs-item value="php" label="PHP">

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

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
response = client.get_task(task_id)

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

</codetabs-item>

<codetabs-item value="java" label="Java">

```java
var taskStatusResponse = TaskStatus.get(taskId).request();
// "completed".equals(taskStatusResponse.status);
```

</codetabs-item>

<codetabs-item value="csharp" label="C#">

```csharp
var taskStatus = await taskClient.GetTaskStatusAsync(taskId);
if (taskStatus.Status == AsyncTaskStatus.Completed)
{
    var exportedFileUrl = taskStatus.Result.Values.First().ToString();
}
```

</codetabs-item>

</codetabs>


---

This page was last updated at 2026-03-05T19:06:29.268Z.

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/).