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.

All export endpoints require server-side authentication.

Exporting Channels

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

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

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

$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;

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

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;

chat.exportChannels(ExportChannelsRequest.builder()
    .channels(List.of(ChannelExport.builder()
        .type("channel-type")
        .id("channel-id")
        .build()))
    .build()).execute();

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)

A single request can export up to 25 channels.

Export Format (v2)

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

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

from getstream.models import ChannelExport

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

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

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

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

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

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

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.

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)

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)

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)

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)

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)

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)

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)

Exporting Users

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

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

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

A single request can export up to 25 users with a maximum of 10,000 messages per user. Contact support to export users with more than 10,000 messages.

Checking Export Status

const response = await serverClient.getTask(taskId);

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

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

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

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

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

require 'getstream_ruby'

response = client.common.get_task(task_id)

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

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

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

Importing Data

Stream CLI

On this page:

Exporting Channels
Exporting Users
- Checking Export Status