---
title: SDK Method Reference
slug: devicepark/sdk-documentation/reference/sdk-methods
description: Find exact Java, Node.js and .NET SDK method signatures.
docTags: 
createdAt: 2026-08-10T08:03:44.631Z
---

This page lists the public method names and return types of each SDK. Java methods are synchronous. Node.js and .NET service methods are asynchronous; every .NET method also accepts an optional trailing `CancellationToken`.

Service accessors differ by language. Java and Node.js use methods (`client.devices()`); .NET uses properties (`client.Devices`).

## Client Creation

| Operation           | Java                                     | Node.js                                    | .NET                                      |
| ------------------- | ---------------------------------------- | ------------------------------------------ | ----------------------------------------- |
| Start builder       | `DeviceParkApiClient.builder()`          | `DeviceParkApiClient.builder()`            | `DeviceParkApiClient.Builder()`           |
| Set URL             | `.url(String)`                           | `.url(string)` or `.endpoint(string)`      | `.Url(string)`                            |
| Set credentials     | `.credentials(Credentials)`              | `.credentials(Credentials)`                | `.Credentials(Credentials)`               |
| Set raw credentials | `Credentials.of(clientId, clientSecret)` | `.credentialsFrom(clientId, clientSecret)` | `Credentials.Of(clientId, clientSecret)`  |
| Read environment    | —                                        | `Credentials.fromEnvironment()`            | `Credentials.FromEnvironment()`           |
| Set timeout         | `.timeout(Integer seconds)`              | `.timeout(number)` or `.timeoutMs(number)` | `.Timeout(int seconds)`                   |
| Add default header  | —                                        | `.addHeader(name, value)`                  | `.AddHeader(name, value)`                 |
| Override transport  | —                                        | `.fetchImplementation(fetch)`              | `.HttpMessageHandler(HttpMessageHandler)` |
| Build               | `.build()`                               | `.build()`                                 | `.Build()`                                |
| Release             | `client.close()`                         | `await client.close()`                     | `using` declaration (`IDisposable`)       |

## Devices

| Purpose             | Java signature                                                  | Node.js signature                                                                    | .NET signature                                                                              |
| ------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- |
| List                | `PageDto<Device> list(ListDevicesRequest request)`              | `list(request?: ListDevicesRequest): Promise<PageDto<Device>>`                       | `ListAsync(ListDevicesRequest? request = null): Task<PageDto<Device>>`                      |
| Get by serial       | `Device get(String serial)`                                     | `get(serial: string): Promise<Device>`                                               | `GetAsync(string serial): Task<Device>`                                                     |
| List default pool   | `PageDto<Device> listByDefaultPool(ListDevicesRequest request)` | `listByDefaultPool(request?: ListDevicesRequest): Promise<PageDto<Device>>`          | `ListByDefaultPoolAsync(ListDevicesRequest? request = null): Task<PageDto<Device>>`         |
| List installed apps | Not available                                                   | `apps(serial: string, request?: ListDeviceAppsRequest): Promise<PageDto<DeviceApp>>` | `AppsAsync(string serial, ListDeviceAppsRequest? request = null): Task<PageDto<DeviceApp>>` |

Access through `client.devices()` in Java and Node.js, `client.Devices` in .NET.

Java and Node.js `listByDefaultPool(...)` and .NET `ListByDefaultPoolAsync` resolve the default pool first and then apply a `POOL_ID` filter. Any `POOL_ID` filter already present in the request is replaced.

## Pools

| Purpose            | Java signature                                                    | Node.js signature                                                       | .NET signature                                                                                  |
| ------------------ | ----------------------------------------------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| List               | `PageDto<Pool> list(ListPoolsRequest request)`                    | `list(request?: ListPoolsRequest): Promise<PageDto<Pool>>`              | `ListAsync(ListPoolsRequest? request = null): Task<PageDto<Pool>>`                              |
| List default pools | Not available                                                     | `listByDefaultPool(request?: ListPoolsRequest): Promise<PageDto<Pool>>` | `ListByDefaultPoolAsync(ListPoolsRequest? request = null): Task<PageDto<Pool>>`                 |
| Get default pool   | `Pool getDefaultPool()`                                           | —                                                                       | `GetDefaultPoolAsync(): Task<Pool>`                                                             |
| Create             | `Pool create(CreatePoolRequest request)`                          | `create(request: CreatePoolRequest): Promise<Pool>`                     | `CreateAsync(CreatePoolRequest request): Task<Pool>`                                            |
| Delete             | `void delete(String poolId)`                                      | `delete(poolId: string): Promise<void>`                                 | `DeleteAsync(string poolId): Task`                                                              |
| Add devices        | `List<String> addDevices(String poolId, List<String> serials)`    | `addDevices(poolId: string, serials: string[]): Promise<string[]>`      | `AddDevicesAsync(string poolId, IReadOnlyList<string> serials): Task<IReadOnlyList<string>>`    |
| Remove devices     | `List<String> removeDevices(String poolId, List<String> serials)` | `removeDevices(poolId: string, serials: string[]): Promise<string[]>`   | `RemoveDevicesAsync(string poolId, IReadOnlyList<string> serials): Task<IReadOnlyList<string>>` |

Access through `client.pools()` in Java and Node.js, `client.Pools` in .NET.

Node.js and .NET `listByDefaultPool(...)` return a page and apply the `IS_DEFAULT = true` filter automatically. Java `getDefaultPool()` and .NET `GetDefaultPoolAsync()` return a single `Pool` and raise an error when no default pool exists.

## Allocations

| Purpose | Java signature                                              | Node.js signature                                                       | .NET signature                                                                  |
| ------- | ----------------------------------------------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| List    | `PageDto<Allocation> list(AllocationSearchRequest request)` | `list(request?: AllocationSearchRequest): Promise<PageDto<Allocation>>` | `ListAsync(AllocationSearchRequest? request = null): Task<PageDto<Allocation>>` |
| Create  | `Allocation create(DeviceAllocationRequest request)`        | `create(request: DeviceAllocationRequest): Promise<Allocation>`         | `CreateAsync(DeviceAllocationRequest request): Task<Allocation>`                |
| Release | `void delete(String allocationId)`                          | `delete(allocationId: string): Promise<void>`                           | `DeleteAsync(string allocationId): Task`                                        |

Access through `client.allocations()` in Java and Node.js, `client.Allocations` in .NET. `delete` releases the reservation; it does not delete a physical device.

## Sessions

| Purpose             | Java signature                                                                                 | Node.js signature                                                                                           | .NET signature                                                                                                     |
| ------------------- | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| List                | `PageDto<Session> list(DeviceSessionRequest request)`                                          | `list(request?: DeviceSessionRequest): Promise<PageDto<Session>>`                                           | `ListAsync(DeviceSessionRequest? request = null): Task<PageDto<Session>>`                                          |
| Start               | `Session start(DeviceStartSessionRequest request)`                                             | `start(request: DeviceStartSessionRequest): Promise<Session>`                                               | `StartAsync(DeviceStartSessionRequest request): Task<Session>`                                                     |
| Stop                | `void stop(String sessionId)`                                                                  | `stop(sessionId: string): Promise<void>`                                                                    | `StopAsync(string sessionId): Task`                                                                                |
| Screen stream URL   | `String streamUrl(String sessionId)`                                                           | `streamUrl(sessionId: string): Promise<string>`                                                             | Not available                                                                                                      |
| Download Appium log | `byte[] logs(String sessionId)`                                                                | `logs(sessionId: string): Promise<Buffer>`                                                                  | `LogsAsync(string sessionId): Task<byte[]>`                                                                        |
| List recordings     | `PageDto<ScreenRecord> screenRecords(String sessionId, ScreenRecordPaginationRequest request)` | `screenRecords(sessionId: string, request?: ScreenRecordPaginationRequest): Promise<PageDto<ScreenRecord>>` | `ScreenRecordsAsync(string sessionId, ScreenRecordPaginationRequest? request = null): Task<PageDto<ScreenRecord>>` |

Access through `client.sessions()` in Java and Node.js, `client.Sessions` in .NET.

Java and Node.js `streamUrl(sessionId)` return a `wss` URL with the current access token appended as the `token` query parameter. Do not log that URL. See [Get Screen Stream URL](docId\:sMdrq_2Jfb0NIyvLPCtpD).

## Applications

| Purpose                     | Java signature                                                                                        | Node.js signature                                                                                       | .NET signature                                                                                                    |
| --------------------------- | ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| List                        | `PageDto<Application> list(ApplicationPaginationRequest request)`                                     | `list(request?: ApplicationPaginationRequest): Promise<PageDto<Application>>`                           | `ListAsync(ApplicationPaginationRequest? request = null): Task<PageDto<Application>>`                             |
| Standard upload             | `Application upload(InputStream fileStream, String fileName, String version)`                         | `upload(fileStream, fileName: string, version: string): Promise<Application>`                           | `UploadAsync(Stream fileStream, string fileName, string version): Task<Application>`                              |
| Upload with image injection | `Application upload(InputStream fileStream, String fileName, String version, boolean imageInjection)` | `upload(fileStream, fileName: string, version: string, imageInjection?: boolean): Promise<Application>` | `UploadAsync(Stream fileStream, string fileName, string version, bool imageInjection = false): Task<Application>` |
| Delete                      | `void delete(String fileKey)`                                                                         | `delete(fileKey: string): Promise<void>`                                                                | `DeleteAsync(string fileKey): Task`                                                                               |

Access through `client.applications()` in Java and Node.js, `client.Applications` in .NET. Node.js accepts a Node.js `ReadableStream` or Web `ReadableStream`; .NET accepts any `System.IO.Stream`.

`imageInjection` defaults to `false`. When enabled, Device Park applies the configured gadget injection during upload processing.

## Request Builders

All three SDKs use the same builder fields. Only the construction syntax differs.

| Language | How a builder is created                                             |
| -------- | -------------------------------------------------------------------- |
| Java     | `ListDevicesRequest.builder()`                                       |
| Node.js  | `new ListDevicesRequestBuilder()`                                    |
| .NET     | `new ListDevicesRequest.Builder()` (nested type, PascalCase methods) |

| Builder                         | Key methods                                                                                                                                                                                         |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ListDevicesRequest`            | `page`, `size`, `sortBy`, `direction`, `addFilter`, `filters`, `build`                                                                                                                              |
| `ListDeviceAppsRequest`         | Node.js and .NET: `page`, `size`, `sortBy`, `direction`, `addFilter`, `filters`, `build`; Java: not available                                                                                       |
| `ListPoolsRequest`              | `page`, `size`, `sortBy`, `direction`, `addFilter`, `filters`, `build`                                                                                                                              |
| `CreatePoolRequest`             | Required `name`; `build`                                                                                                                                                                            |
| `AllocationSearchRequest`       | `page`, `size`, `sortBy`, `direction`, `addFilter`, `filters`, `build`                                                                                                                              |
| `DeviceAllocationRequest`       | `serial`, `manufacturer`, `model`, `platform`, `platformVersion`, `devicePoolId`, `priority`, `removeApps`, `build`                                                                                 |
| `DeviceSessionRequest`          | `page`, `size`, `sortBy`, `direction`, `addFilter`, `filters`, `build`                                                                                                                              |
| `DeviceStartSessionRequest`     | Required `allocationId`, `userId`, `userEmail`, `companyId`, `companyName`; optional `companyPoolId`, `videoRecording`, `videoRecordingScope`, `customVideoRecordingPath`, `appiumVersion`; `build` |
| `ScreenRecordPaginationRequest` | `page`, `size`, `sortBy`, `direction`, `addFilter`, `filters`, `build`                                                                                                                              |
| `ApplicationPaginationRequest`  | `page`, `size`, `sortBy`, `direction`, `addFilter`, `filters`, `build`                                                                                                                              |

`videoRecordingScope` accepts `FULL_SESSION` or `APPIUM_SESSION` and defaults to `FULL_SESSION`. The Java, Node.js and .NET SDKs send this field. The Java builder includes the default value in the request body; Node.js omits it when unset and the API applies `FULL_SESSION`.

Node.js and .NET validate the required `DeviceStartSessionRequest` fields during `build()`.

Node.js and .NET return a copy from `build()`, so a builder can be reused safely.

The three SDKs transmit filters for device, pool, application, allocation, session and screen-record lists. Node.js and .NET additionally support Device Apps filters. See [Pagination and Filtering](docId\:dGs4iHB5eEr5U28AOL8T_).
