# Quick start

Export events, sessions, and users from a workspace.

The Export API client lets you export events, sessions, and users from your workspace in bulk, or individually by their ID. The bulk methods support pagination and optional time-based filtering.

> **Add-on**
>
> This feature is offered as an add-on. [Contact sales](https://croct.com/contact/sales?message=I%E2%80%99d+like+to+add+an+add-on+to+my+plan.\&subject=plan-upgrade) for more information.

## Install the client

Install the client using your preferred package manager:

**JavaScript — npm**

```sh
npm install @croct/export
```

**JavaScript — pnpm**

```sh
pnpm add @croct/export
```

**JavaScript — Yarn**

```sh
yarn add @croct/export
```

**JavaScript — Bun**

```sh
bun add @croct/export
```

**Java — Maven**

```xml
<dependency>
    <groupId>com.croct.client</groupId>
    <artifactId>croct-export-client</artifactId>
    <version>0.3.0</version>
</dependency>
```

**Java — Gradle**

```groovy
repositories {
  mavenCentral()
}

dependencies {
  implementation "com.croct.client:croct-export-client:0.3.0"
}
```

## Export events

Here is how to export event data from your workspace:

**Export events**

**TypeScript**

```ts
import {Configuration, ExportApi} from '@croct/export';

async function exportEvents(): Promise<void> {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  let cursor: string | undefined = undefined;
  let running = true;

  while (running) {
    const {data: {items: events, nextCursor}} = await api.exportEvents({
      pageSize: 100,
      cursor: cursor,
    });

    console.log(events);

    cursor = nextCursor;
    running = events.length > 0;
  }
}
```

**JavaScript**

```js
import {Configuration, ExportApi} from '@croct/export';

async function exportEvents() {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  let cursor = undefined;
  let running = true;

  while (running) {
    const {data: {items: events, nextCursor}} = await api.exportEvents({
      pageSize: 100,
      cursor: cursor,
    });

    console.log(events);

    cursor = nextCursor;
    running = events.length > 0;
  }
}
```

**Java**

```java
import com.croct.client.export.ApiClient;
import com.croct.client.export.ApiException;
import com.croct.client.export.api.ExportApi;
import com.croct.client.export.model.Event;
import com.croct.client.export.model.EventResponse;
import java.util.List;

public class ExportEvents {
  public static void main(String[] args) throws ApiException {
    final ApiClient client = new ApiClient();
    client.setApiKey("<API KEY>");

    final ExportApi api = new ExportApi(client);

    String cursor = null;
    final int pageSize = 100;

    while (true) {
      final EventResponse response = api.exportEvents(
        null,
        null,
        pageSize,
        cursor,
        null
      );

      final List<Event> events = response.getItems();

      System.out.println(events);

      if (events.isEmpty()) {
        break;
      }

      cursor = response.getNextCursor();
    }
  }
}
```

You can filter events by type using the `events` parameter:

**Filter events by type**

**TypeScript**

```ts
import {Configuration, EventType, ExportApi} from '@croct/export';

const {data: {items: events}} = await api.exportEvents({
  pageSize: 100,
  events: [
    EventType.PRODUCT_VIEWED,
    EventType.CHECKOUT_STARTED,
    EventType.ORDER_PLACED,
  ],
});
```

**JavaScript**

```js
import {Configuration, EventType, ExportApi} from '@croct/export';

const {data: {items: events}} = await api.exportEvents({
  pageSize: 100,
  events: [
    EventType.PRODUCT_VIEWED,
    EventType.CHECKOUT_STARTED,
    EventType.ORDER_PLACED,
  ],
});
```

**Java**

```java
import com.croct.client.export.model.EventType;
import java.util.List;

final EventResponse response = api.exportEvents(
  null,
  null,
  100,
  null,
  List.of(
    EventType.PRODUCT_VIEWED,
    EventType.CHECKOUT_STARTED,
    EventType.ORDER_PLACED
  )
);
```

See the [API reference](/reference/api/service/data-export/client/api/export-events#options-events-prop) for a complete list of event types.

## Export sessions

Here is how to export session data from your workspace:

**Export sessions**

**TypeScript**

```ts
import {Configuration, ExportApi} from '@croct/export';

async function exportSessions(): Promise<void> {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  let cursor: string | undefined = undefined;
  let running = true;

  while (running) {
    const {data: {items: sessions, nextCursor}} = await api.exportSessions({
      pageSize: 100,
      cursor: cursor,
    });

    console.log(sessions);

    cursor = nextCursor;
    running = sessions.length > 0;
  }
}
```

**JavaScript**

```js
import {Configuration, ExportApi} from '@croct/export';

async function exportSessions() {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  let cursor = undefined;
  let running = true;

  while (running) {
    const {data: {items: sessions, nextCursor}} = await api.exportSessions({
      pageSize: 100,
      cursor: cursor,
    });

    console.log(sessions);

    cursor = nextCursor;
    running = sessions.length > 0;
  }
}
```

**Java**

```java
import com.croct.client.export.ApiClient;
import com.croct.client.export.ApiException;
import com.croct.client.export.api.ExportApi;
import com.croct.client.export.model.Session;
import com.croct.client.export.model.SessionResponse;
import java.util.List;

public class ExportSessions {
  public static void main(String[] args) throws ApiException {
    final ApiClient client = new ApiClient();
    client.setApiKey("<API KEY>");

    final ExportApi api = new ExportApi(client);

    String cursor = null;
    final int pageSize = 100;

    while (true) {
      final SessionResponse response = api.exportSessions(
        null,
        null,
        pageSize,
        cursor
      );

      final List<Session> sessions = response.getItems();

      System.out.println(sessions);

      if (sessions.isEmpty()) {
        break;
      }

      cursor = response.getNextCursor();
    }
  }
}
```

## Export users

Here is how to export user data from your workspace:

**Export users**

**TypeScript**

```ts
import {Configuration, ExportApi} from '@croct/export';

async function exportUsers(): Promise<void> {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  let cursor: string | undefined = undefined;
  let running = true;

  while (running) {
    const {data: {items: users, nextCursor}} = await api.exportUsers({
      pageSize: 100,
      cursor: cursor,
    });

    console.log(users);

    cursor = nextCursor;
    running = users.length > 0;
  }
}
```

**JavaScript**

```js
import {Configuration, ExportApi} from '@croct/export';

async function exportUsers() {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  let cursor = undefined;
  let running = true;

  while (running) {
    const {data: {items: users, nextCursor}} = await api.exportUsers({
      pageSize: 100,
      cursor: cursor,
    });

    console.log(users);

    cursor = nextCursor;
    running = users.length > 0;
  }
}
```

**Java**

```java
import com.croct.client.export.ApiClient;
import com.croct.client.export.ApiException;
import com.croct.client.export.api.ExportApi;
import com.croct.client.export.model.User;
import com.croct.client.export.model.UserResponse;
import java.util.List;

public class ExportUsers {
  public static void main(String[] args) throws ApiException {
    final ApiClient client = new ApiClient();
    client.setApiKey("<API KEY>");

    final ExportApi api = new ExportApi(client);

    String cursor = null;
    final int pageSize = 100;

    while (true) {
      final UserResponse response = api.exportUsers(
        null,
        null,
        pageSize,
        cursor
      );

      final List<User> users = response.getItems();

      System.out.println(users);

      if (users.isEmpty()) {
        break;
      }

      cursor = response.getNextCursor();
    }
  }
}
```

### Time window filtering

You can specify the `start` and `end` parameters to define the time range for the events and sessions you want to export. For example, to export events from the last 24 hours:

**Time-based filtering**

**TypeScript**

```ts
const today = new Date();
today.setHours(0, 0, 0, 0);

const yesterday = new Date(today.getTime());
yesterday.setDate(today.getDate() - 1);

const {data: {items: events}} = await api.exportEvents({
  pageSize: 100,
  start: yesterday.getTime(),
  end: today.getTime(),
});
```

**JavaScript**

```js
const today = new Date();
today.setHours(0, 0, 0, 0);

const yesterday = new Date(today.getTime());
yesterday.setDate(today.getDate() - 1);

const {data: {items: events}} = await api.exportEvents({
  pageSize: 100,
  start: yesterday.getTime(),
  end: today.getTime(),
});
```

**Java**

```java
import java.time.LocalDate;
import java.time.ZoneId;

final LocalDate today = LocalDate.now();
final LocalDate yesterday = today.minusDays(1);

final long start = yesterday
  .atStartOfDay(ZoneId.systemDefault())
  .toInstant()
  .toEpochMilli();

final long end = today
  .atStartOfDay(ZoneId.systemDefault())
  .toInstant()
  .toEpochMilli();

final EventResponse response = api.exportEvents(
  start,
  end,
  100,
  null,
  null
);
```

## Export an event by ID

Here is how to export a single event by its ID:

**Export an event by ID**

**TypeScript**

```ts
import {Configuration, ExportApi} from '@croct/export';

async function getEvent(): Promise<void> {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  const {data: {metadata, event}} = await api.exportEventById({
    eventId: '924f6c8f-3b5b-47ea-b483-25a0506dc436',
  });

  console.log(event);
}
```

**JavaScript**

```js
import {Configuration, ExportApi} from '@croct/export';

async function getEvent() {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  const {data: {metadata, event}} = await api.exportEventById({
    eventId: '924f6c8f-3b5b-47ea-b483-25a0506dc436',
  });

  console.log(event);
}
```

**Java**

```java
import com.croct.client.export.ApiClient;
import com.croct.client.export.ApiException;
import com.croct.client.export.api.ExportApi;
import com.croct.client.export.model.SingleEventResponse;
import java.util.UUID;

public class GetEvent {
  public static void main(String[] args) throws ApiException {
    final ApiClient client = new ApiClient();
    client.setApiKey("<API KEY>");

    final ExportApi api = new ExportApi(client);

    final SingleEventResponse response = api.exportEventById(
      UUID.fromString("924f6c8f-3b5b-47ea-b483-25a0506dc436")
    );

    System.out.println(response.getEvent());
  }
}
```

## Export a session by ID

Here is how to export a single session by its ID:

**Export a session by ID**

**TypeScript**

```ts
import {Configuration, ExportApi} from '@croct/export';

async function getSession(): Promise<void> {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  const {data: session} = await api.exportSessionById({
    sessionId: '916c8d26-053d-4ce8-86c6-3c98b4185921',
  });

  console.log(session);
}
```

**JavaScript**

```js
import {Configuration, ExportApi} from '@croct/export';

async function getSession() {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  const {data: session} = await api.exportSessionById({
    sessionId: '916c8d26-053d-4ce8-86c6-3c98b4185921',
  });

  console.log(session);
}
```

**Java**

```java
import com.croct.client.export.ApiClient;
import com.croct.client.export.ApiException;
import com.croct.client.export.api.ExportApi;
import com.croct.client.export.model.Session;
import java.util.UUID;

public class GetSession {
  public static void main(String[] args) throws ApiException {
    final ApiClient client = new ApiClient();
    client.setApiKey("<API KEY>");

    final ExportApi api = new ExportApi(client);

    final Session session = api.exportSessionById(
      UUID.fromString("916c8d26-053d-4ce8-86c6-3c98b4185921")
    );

    System.out.println(session);
  }
}
```

## Export a user by ID

Here is how to export a single user by its ID:

**Export a user by ID**

**TypeScript**

```ts
import {Configuration, ExportApi} from '@croct/export';

async function getUser(): Promise<void> {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  const {data: user} = await api.exportUserById({
    userId: '6d5f1fe8-3f21-4bce-9afb-e1d11b610674',
  });

  console.log(user);
}
```

**JavaScript**

```js
import {Configuration, ExportApi} from '@croct/export';

async function getUser() {
  const api = new ExportApi(
    new Configuration({
      apiKey: '<API KEY>'
    })
  );

  const {data: user} = await api.exportUserById({
    userId: '6d5f1fe8-3f21-4bce-9afb-e1d11b610674',
  });

  console.log(user);
}
```

**Java**

```java
import com.croct.client.export.ApiClient;
import com.croct.client.export.ApiException;
import com.croct.client.export.api.ExportApi;
import com.croct.client.export.model.User;
import java.util.UUID;

public class GetUser {
  public static void main(String[] args) throws ApiException {
    final ApiClient client = new ApiClient();
    client.setApiKey("<API KEY>");

    final ExportApi api = new ExportApi(client);

    final User user = api.exportUserById(
      UUID.fromString("6d5f1fe8-3f21-4bce-9afb-e1d11b610674")
    );

    System.out.println(user);
  }
}
```