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;

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"]

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)

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

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

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;

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

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",
  },
);

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

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

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

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

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

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

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

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

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

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)

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

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)

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)

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)

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 _userClient.ExportUsersAsync(new[] { "user-id-1", "user-id-2" });
var taskId = exportResponse.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);
}

response = client.get_task(task_id)

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

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

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

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

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

response = client.get_task(task_id)

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

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

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

Importing Data

Stream CLI