--- url: /sdks-and-tools/jabraplusapis/api-access.md --- # API Access in Jabra Plus Management In Jabra Plus Management, you can grant API access to build integrations. API access can be granted to any person or service account with an email address. ## Prerequisites * To grant API access, you must be an admin user in Jabra Plus Management with the *Owner* role * To view or regenerate API keys, the user must have access to the Jabra API Portal ## Grant API access and API Portal access 1. Go to [Integrations > API Access](https://cloud.jabra.com/integrations/api-users). Sign in with an account that has the **Owner** role. 2. Select **Grant API access**. 3. Enter the required user details (*First name*, *Last name*, and *Email address*). 4. Select **Grant access**. The user receives an email from Jabra with a link to the Jabra API Portal, where they create a password and sign in. ## Get or regenerate primary and secondary API keys 1. Sign in to the Jabra API Portal. 2. Select **Profile** in the top ribbon. 3. On **User Profile**, scroll to **Subscriptions**. 4. In **Subscription details**: * Select **Show** to view a key * Select **Regenerate** to create a new key ::: warning Warning Regenerating a key invalidates the previous key. Update any integration that uses the old key. ::: --- --- url: /sdks-and-tools/jabraplusapis/api-endpoints.md --- # API Endpoints ::: info See API Portal for full API reference This page describes the most common usage of our API endpoints. The full set of API endpoints and versions is available in the [API Portal](https://api-portal.cloud.jabra.com). ::: ## Devices API The Devices API lets you retrieve device inventory, update device settings, and manage firmware versions. ::: warning Breaking changes in v2 The latest Devices collection endpoint uses `POST` with filter fields in a JSON request body. Previous versions used `GET` with query parameters. For new integrations, use API version 2 to align with the current endpoint behavior and filter model. Basic differences: * Method changed from `GET` to `POST` * Filter and paging inputs moved from query string parameters (for example `DeviceClientType`, `PageSize`, `ContinuationToken`) to JSON body fields (for example `deviceClientType`, `pageSize`, `continuationToken`) ::: **Important filter fields (request body)**: * **deviceClientType** (enum): Filter by client type, for example personal or meeting-room client usage * **continuationToken** (string): Token for requesting the next page *The complete parameter list is available in the [API Portal](https://api-portal.cloud.jabra.com).* **Example: Get Devices using filters** ::: code-group ```http POST https://api.cloud.jabra.com/devices/api/devices HTTP/1.1 Cache-Control: no-cache api-version: 2 Ocp-Apim-Subscription-Key: {your API subscription key} Content-Type: application/json { "deviceClientType": "MeetingRoom", "sortDescending": false, "pageSize": 100 } ``` ```sh [curl] curl -v -X POST "https://api.cloud.jabra.com/devices/api/devices" -H "Cache-Control: no-cache" -H "api-version: 2" -H "Ocp-Apim-Subscription-Key: {your API subscription key}" -H "Content-Type: application/json" -d '{"deviceClientType":\"MeetingRoom\","sortDescending":false,"pageSize":100}' ``` ::: ### Get devices including settings (v2) Version 2 includes an additional operation named **Get devices in pages, including their settings**. Use this operation when your integration needs both device inventory and device settings in the same workflow. This avoids an N+1 request pattern where you first fetch a page of devices and then call device settings for each device individually. **Why this endpoint is useful**: * Reduces the total number of API calls * Improves performance for inventory and configuration views * Simplifies synchronization jobs and backend processing **When to use it**: * You need device settings shown together with each device in your UI * You run periodic sync jobs and want fewer round trips * You want to lower the risk of hitting rate limits caused by many follow-up settings calls The request follows the same v2 model of `POST` plus filter/pagination parameters in the JSON body. See the [API Portal](https://api-portal.cloud.jabra.com) for the latest schema and response details. ## Meeting Rooms API The Meeting Rooms API can retrieve room details, list meeting rooms using filters, and reboot all Jabra meeting room devices in a room. **Example: Get meeting rooms using filters** ::: code-group ```http POST https://api.cloud.jabra.com/meetingrooms/api/meetingrooms HTTP/1.1 Cache-Control: no-cache api-version: 2 Ocp-Apim-Subscription-Key: {your API subscription key} Content-Type: application/json { "sortDescending": false, "pageSize": 100 } ``` ```sh [curl] curl -v -X POST "https://api.cloud.jabra.com/meetingrooms/api/meetingrooms" -H "Cache-Control: no-cache" -H "api-version: 2" -H "Ocp-Apim-Subscription-Key: {your API subscription key}" -H "Content-Type: application/json" -d '{"sortDescending":false,"pageSize":100}' ``` ::: **Example: Retrieve a room** ::: code-group ```http GET https://api.cloud.jabra.com/meetingrooms/api/meetingrooms/{groupId of one device in room} HTTP/1.1 Cache-Control: no-cache api-version: 2 Ocp-Apim-Subscription-Key: {your API subscription key} ``` ```sh [curl] curl -v -X GET "https://api.cloud.jabra.com/meetingrooms/api/meetingrooms/{groupId of one device in room}" -H "Cache-Control: no-cache" -H "api-version: 2" -H "Ocp-Apim-Subscription-Key: {your API subscription key}" ``` ::: **Example: Reboot all Jabra meeting room devices in a room** ::: code-group ```http POST https://api.cloud.jabra.com/meetingrooms/api/meetingrooms/{groupId of one device in room}/reboot HTTP/1.1 Cache-Control: no-cache api-version: 2 Ocp-Apim-Subscription-Key: {your API subscription key} ``` ```sh [curl] curl -v -X POST "https://api.cloud.jabra.com/meetingrooms/api/meetingrooms/{groupId of one device in room}/reboot" -H "Cache-Control: no-cache" -H "api-version: 2" -H "Ocp-Apim-Subscription-Key: {your API subscription key}" ``` ::: ## API versioning Jabra Plus APIs use explicit version headers to control behavior and maintain backward compatibility. Use the latest API versions from the [API Portal](https://api-portal.cloud.jabra.com) for new integrations. **Version header format:** ```http api-version: [version-number] ``` Older versions remain supported during a transition period. Breaking changes are introduced in new versions. ## Pagination and continuation tokens When requesting device lists, responses are paged. If more devices are available, a continuation token is returned. In the latest Devices API, pagination inputs are sent in the request body. **Example: Request next page with continuation token** ::: code-group ```http POST https://api.cloud.jabra.com/devices/api/devices HTTP/1.1 Cache-Control: no-cache api-version: 2 Ocp-Apim-Subscription-Key: {your API subscription key} Content-Type: application/json { "sortDescending": false, "continuationToken": "{your continuation token}", "pageSize": 100 } ``` ```sh [curl] curl -v -X POST "https://api.cloud.jabra.com/devices/api/devices" -H "Cache-Control: no-cache" -H "api-version: 2" -H "Ocp-Apim-Subscription-Key: {your API subscription key}" -H "Content-Type: application/json" -d '{"sortDescending":false,"continuationToken":\"{your continuation token}\","pageSize":100}' ``` ::: --- --- url: /sdks-and-tools/ai-tooling.md --- # Building with AI ✨ Great effort has been put into making sure that Jabra developer tools, SDKs, and APIs are as friendly as possible to work with for AI agents and humans alike. When building a Jabra integration with AI, we offer the following resources and recommendations to help you achieve the best possible results. ## Agent Skills for Jabra development For the best and most accurate AI agent development experience, it's recommended to use the `Jabra Integration` skill. It's based on [Agent Skills](https://agentskills.io/home) and contains instructions to help AI agents understand and use Jabra developer resources and best practices for solid integration design, development and verification. AI coding agents like Claude Code, GitHub Copilot, Codex, and others support Agent Skills. ### Adding the `Jabra Integration` skill to your project Consider adding the `Jabra Integration` skill as a project-level skill in your preferred AI coding agent. This makes it available to everyone — and every tool — working on the project. To add the `Jabra Integration` skill to your project: **Install with [npx skills](https://skills.sh/):** If you have Node.js + npm installed, you can add the `Jabra Integration` skill to your project with a single command: ```sh npx skills add gnaudio/jabra-ai-toolkit -y ``` **Install manually:** Download the `jabra-integration` skill folder from our [Jabra AI Toolkit GitHub repo](https://github.com/gnaudio/jabra-ai-toolkit) and place it in the appropriate folder for your AI coding agent: * For GitHub Copilot, place it in `.github/skills/jabra-integration` * For Claude Code, place it in `.claude/skills/jabra-integration` * For Codex, place it in `.codex/skills/jabra-integration` ## Agent friendly documentation All content on this site is served in Markdown format too. This is to ensure that all documentation is simpler and cheaper for AI agents to parse. Most AI agents should automatically find the markdown versions if you just tell them to use [developer.jabra.com](https://developer.jabra.com/) as reference. * [`llms.txt`](/llms.txt) A content overview of this site, designed to give AI agents a clear map of what's available and where to find it. * [`llms-full.txt`](/llms-full.txt) The full content of this entire site in a single text file. For a full markdown version of a specific page, simply add `.md` to the URL. For example, the markdown version of this page is available at: /sdks-and-tools/ai-tooling.md. --- --- url: /sdks-and-tools/javascript/button-customization.md --- # Button customization The Button customization module allows you to customize buttons and LEDs on supported Jabra headsets. You can take control of buttons, listen for button interactions, and control LED colors and modes. [Live sample implementation](./samples-and-reference.md#code-samples) The demo implementation includes details on common properties for Jabra Engage 40 and 50 II headset devices. ## Initialize Before you can use the Button customization module in your application, you must [initialize the core SDK](./) and install the button customization npm package: ```sh npm install @gnaudio/jabra-js-button-customization ``` To start working with button customization, create a device controller and get access to the button you want to customize: ```js import { ButtonInteraction, createDeviceController, ButtonId, Color, LedMode } from '@gnaudio/jabra-js-button-customization'; async function setupButtonCustomization(device) { const controller = await createDeviceController(device); if (!controller) { console.error("Failed to create device controller. The device may not support button customization."); return; } // Get the three-dot button const threeDotButton = await controller.getButton(ButtonId.threeDot); // Take control of the button (disables default functionality) threeDotButton.open(); return { controller, threeDotButton }; } ``` ## Setting LED color and mode Once you have control of a button, you can set its LED color and mode: ```js // Set LED to green with slow pulsing threeDotButton.setColor(Color.green, LedMode.slowPulse); // Set LED to solid red threeDotButton.setColor(Color.red, LedMode.on); // Turn LED off threeDotButton.setColor(Color.red, LedMode.off); ``` **Available predefined colors:** * `Color.red` * `Color.green` * `Color.blue` * `Color.yellow` * `Color.cyan` * `Color.magenta` * `Color.white` **Available LED modes:** * `LedMode.off` - LED is turned off * `LedMode.on` - LED is on with steady light * `LedMode.slowPulse` - LED is pulsing slowly * `LedMode.fastPulse` - LED is pulsing quickly ## Custom RGB colors You can also create custom colors using RGB values (0-255): ```js // Create custom orange color const orange = new Color(255, 165, 0); threeDotButton.setColor(orange, LedMode.on); ``` ## Listening for button interactions To respond to button presses, use the `listenFor` method: ```js // Listen for button taps const taps = await threeDotButton.listenFor(ButtonInteraction.tap); taps.subscribe({ next: () => { // Called when a button tap event is received }, error: (error) => { // Called if an error occurs when listening for button events }, complete: () => { // Called when listening for button events is stopped } }); ``` **Available button interactions:** * `ButtonInteraction.press` - Button held down longer than a tap * `ButtonInteraction.tap` - Quick button press * `ButtonInteraction.doubleTap` - Two quick taps in succession * `ButtonInteraction.down` - Button is pressed down * `ButtonInteraction.up` - Button is released ## Releasing button control If you're done with button customization, call `close()` to restore the button's default functionality: ```js // Release control and restore default functionality threeDotButton.close(); ``` ::: warning Important When a button is opened for control, any other functionality assigned to the button is disabled until control is released through `close()`. When closed, any custom LED configurations are reset and standard functionality is restored. ::: ## Supported devices Button customization is currently supported on: * Jabra Engage 40 * Jabra Engage 50 * Jabra Engage 50 II --- --- url: /use-cases/call-control.md --- # Call Control Jabra devices can answer, mute, and hang up a call by using the buttons on the device itself. This allows a user to take calls away from the desk or when the PC is locked. Jabra SDKs are designed to make this simple and easy to do while ensuring that call control integrations for multiple softphones co-exist with no conflicts. *Can be built with * --- --- url: /support.md --- # Developer support We're here to help! If you have a question or issue related to **building integrations with Jabra devices** or **require a *Jabra Partner Key*** for your integration, please reach out via the form below. If you need help on how to select, use, or connect a Jabra device, our [Jabra Product Support site](https://www.jabra.com/support) is the right place to get help. *** --- --- url: /use-cases/device-management.md --- # Device Management Jabra audio and video devices can be monitored, configured, updated, and managed via software in bulk, dramatically reducing the total cost of ownership of large and remote installations. Jabra SDKs, APIs and tools are designed to make this simple and easy to do. *Can be built with * --- --- url: /sdks-and-tools/dotnet/device-pairing.md --- # Device Pairing The `DevicePairing` module is used to pair/unpair and connect/disconnect wireless headsets (Bluetooth or DECT) with Jabra wireless dongles such as the Jabra Link 390 Bluetooth dongle or the Jabra Link 400 DECT dongle. ## Set up Device Pairing Module To use the `DevicePairing` module, you need to [initialize the core SDK module](./#getting-started) and install the [`Jabra.NET.Sdk.DevicePairing`](https://www.nuget.org/packages/Jabra.NET.Sdk.DevicePairing) nuget package: ```sh dotnet add package Jabra.NET.Sdk.DevicePairing ``` The `DevicePairing` module provides access to the following functionalities with Jabra wireless dongles: * Pairing a headset with the dongle * Remove headset pairing from dongle * Connecting/disconnecting headset to/from dongle Please refer to the [Bluetooth Pairing sample](./samples-and-reference.md#bluetooth-pairing-sample) to get a quick start on using the Device Pairing module. In addition, there is more information and descriptions of usage in the [API reference](./samples-and-reference.md#api-reference) for the Device Pairing module. --- --- url: /sdks-and-tools/dotnet/easy-call-control.md --- # Easy Call Control The recommended way for integrating call control with Jabra headsets into a softphone is to use our *Easy Call Control* module (multi-call option) which is part of the *core* SDK module. ::: warning Legacy CallControl and Easy Call Control (single-call option) If you have an existing softphone integration using the legacy CallControl or Easy Call Control (single-call option), you can keep using that and it is fully supported. However, for all **new** integrations, we strongly recommend basing only on *Easy Call Control* (multi-call option). ::: Easy Call Control offers a high-level abstraction for call control integrations and is intended to be quick and easy to integrate with no need to understand the complexities of signals to and from headsets. Once Easy Call Control is set up for a device, you can change the call state using high-level methods. Likewise, you can subscribe to events from Easy Call Control letting you know what state the device has requested. :::tip Call control sample code See [code samples](./samples-and-reference.md#code-samples) for a complete demo implementation of Easy Call Control. ::: ## Set up Easy Call Control To set up Easy Call Control for a device, you should first check that the device supports call control and then create an instance of Easy Call Control. ```C# // Create an Easy Call Control Factory from your // instance of the IApi you got when initializing SDK. EasyCallControlFactory easyCallControlFactory = new EasyCallControlFactory(jabraSdk); // If the device supports Easy Call Control, enable it. if (easyCallControlFactory.SupportsEasyCallControl(device)) { IMultiCallControl easyCallControl = await easyCallControlFactory.CreateMultiCallControl(device); } ``` ## Subscribe to events By listening to these events your application can keep track of the call state of the device and update your application's state accordingly. ```C# // OngoingCalls is the number of ongoing calls on the device. This includes active and held calls. easyCallControl.OngoingCalls.Subscribe((ongoingCalls) => { // (...) }); // MuteState is the microphone mute state of the device. easyCallControl.MuteState.Subscribe((isMuted) => { // (...) }); // HoldState indicates if call is on hold or not. easyCallControl.HoldState.Subscribe((isOnHold) => { // (...) }); // RingState indicates if the device is ringing or not (incoming call). easyCallControl.RingState.Subscribe((isRinging) => { // (...) }); // SwapRequest is called when the user wants to swap between two calls. easyCallControl.SwapRequest.Subscribe((_) => { // (...) }); ``` ## Change call state By using these methods you can update Easy Call Control with state changes from your application. ::: code-group ```C# [New incoming call] // New incoming call // Note there is an optional parameter for timeout in milliseconds. // After timeout the SDK considers the call Rejected. // The async call to SignalIncomingCall() will not resolve // until the call is either accepted or rejected. Console.WriteLine("SignalIncomingCall()"); bool callAcceptedResult = await easyCallControl.SignalIncomingCall(); if (callAcceptedResult) { Console.WriteLine("SignalIncomingCall() - Call accepted"); } else { Console.WriteLine("SignalIncomingCall() - Call rejected"); } ``` ```C# [Accept incoming call] // Accept incoming call. // Note there is an optional parameter in case of multiple calls to specify whether to // accept and hang up current call, or accept and put current call on hold. await easyCallControl.AcceptIncomingCall(); ``` ```C# [Reject incoming call] // Reject incoming call. await easyCallControl.RejectIncomingCall(); ``` ::: ::: code-group ```C# [New outgoing call] // New outgoing call await easyCallControl.StartCall(); ``` ```C# [End call] // End active call await easyCallControl.EndCall(); ``` ```C# [Hold call] // Put active call on hold await easyCallControl.Hold(); ``` ```C# [Resume call] // Resume call from held state await easyCallControl.Resume(); ``` ::: ::: code-group ```C# [Mute] // Mute headset microphone await easyCallControl.Mute(); ``` ```C# [Unmute] // Unmute headset microphone await easyCallControl.Unmute(); ``` ::: --- --- url: /sdks-and-tools/javascript/easy-call-control.md --- # Easy Call Control The recommended way for integrating call control with Jabra headsets into a softphone is to use our *Easy Call Control* (multi-call option) which is part of the JavaScript SDK. ::: warning Legacy CallControl and Easy Call Control (single-call option) If you have an existing softphone integration using the legacy CallControl or Easy Call Control (single-call option), you can keep using that and it is fully supported. However, for all **new** integrations, we strongly recommend basing only on *Easy Call Control* (multi-call option). ::: Easy Call Control offers a high-level abstraction for call control integrations and is intended to be quick and easy to integrate with no need to understand the complexities of signals to and from headsets. Once Easy Call Control is set up for a device, you can change the call state using high-level methods. Likewise, you can subscribe to events from Easy Call Control letting you know what state the device has requested. :::tip Call control live sample and code See [code samples](./samples-and-reference.md#code-samples) for a complete live demo implementation of Easy Call Control. ::: ## Setup Easy Call Control The @gnaudio/jabra-js npm package contains the core SDK including everything needed for call control integrations. See [Getting Started](./) for instructions on how to install the SDK and set up your project. To set up Easy Call Control for a device, you should first check that the device supports call control and then create an instance of Easy Call Control. ```js // Create an Easy Call Control Factory from your // instance of the IApi you got when initializing SDK. const easyCallControlFactory = new EasyCallControlFactory(jabraSdk); // If the device supports Easy Call Control, enable it. if (easyCallControlFactory.supportsEasyCallControl(device)) { /**@type {import('@gnaudio/jabra-js').IMultiCallControl} */ const easyCallControl = await easyCallControlFactory.createMultiCallControl(device); }; ``` ## Subscribe to events By listening to these events your application can keep track of the call state of the device and update your application's state accordingly. ```js // OngoingCalls is the number of ongoing calls on the device. This includes active and held calls. easyCallControl.ongoingCalls.subscribe((ongoingCalls) => { // (...) }); // MuteState is the microphone mute state of the device. easyCallControl.muteState.subscribe((muteState) => { // (...) }); // HoldState indicates if call is on hold or not. easyCallControl.holdState.subscribe((holdState) => { // (...) }); // SwapRequest is called when the user wants to swap between two calls. easyCallControl.swapRequest.subscribe(() => { // (...) }); ``` ## Change call state By using these methods you can update the Jabra device with state changes from your application. ::: code-group ```js [New incoming call] // New incoming call // The async call to signalIncomingCall() will not resolve // until the call is either accepted or rejected. console.log("signalIncomingCall()"); const callAcceptedResult = await easyCallControl.signalIncomingCall(); if (callAcceptedResult) { console.log("signalIncomingCall() - Call accepted"); } else { console.log("signalIncomingCall() - Call rejected"); }; ``` ```js [Accept incoming call] // Accept incoming call. // Note there is an optional parameter in case of multiple calls to specify whether to // accept and hang up current call, or accept and put current call on hold. await easyCallControl.acceptIncomingCall(); ``` ```js [Reject incoming call] // Reject incoming call. await easyCallControl.rejectIncomingCall(); ``` ::: ::: code-group ```js [New outgoing call] // New outgoing call await easyCallControl.startCall(); ``` ```js [End call] // End active call await easyCallControl.endCall(); ``` ```js [Hold call] // Put active call on hold await easyCallControl.hold(); ``` ```js [Resume call] // Resume call from held state await easyCallControl.resume(); ``` ::: ::: code-group ```js [Mute] // Mute headset microphone await easyCallControl.mute(); ``` ```js [Unmute] // Unmute headset microphone await easyCallControl.unmute(); ``` ::: --- --- url: /sdks-and-tools/end-user-runtimes.md --- # End user runtimes ## Browser with SDK2 ... ## Browser with SDK4 ... --- --- url: /sdks-and-tools/javascript/end-user-components.md --- # End-user components In certain scenarios the SDK requires installation of two Jabra software components on the end-user's laptop. These components are available here: :::info Scenarios requiring end-user components: * End-users run multiple softphones simultaneously and experience conflicts where calls to/from one softphone affects the state of the other. * Web app users experience that some device features do not work, such as device connections, properties, and button customization. ::: | File | Description | Download | | ------------------------------------------ | -------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Browser Extension for Device Connector** | Works across operating systems. Supports Microsoft Edge and Google Chrome. | [Chrome Web Store](https://chrome.google.com/webstore/detail/jabra-sdk-generation-3/kpmedpgagnidddimmioekjdhfllmdfia) | | **Device Connector Application** | Installed application required by the Browser Extension | [Windows](/downloads/EndUserRuntimes/SDK4/jabra-device-connector-2.3.3-windows.zip)[macOS](/downloads/EndUserRuntimes/SDK4/jabra-device-connector-2.1.1-macos.zip)[Linux](/downloads/EndUserRuntimes/SDK4/jabra-device-connector-2.0.4-linux.zip) | --- --- url: /sdks-and-tools/jabracli/installation.md --- # Installing JabraCLI **1. Download the tool.** Access is available by request: [Request access to download JabraCLI](/support.md) Latest version is 1.3.4 **2. Run the installer** for macOS (`*.pkg`) or Windows (`*.msi`) to install `JabraCLI` on your machine. The installer will guide you through the installation process. ## Supported Operating Systems The latest version is supported on the following operating systems: * **Windows 11** (x64, arm64) * **macOS 14 or newer** (x64, arm64) ## Updating When a new version of `JabraCLI` is released, you can download the latest installer from this site. Running a newer installer will update an existing installation. The JabraCLI tool itself will not automatically update or notify about new versions. ## Manual Installation If you prefer to manually install `JabraCLI` - i.e. without using the `.msi`/`.pkg` installer - or need to deploy it in an environment without installer support, you can copy the `JabraCLI` executable files along with the Firmware Updater (FWU) to the target machine. Note that the FWU has the following dependencies that must be present: * **Visual C++ 2022 Redistributable (x86)** * **Visual C++ 2010 Redistributable (x86)** If these are not installed, the tool will fail to launch. These redistributables can be found through Microsoft's official sites. ## Releases ### v1.3.4 - 2026-03-11 * Jabra Evolve3 device support * Improved logging and error messages for troubleshooting ### v1.2.77 - 2025-12-09 * Find and download firmware files from jabra.com via `jabracli firmware list` and `jabracli firmware download` * Watch changes to Jabra devices connected and their properties via `jabracli device watch` and `jabracli property watch` * Check if a configuration or firmware version can be applied on a device without applying changes — use `... --check-only` ### v1.1.59 - 2025-09-05 * Read/write Jabra device settings via `jabracli property` * List attached Jabra devices via `jabracli device` * Structured JSON output via `jabracli ... --output-format json` ### v1.0.20 - 2025-06-01 * Initial release * Update Jabra personal and meeting room device firmware --- --- url: /sdks-and-tools/dotnet.md --- # Jabra .NET SDK The SDK supports the following use cases: * Call control integration for softphones * Getting detailed device information * Changing camera, headset and speakerphone settings * Getting audio, video and wireless telemetry data ## Supported runtimes * .NET Framework 4.7.1 or later * .NET Core * .NET 5 or later ## Supported Operating Systems * Windows 10 and Windows 11 (x64, arm64) * macOS 14 and newer (x64, arm64) * Ubuntu Linux 22.04 (LTS) and newer ## SDK modules Jabra .NET SDK is available through [nuget.org](https://www.nuget.org/). The SDK consists of multiple modules. The *core* [`Jabra.NET.Sdk` module](https://www.nuget.org/packages/Jabra.NET.Sdk) is mandatory for all SDK integrations and contains everything you need for: * Device detection * Call control integration into softphones * Basic device information such as name of device, serial number, product ID ::: info Optional NuGet packages Install optional modules only if you need the specific functionality they provide: * [`Jabra.NET.Sdk.Properties`](https://www.nuget.org/packages/Jabra.NET.Sdk.Properties) - Enables you to get and set device settings and get telemetry information from devices. Learn more in the [Properties documentation](./properties.md). * [`Jabra.NET.Sdk.DevicePairing`](https://www.nuget.org/packages/Jabra.NET.Sdk.DevicePairing) - Enables you to pair/unpair and connect/disconnect wireless headsets (BT or DECT) with Jabra wireless dongles. Learn more in the [Device Pairing documentation](./device-pairing.md). * [`Jabra.NET.Sdk.ButtonCustomization`](https://www.nuget.org/packages/Jabra.NET.Sdk.ButtonCustomization) - Enables you to customize buttons and LEDs on supported headsets. Learn more by inspecting the [API reference](./samples-and-reference.md#api-reference) for the Button Customization module. ::: ::: warning .NET Framework - Copy files to output folder If your application is using .NET Framework, you need to configure your project to copy all the files from the `Jabra.Utilities/DeviceConnector/win32` to the output directory when you build your project. Mark all the files in the folder in Visual Studio and select either `Copy always` or `Copy if newer` in the Properties window. ![Copy files to Output Directory](../assets/dotnet-copy-output.png) Note: If your application is using .NET Core or .NET 5 (or later) you don't need to manually configure copying to Output Directory. ::: ## Getting Started The simplest way to get started is to try out our [code samples](./samples-and-reference.md#code-samples). ### Install the SDK To install the core SDK module, by running the following command in your project folder: ```sh dotnet add package Jabra.NET.Sdk ``` ### Initializing the SDK To use any of the functionality of the SDK, you first need to initialize it. The recommended way to do this is via the `Jabra.NET.Sdk.Core.Init.InitManualSdk` static function. Using this, you can set up subscriptions to error handling and device discovery before finalizing initialization: ```C# using Jabra.NET.Sdk.Core; internal class Program { public static async Task Main() { var config = new Config( partnerKey: "[Your Partner Key]", // We recommend initializing with a proper Partner Key. appId: "my-app-id", // may contain a combination of letters (A-Z, a-z), numbers (123), underscores (_), and hyphens (-) appName: "My app name" // end-user friendly name for your application ); // Begin init - not complete until jabraSdk.Start(); IManualApi jabraSdk = Init.InitManualSdk(config); // (...) setup error handling and device added/removed events (see below) await jabraSdk.Start(); } } ``` Get your Partner Key by [contacting us through the support form](/support/). ### Error handling To receive logging messages from the SDK in your application, the IApi interface exposes an observable LogEvents which you can subscribe to, as illustrated in the following: ```C# // Subscribe to SDK log events. jabraSdk.LogEvents.Subscribe((log) => { // Ignore info, warning, and debug log messages. if (log.Level == LogLevel.Error) Console.WriteLine(log.ToString()); }); ``` ### Device added/removed You can choose to subscribe to `DeviceAdded`/`DeviceRemoved` events or to subscribe to changes to the entire Jabra `DeviceList`. ```C# // Subscribe to Jabra devices being attached/detected by the SDK jabraSdk.DeviceAdded.Subscribe(static async (IDevice device) => { Console.WriteLine($"Device attached/detected: {device.Name} (Product ID: {device.ProductId}, Serial #: {device.SerialNumber})"); // (...) Your code working with the device here. Example: Set up Easy Call Control for the device, if you're building a softphone integration. }); // Subscribe to Jabra devices being detached jabraSdk.DeviceRemoved.Subscribe((IDevice device) => { Console.WriteLine($"Device detached: {device.Name} (Product ID: {device.ProductId}, Serial #: {device.SerialNumber})"); // (...) Your code handling that the device was removed. Example: If you were using the device for call control, you might want to setup another device for call control. }); // Subscribe to changes in the entire list of Jabra devices jabraSdk.DeviceList.Subscribe((List devices) => { Console.WriteLine("List of attached devices:"); foreach (IDevice device in devices) { Console.WriteLine($"{device.Name} (Product ID: {device.ProductId}, Serial #: {device.SerialNumber})"); // (...) Your code depending on whether this was the device you were looking for. Example: If device matches the audio device selected in a softphone, set up Easy Call Control for device. } }); ``` ### Device connections When an end-user connects a headset to their computer, some cases can lead to multiple connections. **Example:** *For a BT headset you can simultaneously connect the headset using a wireless dongle connection for calls, in addition to a wired USB cable connection. A new wired connection does not report the headset as an additional device, but merely as an additional connection for the same device.* For a device, you can subscribe to `ConnectionAdded`/`ConnectionRemoved` events or subscribe to changes to the entire `ConnectionList`. You can also get a list of `CurrentConnections`. ```C# // Connection added event device.ConnectionAdded.Subscribe(async (IConnection connection) => { Console.WriteLine($"Connection type {connection.Type} added for: {device.Name}"); }); // Connection removed event device.ConnectionRemoved.Subscribe(async (IConnection connection) => { Console.WriteLine($"Connection type {connection.Type} removed for: {device.Name}"); }); // Connection list changed event device.ConnectionList.Subscribe(async (IEnumerable connections) => { Console.WriteLine($"Connections for device: {device.Name}"); foreach (var connection in connections) { Console.WriteLine($"Connection type: {connection.Type}"); } }); ``` --- --- url: /sdks-and-tools/amazonconnect.md --- # Jabra Call Control for Amazon Connect SDK See [Jabra Call Control for Amazon Connect on jabra.com](https://www.jabra.com/software-and-services/apps/jabra-call-control-integration-for-amazon-connect) for an introduction to what can be setup with this SDK. ## Requirements * A web application with Amazon Connect CCP (Contact Control Panel) integrated via the Amazon Connect Streams API. Access to update the code. * End-user on Chromium based browser like Google Chrome or Microsoft Edge running on Windows or macOS. * [Jabra end-user components](/sdks-and-tools/legacy#end-user-components-for-legacy-sdks) installed on end-users' computer. * A USB connected Jabra headset. :::tip Agent state change feature Some Jabra headsets support the feature of controlling agent state (toggling between "available", "break" etc.) via a *customizable headset button*. Headsets with customizable button include Jabra Engage 40/50/50II. ::: ## Getting started 1. Add a script reference to the file `jabra.connect.integration.v1.1.2.js` to the web application with Amazon Connect integrated (similar to how you've added the *Amazon Connect Streams JavaScript file*). 2. Include the script in your code along with the *Amazon Connect Streams JavaScript file*. E.g. in index.html: ```html ``` ## Download the SDK Please [submit a developer support ticket](/support/) to request access to the *Jabra Call Control for Amazon Connect SDK*. --- --- url: /sdks-and-tools/android-ios.md --- # Jabra devices integration for Android & iOS apps ## Call controls :::info For all Jabra device families The following applies to all Jabra devices with call control support. ::: To build call controls integrations on Android or iOS, you should use the native APIs for doing so. Please see following resources for details: * [Android Telecom Framework](https://developer.android.com/develop/connectivity/telecom) * [iOS CallKit](https://developer.apple.com/documentation/callkit/) ## Jabra Perform and BlueParrott SDK :::warning For Jabra Perform and BlueParrott devices only The Jabra Perform and BlueParrott SDKs support the Perform and BlueParrott product families only. We currently do not offer SDKs for Android or iOS integration with other Jabra device families. If you are looking for it, [please contact us](/support/) and let us know why. ::: The Jabra Perform and BlueParrott SDKs for Android & iOS enable you to create apps that interact with the configurable button and reads basic telemetry on Jabra Perform and BlueParrott headsets. The SDKs incl. detailed documentation can be found in the following GitHub repos: * [Jabra Perform and BlueParrott SDK for Android](https://github.com/gna-sw/Jabra-Perform-BlueParrott-Android-SDK) * [Jabra Perform and BlueParrott SDK for iOS](https://github.com/gna-sw/Jabra-Perform-BlueParrott-iOS-SDK) --- --- url: /sdks-and-tools/linux.md --- # Jabra devices integration for Linux apps :::info No C++ SDK available for download We only offer a Linux SDK for C++ development by request. ::: If you plan to build a Jabra device integration for Linux and are not covered by the [Jabra JavaScript SDK](/sdks-and-tools/javascript/) or the [Jabra .NET SDK](/sdks-and-tools/dotnet/), please [reach out and tell us more](/support/). --- --- url: /sdks-and-tools/macos.md --- # Jabra devices integration for macOS apps :::info No Swift and Objective-C available for download We only offer an SDK for Swift/Objective-C development by request. ::: If you plan to build a Jabra device integration for macOS and are not covered by the [Jabra JavaScript SDK](/sdks-and-tools/javascript/) or the [Jabra .NET SDK](/sdks-and-tools/dotnet/), please [reach out and tell us more](/support/). --- --- url: /sdks-and-tools/javascript.md --- # Jabra JavaScript SDK The SDK supports the following use cases: * Call control integration for softphones * Getting device information * Reading and changing settings and other properties (properties module) * Subscribing to telemetry events such as audio telemetry (properties module) * Customizing buttons and LEDs on supported headsets (button customization module) ## Supported runtimes * Desktop versions of Google Chrome, Microsoft Edge and other [Chromium](https://www.chromium.org/) based browsers. * [Node.js](https://nodejs.org/) on Windows, macOS and common Linux distributions. ## Installing JavaScript SDK Please install the [@gnaudio/jabra-js](https://www.npmjs.com/package/@gnaudio/jabra-js) package via NPM (get NPM by installing [Node.js](https://nodejs.org/)). You can do this by running the following command in your project directory: ```sh npm install @gnaudio/jabra-js ``` ## Getting Started The easiest way to get started is to try the live code samples ### Initializing the SDK Before using the SDK you need to initialize it. For browser-based apps, you should always use the "Chrome extension with WebHID fallback transport". For Node.js you can ignore the transport option. ::: code-group ```js [Browser] import {createApi, RequestedBrowserTransport} from '@gnaudio/jabra-js'; // For browser apps, you should always use CHROME_EXTENSION_WITH_WEB_HID_FALLBACK for transport. /** @type {import('@gnaudio/jabra-js').IConfig} */ const sdkConfig = { partnerKey: 'your-partner-key', // For production use, please request and use a Partner Key. transport: RequestedBrowserTransport.CHROME_EXTENSION_WITH_WEB_HID_FALLBACK, appId: 'my-app-id', // may contain a combination of letters (A-Z, a-z), numbers (123), underscores (_), and hyphens (-) appName: 'My app name', // end-user friendly name for your application logger: { write(logEvent) { console.log("Jabra SDK log event: " + logEvent.message, logEvent.layer); } } }; const jabraSdk = await createApi(sdkConfig); // (...) setup device added/removed event subscriptions (see below) // Finalize initialization using start() to start subscribing to device added events. await jabraSdk.start(); ``` ```js [Node.js] import {createApi} from '@gnaudio/jabra-js'; // For Node.js apps, you don't need to specify transport. /** @type {import('@gnaudio/jabra-js').IConfig} */ const sdkConfig = { partnerKey: 'your-partner-key', // For production use, please request and use a Partner Key. appId: 'my-app-id', // may contain a combination of letters (A-Z, a-z), numbers (123), underscores (_), and hyphens (-) appName: 'My app name', // end-user friendly name for your application logger: { write(logEvent) { console.log("Jabra SDK log event: " + logEvent.message, logEvent.layer); } } }; const jabraSdk = await createApi(sdkConfig); // (...) setup device added/removed event subscriptions (see below) // Finalize initialization using start() to start subscribing to device added events. await jabraSdk.start(); ``` ::: Get your Partner Key by [contacting us through the support form](/support/). :::warning Use `createApi()` instead of `init()` In SDK version 4.4.1 and later, we recommend using `createApi()` and `.start()` instead of `init()` to initialize the SDK. This is to ensure your app gets fully setup and subscribes to device events before the SDK starts emitting them. ::: ### Device added/removed You can choose to subscribe to `deviceAdded`/`deviceRemoved` events or to subscribe to changes to the entire Jabra `deviceList`. ```js // Subscribe to Jabra devices being attached/detected by the SDK jabraSdk.deviceAdded.subscribe(async (/**@type {import('@gnaudio/jabra-js').IDevice} */ device) => { console.log(`Device attached/detected: ${device.name} (Product ID: ${device.productId}, Serial #: ${device.serialNumber})`); // (...) Your code working with the device here. // Example: Set up Easy Call Control for the device, if you're building a softphone integration. }); // Subscribe to Jabra devices being detached jabraSdk.deviceRemoved.subscribe(async (/**@type {import('@gnaudio/jabra-js').IDevice} */ device) => { console.log(`Device detached/removed: ${device.name} (Product ID: ${device.productId}, Serial #: ${device.serialNumber})`); // (...) Your code handling that the device was removed. // Example: If you were using the device for call control, you might want to set up another device for call control. }); // Subscribe to changes in the entire list of Jabra devices jabraSdk.deviceList.subscribe((/**@type {import('@gnaudio/jabra-js').IDevice[]} */ devices) => { console.log('Device list changed. New device list:'); devices.forEach(async (/**@type {import('@gnaudio/jabra-js').IDevice} */ device) => { console.log(`--Device: ${device.name} (Product ID: ${device.productId}, Serial #: ${device.serialNumber})`); // (...) Your code depending on whether this was the device you were looking for. // Example: If device matches the audio device selected in a softphone, set up Easy Call Control for device. }); }); ``` :::warning Important note on WebHID transport If your application is running in the browser, the [transport mode](./transport-mode.md) used by most of your customers will be "WebHID". In this case you will need to ensure you trigger the WebHID consent dialog. Example: To trigger the WebHID consent dialog add for example a button to your HTML: ```html ``` Then add an event listener from where you trigger the WebHID consent dialog: ```js const webHidButton = document.getElementById('webHidButton'); webHidButton.addEventListener('click', async () => { console.log('Adding Jabra device using WebHID'); await webHidPairing(); // If user added a device, the deviceAdded and deviceList subscriptions // will trigger and you should handle the device interaction there. }); ``` By browser security requirements, the WebHID consent dialog **must** be triggered from a user gesture such as a button click. Alternatively a browser policy can be set by IT administrators. Read more at [Transport mode for web apps](./transport-mode.md). ::: ### Device connections :::info This only applies to Node.js apps and to web apps where the transport mode is to use Chrome Extension - please see [Transport mode for web apps](./transport-mode.md) for more. ::: When an end-user connects a headset to their computer, this may lead to multiple connections. **Example:** *For a Bluetooth headset you can simultaneously connect the headset using a wireless dongle connection for calls, in addition to a wired USB cable connection. A new wired connection does not report the headset as an additional device, but merely as an additional connection for the same device.* For a device, you can subscribe to `ConnectionAdded`/`ConnectionRemoved` events or subscribe to changes to the entire `ConnectionList`. You can also get a list of `CurrentConnections`. ```js // Connection added event device.connectionAdded.subscribe(async (/**@type {import('@gnaudio/jabra-js').IConnection} */ connection) => { console.log(`Device connection added: ${connection.id}`); }); // Connection removed event device.connectionRemoved.subscribe(async (/**@type {import('@gnaudio/jabra-js').IConnection} */ connection) => { console.log(`Device connection removed: ${connection.id}`); }); // Connection list changed event device.connectionList.subscribe(async (/**@type {import('@gnaudio/jabra-js').IConnection[]} */ connections) => { console.log(`Device connection list for ${device.name}:`); connections.forEach(/**@type {import('@gnaudio/jabra-js').IConnection} */ connection => { console.log(`Connection: ${connection.id}`); }); }); ``` From here you should be setup to integrate with basic information about connected Jabra devices. Or expand to use some of the other SDK functionality found in the left menu. --- --- url: /legal/license-agreement.md --- # Jabra License Agreement This license agreement applies to Jabra SDKs, Jabra Integration Software and the website content of [developer.jabra.com](/). The license agreement will be updated if required. | Publication Date | Description | |---|---| | 2022-10-04 | First publication| ## 1. General THIS IS A LICENSE AGREEMENT BETWEEN YOU AND GN AUDIO A/S (“*GN AUDIO*”) GOVERNING YOUR USE OF THE SOFTWARE LICENSED HEREIN. TO USE THE SOFTWARE, YOU MUST FIRST AGREE TO THIS SOFTWARE LICENSE AGREEMENT (THIS “LICENSE AGREEMENT”). YOU MAY NOT USE THE SOFTWARE IF YOU DO NOT ACCEPT THIS LICENSE AGREEMENT. BY ACCESSING OR USING THE SOFTWARE, YOU HEREBY AGREE TO THE TERMS OF THIS LICENSE AGREEMENT. IF YOU ARE AGREEING TO BE BOUND BY THIS LICENSE AGREEMENT ON BEHALF OF YOUR EMPLOYER OR OTHER ENTITY, INCL BUT NOT LIMITED TO AFFILIATES OF YOUR EMPLOYER, YOU REPRESENT AND WARRANT THAT YOU HAVE FULL LEGAL AUTHORITY TO BIND YOUR EMPLOYER OR SUCH ENTITY TO THIS LICENSE AGREEMENT. IF YOU DO NOT AGREE TO THE TERMS OF THE AGREEMENT, DO NOT USE THE SOFTWARE. IF YOU ARE ACCESSING THE SOFTWARE THROUGH A GN AUDIO WEBSITE, SECTION 6 (WEBSITE) APPLIES IN ADDITION TO THE OTHER TERMS & CONDITIONS. ## 2. Definitions a. “*API*” means application programming interface such the GN Audio integration software.\ b. “*GN Audio*” means GN Audio A/S, located at Lautrupbjerg 7, 2750 Ballerup, Denmark.\ c. “*Developer*” and “You” refers to any person or entity acquiring or using the Software under the terms of this License Agreement.\ d. “*Developer Application*” means any software that is developed by You or on your behalf to function with a GN Audio Product.\ e. “*Documentation*” means any explanatory text, instructions and references accompanying the Software.\ f. "*Product*" or "*GN Audio Product*" means GN Audio hardware or software products or services.\ g. “*Sample Code*” means software code that GN Audio has included in the Software and/or designated in the Documentation as “*Sample Code*”.\ h. “*Software*” means components and libraries distributed with the SDK, plug-ins, toolkits, Sample Code, APIs, related items, Documentation in online format, and any upgrades, modified versions, updates and additions.\ i. “*SDK*” means Software Development Kit.\ j. “*Tools*” mean the programs and utilities that may be included in the Software for You to use for building the Developer Applications.\ k. “*Use*”, “*Used*” or “*Using*” means to access, install and/or download the Software. ## 3. License a. Subject to the terms and conditions of this License Agreement including the restrictions contained in this Section 3, GN Audio hereby grants to You a nonexclusive, nontransferable, revocable license to * (i) use the Software and the items included strictly for the purpose of developing the Developer Application and * (ii) link or incorporate all or portions of the Software, with the Developer Application and distribute them only for use in connection with a GN Audio Product. Except for the foregoing, You are not granted any right or license to modify, improve or create derivative works of the Software, or any of the items in the Software. This License Agreement does not govern or grant You any license or right to use any GN Audio Product. Any use of a GN Audio Product is governed by GN Audio’s terms and conditions that accompany such GN Audio Product. Authorization to distribute your Developer Application with GN Audio Products may be subject to your payment of fees to GN Audio. b. You warrant that you shall only use the Software in accordance with the License Agreement and any applicable law, regulation or generally accepted practices in your jurisdictions. c. You warrant that you shall be solely responsible for any breach of your obligations under the Terms. d. You warrant that you shall only access the Software through the interface provided by GN Audio. Furthermore, you warrant at all times to comply with the instructions provided by GN Audio. Without limiting GN Audio’s rights to revoke your access to the Software or terminate this License Agreement at any time without cause, GN Audio may revoke your access to the Software or terminate this License Agreement immediately if you fail to comply with any such rules or best practices or any other terms or conditions herein. e. Except as expressly set forth in this Agreement, You may not, directly or indirectly, sell, sublicense, rent, loan, share, disclose, transfer or lease the Software, or any portion of the Software, to any third party. You may not assign Your rights or obligations granted under this License Agreement without prior written consent of GN Audio which may be withheld at its sole discretion. Any attempted assignment or transfer without such prior written consent from GN Audio shall be void and of no effect. f. You may not, directly or indirectly, reverse engineer, decompile, disassemble or otherwise attempt to discover the source code and/or file formats of any portion of the Software. To the extent that local law grants You the right to decompile software to obtain information necessary to render the software interoperable with other software, You shall first request to GN Audio in writing to provide You with the necessary information. GN Audio has the right to impose reasonable conditions on decompiling its software such as a reasonable fee for doing so. g. You represent, warrant and covenant that you will not use the Software in connection with any hardware or software that does not conform to the description set forth in the Software Documentation. h. GN Audio reserves the right at any time to modify or discontinue temporarily or permanently the Software, your use of the Software, or any portion thereof with or without notice to you and without any form of compensation or consideration to you, regardless of the status of any of your Developer Applications. In addition, GN Audio reserves the right to create, modify and enforce controlling mechanisms such as a rate limiting structure for use of the Software. Further, you acknowledge that GN Audio has no obligation to ensure that an upgrade of Software or any GN Audio Product will be compatible with existing or planned Developer Applications. i. You will not use the Software for any purpose other than developing and providing Developer Applications. You will not include or use the Software or any Developer Application in, or in connection with, any application, website or other product or service that includes content that is disparaging of GN Audio or may otherwise be perceived as detrimental or harmful to GN Audio and its business and reputation, as determined by GN Audio in its sole discretion. You will not use web scraping, web harvesting, or web data extraction methods to extract data from any GN Audio Product. You will not use the Software or any Developer Application to distribute any virus, spyware, adware, malware, or other harmful or malicious component. You will not use the Software or any Developer Application for any purpose which or might overburden, impair or disrupt the GN Audio network or related servers. You will not use the Software or any Developer Application to distribute unsolicited advertising or promotions, or to send messages, make comments, or initiate any other unsolicited direct communication or contact with GN Audio users or partners. j. You may not encourage or authorize others to: * (i) remove or alter any proprietary notices or marks from any items included in the Software; * (ii) use or access the Software for purposes of monitoring the availability, performance, or functionality of any GN Audio Product or for any other benchmarking or competitive purposes; or * (iii) frame, wrap or otherwise reproduce significant portions of any GN Audio Product or the Software. k. Along with the distribution of the Developer Application you must ensure that GN Audio’s and any third parties’ rights as contained in this License Agreement are upheld and you may not impose any terms on users of any Developer Application that are inconsistent with this License Agreement. You will require each user of a Developer Application to agree to terms of service that * (i) disclaim all warranties on behalf of GN Audio and any third-party service providers, including a disclaimer of implied warranties of merchantability, fitness for a particular purpose and non-infringement and * (ii) exclude GN Audio and any third party service providers from all liability for direct, indirect, consequential, special and punitive damages, to the fullest extent permitted under applicable law. ## 4. Intellectual Property Rights a. The Software, and all items contained in the Software, are the intellectual property of GN Audio and its suppliers and are protected by copyright, patent and intellectual property law, international treaty provisions and applicable laws of the country in which it is being Used. You agree to protect all copyright, intellectual property and other ownership interests of GN Audio and/or its suppliers in the Software, and all items in the Software, supplied under this License Agreement. b. You agree that all copies of the Software, and all items in the Software, reproduced for any reason by You, shall contain the same copyright notices, and other proprietary notices as appropriate, as appear on or in the master items delivered by GN Audio in the Software. You agree not to remove, obscure, or deface any intellectual property or confidentiality legends of GN Audio and/or delete any program files. GN Audio and/or its suppliers retain exclusive title and ownership of the Software, and all items in the Software, the media on which it is recorded, and all subsequent copies, regardless of the form or media in or which the original and other copies may exist. Except as stated above, this License Agreement does not grant You any rights to patents, copyrights, trade secrets, trademarks or any other intellectual property or proprietary rights in respect of the Software, and the items in the Software. ## 5. Personal data a. GN Audio collects personal data about You when you sign up for or install the Software. Any processing of your personal data or employees with the Developer in relation to the use of the Software is described in the [Jabra Privacy Policy](/legal/privacy-policy). b. You are solely responsible for obtaining all consents (provided another legal basis or ground does not apply), maintaining the security and integrity of any collected data, providing all required notices and disclosures to the standard imposed by applicable laws, including, but not limited to, the General Data Protection Regulation 2016/679 (the “*GDPR*”), and fulfilling all other legal obligations in relation to Your collection of personal data in relation to the extent related to use of the Software in connection with any Developer Application. Further It is Your sole responsibility to ensure that information is given to Your customers and/or customers’ users of the Developer Application explaining that certain SDK usage information will be collected by GN Audio when using the Developer Application. The information will only be collected to the extent you have chosen to activate the collection of data-feature and the Developer Application is used online. The information is collected for statistical purposes and to improve the Software and GN Audio Products. Our processing of Your customers’ users’ data is also described in the Jabra Privacy Policy. ## 6. Website a. To the extent You use any of the GN Audio websites, including but not limited to the *Jabra Developer Zone*, to access and use the Software this section 6 applies in addition to the other terms and conditions. b. You may download material displayed on the website to the extent You use it in accordance with the terms and conditions applicable for the Software under this License Agreement. c. The websites may include information related to GN Audio Products, the Software, incl tools, API Information and Documentation in online format. GN AUDIO DOES NOT WARRANT THE COMPLETENESS, CORRECTNESS, TIMELINESS, USEFULNESS OR ACCURACY OF ANY OF THE INFORMATION PROVIDED ON THIS SITE. It is your responsibility to verify all information before relying on it. d. The websites may contain links to other websites operated by third parties other than GN Audio. Such links are provided for your convenience only. GN Audio disclaims any control over, relationship with, or endorsement of any third-party sites that this site may contain links to. You are advised to use discretion and judgment in browsing the websites and any sites related hereto. The Internet contains material which may be inappropriate or sexually explicit, may be offensive to you, or may contain inaccurate information which may violate copyright, libel or defamation laws. e. If you purchase merchandise or services from third parties or websites, GN Audio is not a party to that transaction and has no liability or responsibility with respect to that transaction. NOTHING CONTAINED IN THE WEBSITES SHOULD BE CONSTRUED AS CONSTITUTING ANY PRODUCT WARRANTY OR AS EXPANDING OR OTHERWISE MODIFYING ANY PRODUCT WARRANTY. f. GN AUDIO cannot warrant or guarantee that any downloaded files from this site or from any site linked to it are free from error, viruses, or other destructive properties. You agree to assume all risk in downloading files or in retrieving any information from the websites or any sites related or linked to it. You acknowledge that you have been advised that you should take all necessary steps to protect your computer and files from erasing, destruction, corruption or other malfunction. g. To the extent You need to set up username and password to access the Software, You shall at all times keep your username and password strictly confidential. Any activity in your account shall be your sole responsibility. If you discover any unauthorized use of your password or your account, you shall notify GN Audio hereof immediately by sending an email to *developersupport@jabra.com*. ## 7. Term a. The Terms shall apply until they are terminated by you or GN Audio in accordance with the terms set out below.\ b. You may terminate this Agreement at any time by notifying GN Audio hereof in writing. Your notice should be sent, in writing, to *developersupport@jabra.com*.\ c. GN Audio may terminate this Agreement at any time with immediate effect if: * (i) You have breached the License Agreement; * (ii) GN Audio is required to do so by law; * (iii) The partner with whom GN Audio offered the Software to you has terminated its relationship with GN Audio or ceased to offer their services to GN Audio; or * (iv) For convenience, with at least 90 days’ prior written notice. d. Upon any termination * (i) all licenses granted to You with respect to the Software will immediately terminate, * (ii) You will immediately discontinue all distribution, support and use of any Developer Applications and * (iii) You must remove all full and partial copies of the items in the Software from your computers, systems and servers and discontinue use of the items in the Software. e. Nothing in this Section shall affect GN Audio's other rights according to the License Agreement. ## 8. Warranty and Indemnification a. GN Audio licenses the Software to Developer only on an “*as-is*” basis. GN Audio makes no warranties or representation, express or implied, with respect to the adequacy of the Software, and any items in the Software, whether or not used by You, for any particular purpose or with respect to their adequacy to produce any particular result. GN Audio and its suppliers shall not be liable for loss or damage arising out of this License Agreement or from use by You of any devices or products containing portions of the Software. GN AUDIO A/S, ITS AFFILIATES AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO IMPLIED CONDITIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. GN AUDIO, ITS AFFILIATES AND SUPPLIERS MAKE NO WARRANTY THAT THE PROVISION OR USE OF THE OF THE SOFTWARE WILL BE UNINTERRUPTED, SECURE OR FREE FROM ERROR, ANY INFORMATION OBTAINED AS A RESULT OF USE OF THE SOFTWARE WILL BE ACCURATE OR RELIABLE, OR THAT DEFECTS IN THE OPERATION OR FUNCTIONALITY OF ANY SOFTWARE PROVIDED AS PART OF THE SOFTWARE WILL BE CORRECTED. YOU ACCEPT THAT ANY USE OF THE SOFTWARE IS AT YOUR OWN RISK AND YOU ALONE ARE SOLELY RESPONSIBLE FOR ANY DAMAGE TO YOUR EQUIPMENT, INCLUDING LOSS OF DATA, AS A RESULT OF YOUR USE OF THE SOFTWARE. b. NO PERSON IS AUTHORIZED TO MAKE ANY OTHER WARRANTY OR REPRESENTATION CONCERNING THE PERFORMANCE OF THE SOFTWARE. YOU ASSUME THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE AND ANY DESIGN OR PRODUCT IN WHICH THE SOFTWARE MAY BE USED, INCLUDING, WITHOUT LIMITATION, ANY DEVELOPER PRODUCTS. EXCEPT TO THE EXTENT PROHIBITED BY LAW AND AS PROVIDED IN 11.1, THIS WARRANTY IS EXCLUSIVE AND IN LIEU OF ALL OTHER EXPRESS AND IMPLIED WARRANTIES WHATSOEVER. c. To the maximum extent permitted by law, You agree to defend, indemnify and hold harmless GN Audio, its affiliates and their respective directors, officers, employees and agents from and against any and all claims, actions, suits or proceedings, as well as any and all losses, liabilities, damages, costs and expenses (including reasonable attorneys’ fees) arising out of or accruing from * (a) Your use of the Software, * (b) any application or other product or service You develop using the Software that infringes any copyright, trademark, trade secret, trade dress, patent or other intellectual property right of any person or defames any person or violates their rights of publicity or privacy, and * (c) any non- compliance by you with this License Agreement. This indemnity obligation shall survive termination of this License Agreement, including your cessation with regard to your use of the Software. GN AUDIO reserves the right to assume the defense and control of any matter subject to indemnification by you, in which event you shall cooperate fully with GN AUDIO in asserting any available defenses. ## 9. Liability a. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT WILL GN AUDIO AND/OR GN AUDIO’S AFFILIATES, SUBSIDIARIES AND AGENTS BE LIABLE FOR ANY DIRECT, INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGE IN CONNECTION WITH OR ARISING OUT OF THIS LICENSE AGREEMENT (INCLUDING WITHOUT LIMITATION LOSS OF BUSINESS, REVENUE, PROFITS, USE, DATA OR OTHER ECONOMIC ADVANTAGE), HOWEVER IT ARISES, WHETHER FOR BREACH OR IN TORT, EVEN IF THE DEVELOPER HAS BEEN PREVIOUSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGE AND EVEN IF THE REMEDY FAILS OF ITS ESSENTIAL PURPOSE. YOU ACKNOWLEDGE THAT GN AUDIO HAS NO RESPONSIBILITY OR DUTY TO DEFEND, INDEMNIFY, OR HOLD YOU HARMLESS FROM AND AGAINST ANY CLAIMS, SUITS, PROCEEDINGS, DAMAGES, LOSS, COSTS AND EXPENSES BASED ON PATENT OR OTHER INTELLECTUAL PROPERTY CLAIMS. b. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAWS, YOU HEREBY RELEASE US FROM ALL LIABILITY AND DAMAGES (INCLUDING, WITHOUT LIMITATION, DIRECT, INCIDENTAL AND CONSEQUENTIAL DAMAGES, LOST PROFITS, OR DAMAGES RESULTING FROM LOST DATA OR BUSINESS INTERRUPTION), WHETHER BASED ON WARRANTY, CONTRACT, TORT (INCLUDING NEGLIGENCE), OR ANY OTHER LEGAL THEORY, EVEN IF WE HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. c. Some states or jurisdictions do not allow the exclusion or limitation of incidental, consequential or special damages, or the exclusion of implied warranties or limitations on how long an implied warranty may last, so the above limitations may not apply to You. You may have rights which vary from state to state or jurisdiction to jurisdiction. The foregoing does not affect or prejudice Your statutory rights. d. GN Audio is under no obligation to provide any support under this License Agreement, including upgrades or further versions of the Software or any portion thereof, to Developer, to any end user or to any other party. GN Audio is acting on behalf of its suppliers for the purpose of disclaiming, excluding and/or restricting obligations, warranties and liability provided in Sections 8 and 9 of this License Agreement, but in no other respect and for no other purpose. e. GN Audio shall in no event be held liable for losses, by you, your company or another entity, including but not limited to, any affiliates of your employer or another entity, in excess of DKK 1,000,000.00 (one million) in aggregate. f. Irrespective of what is stated elsewhere in this section 9, in case any claim, suit or action be brought against you for infringement of any patents, trademarks, or other intellectual property rights arising out of Your use of the Software in accordance with this License Agreement, You shall promptly notify GN Audio of any such claim, suit or action. GN Audio shall, at its own expense, settle or defend any such claim, suit, or action and pay any final judgment for damages and costs that may be awarded against you, to the extent that such claim, suit or action arises out of your use of the Software in accordance with this Agreement, provided that You provide GN Audio with all available information regarding such claim, suit or action, affords GN Audio complete control of the settlement or defense of such claim, suit or action, and cooperates fully with GN Audio in such settlement or defense. GN Audio may, in its sole discretion and at its own expense, elect to procure for You the right to continue using the allegedly infringing Software, or replace them with non-infringing Products, or modify them so that they become non-infringing Software, or remove them. This clause shall not apply to any alleged infringement arising out of * (i) any feature or changes incorporated in the Software or in the Developer Application by you, on your behalf, on your request, or * (ii) use of the Software not in compliance with the License Agreement. ## 10. Non-blocking of GN Audio Development You acknowledge that GN Audio is currently developing or may develop technologies and products in the future that have or may have design and/or functionality similar to products that You may develop based on your license herein. Nothing in this License Agreement shall impair, limit or curtail GN Audio’s right to continue with its development, maintenance and/or distribution of GN Audio’s technology or products. You agree that you shall not assert in any way any patent owned by You arising out of or in connection with these Software or modifications made thereto against GN Audio, its subsidiaries or affiliates, or their customers, direct or indirect, agents and contractors for the manufacture, use, import, licensing, offer for sale or sale of any GN Audio products. ## 11. Third-Party Software To the extent the Software contains third party software including open-source software covered by separate software licenses (“Third-party Software”), the terms and conditions of this License Agreement also applies for such Third-Party Software, unless a Third-Party Software is governed by a separate license. Applicable separate Third Party-licenses are documented in the section [Third-party licenses](/legal/third-party-licenses). GN Audio may update the list and the licenses whenever a new version of the Software is released. You are responsible for having read and understood the Third-Party Software licenses applicable at any time. Notwithstanding anything to the contrary, You are not licensed to (and You agree that You will not) integrate or use this Software with any open source software, unless already governed by open source software licenses, or otherwise take any action that could require disclosure, distribution, or licensing of all or any part of the Software in source code form, for the purpose of making derivative works. Such limitation only applies to open source software which is licensed under the GNU General Public License, the GNU Lesser General Public License, or any other license terms that could require, or condition Your use, modification, or distribution of such software on, the disclosure, distribution, or licensing of any software in source code form, for the purpose of making derivative works. Any violation of the foregoing provision shall immediately terminate all of Your licenses and other rights of the Software granted under this License Agreement. ## 12. Confidential Information a. During the term of this License Agreement and thereafter, You will maintain GN Audio’s Confidential Information (as defined below) in confidence and will employ reasonable steps to protect such Confidential Information from unauthorized or inadvertent disclosure or unauthorized use, including but not limited to all steps that You take to protect Your own information of similar importance that it considers to be proprietary and trade secret, but in no event less than reasonable care. b. You agree: * (i) not to disclose Confidential Information to any third parties, except for employees and independent contractors who have a “*need to know*” and who have signed agreements containing disclosure and use restrictions no less stringent than those set forth herein; and * (ii) not to use any Confidential Information for any purpose except as required to perform under this License Agreement. c. This Section 12 shall not prohibit You from disclosing information to the extent reasonably required by law or regulation; provided that You are required to disclose such information via court order and shall provide prior notice to GN Audio of such required disclosure and the opportunity to obtain an appropriate protective or other court order. d. For the purposes of this License Agreement, “*Confidential Information*” shall mean data and information of a proprietary or confidential nature disclosed by or on behalf of GN Audio under or relating to this Agreement, including, but not limited to, trade secrets, computer programs (including without limitation the Software, all items in the Software, and any derivative works, enhancements, modifications or improvements thereto), proprietary tools, methodologies and other information held in confidence by GN Audio that is marked or designated as confidential at the time of disclosure or would otherwise be reasonably presumed to be confidential. Confidential Information shall not include (or shall cease to include) data or information that: * (i) is or becomes generally known to the public on or after the date of execution of this License Agreement, other than as a result of any act or omission of You; * (ii) was rightfully known to You prior to its receipt from GN Audio; * (iii) is rightfully furnished to You by a third party without restriction as to use or disclosure; or * (iv) is independently developed by You without use of or reference to GN Audio’s Confidential Information. ## 13. General a. When conflicting language exists between this License Agreement and any other information included in the Software, this License Agreement shall supersede. The License Agreement supersedes any prior agreement, oral or written, between GN Audio and You with respect to the licensing to You of the Software. b. Use of the Software may necessitate that you download additional software or purchase a certain good, which are provided by a third party. Your use of third party software or goods may be subject to separate terms between you and said third party. GN Audio shall not be considered a party to any agreement made between you and the third-party provider. c. You agree that GN Audio may provide you with notices, including notices concerning changes to the License Agreement, by email or postings in the Software. d. A party’s failure to exercise or enforce any legal right or remedy which is contained in the Terms (or which a party may have under any applicable law) shall not be considered a formal waiver of that party’s rights or remedies and such rights or remedies shall be available to the party at any time. e. If any provision of this Agreement is held to be invalid, illegal or unenforceable, such determination shall not affect the validity of the remaining provisions which shall continue to be valid and enforceable. f. You accept that all companies which are part of the GN Audio group shall be third party beneficiaries to the License agreement and that they shall be entitled to rely upon and directly enforce any provision of the Terms. g. You agree that GN Audio may audit Your compliance with this License Agreement. h. Your breach of the provisions of Sections 4 and/or 12 of this License Agreement will cause GN Audio irreparable damage for which recovery of monetary damages will be inadequate, and that GN Audio will therefore be entitled to seek timely injunctive relief to protect GN Audio’s rights under this License Agreement in addition to any and all remedies available at law, without the necessity of posting a bond or other security. i. These Terms shall be governed by the laws of the Denmark without regard to its choice of law provisions. Furthermore, you agree that the United Nations Convention on Contracts for the International Sale of Goods shall not apply. The parties agree to submit to the exclusive jurisdiction of the courts of Denmark to resolve any legal matter arising from the Terms. --- --- url: /sdks-and-tools/jabraplusapis.md --- # Jabra Plus APIs The Jabra Plus APIs support the following: * Getting device inventory * Getting meeting room information * Getting and updating device settings * Getting and updating firmware versions * Performing remote reboots of meeting room devices * Subscribing to webhooks for meeting room device status updates ## Background and prerequisites With the Jabra Plus APIs, you can manage devices in Jabra Plus Management. Before using the APIs, you must: * Create an organization in [Jabra Plus Management](https://cloud.jabra.com) * Provision Jabra devices to your organization ## Why is this in beta? The APIs are functional, but the following conditions apply during the beta period: * Features are still under development and can change * Breaking changes are handled through versioning whenever possible * Some documentation and features may be incomplete *Usage of the Jabra Plus APIs is free during the beta period. After this, APIs may become available as a paid service.* ## Feedback and bug reporting As the Jabra Plus APIs are in beta, developers can provide feedback through [developer support](/support/): * What works well and what could be improved * Feature requests for upcoming versions * Bug reports for unexpected behavior ## Getting started The full set of available endpoints and versions is in the [API Portal](https://api-portal.cloud.jabra.com). The portal requires API access to your Jabra Plus organization. You can also use the portal to inspect endpoint details and test HTTP requests. ## Meeting room devices vs. personal devices Jabra Plus Management uses dedicated clients to connect personal and meeting room Jabra devices for centralized management. **Desktop client**: For personal devices, you run a desktop client (Jabra Plus desktop app) on a computer. **Meeting room client**: For meeting room devices, you can either: * Run the Jabra Plus room client on a meeting room compute device * Use supported built-in clients on Jabra meeting room devices * Use the Jabra Plus Provisioning app with room or organization provisioning codes --- --- url: /sdks-and-tools.md --- # Jabra SDKs & Tools ::: tip Building with AI? ✨ If you're using an AI coding agent to build your Jabra integration, check out [Building with AI](/sdks-and-tools/ai-tooling/) for agent skills and resources that improve accuracy and results. ::: ## Core SDKs & APIs * [.NET SDK](/sdks-and-tools/dotnet.md) — Integrate Jabra device functionality in your .NET applications for Windows. * [JavaScript SDK](/sdks-and-tools/javascript.md) — Integrate Jabra device functionality in your JavaScript browser and NodeJS applications for Windows, macOS and Linux. * [Jabra Plus APIs (beta)](/sdks-and-tools/jabraplusapis.md) — Integrate Jabra device functionality into your cloud service. * [JabraCLI](/sdks-and-tools/jabracli.md) — Scripted and fully offline firmware update for Jabra devices. ## Operating Systems * [macOS](/sdks-and-tools/macos.md) — Understand your options if you are looking to build Jabra device integrations for macOS apps. * [Linux](/sdks-and-tools/linux.md) — Understand your options if you are looking to build Jabra device integrations for Linux apps. * [Android & iOS](/sdks-and-tools/android-ios.md) — Interact with the configurable buttons on Jabra Perform and Blueparrott devices and integrate call control in mobile apps. ## Others * [Room Scheduler integration](/sdks-and-tools/room-scheduler) — Integrate third-party room booking platforms with Jabra meeting room scheduling panels. * [Legacy SDKs & Tools](/sdks-and-tools/legacy) — Resources for legacy SDKs and tools no longer recommended for new development. --- --- url: /sdks-and-tools/jabracli.md --- # JabraCLI **`JabraCLI`** is a Command Line Interface tool for managing Jabra personal and meeting room devices without depending on cloud services. It is designed for **developers and IT administrators** developing tailored device management solutions and integrators aiming to incorporate device management capabilities into their products. ::: warning Consider more user-friendly options To manage a fleet of Jabra personal or meeting room devices - or update a single device - consider signing up for a [Jabra Plus](https://www.jabra.com/software-and-services/jabra-plus) account or use [Jabra Direct](https://www.jabra.com/software-and-services/jabra-direct) or [Jabra Xpress](https://www.jabra.com/software-and-services/jabra-xpress). These are simpler options for a more user-friendly experience. ::: **Capabilities of the `JabraCLI` tool:** * Update Jabra personal and meeting room device firmware * Read/write settings on personal and meeting room devices * Observe device properties like background noise and people count on supported devices **IT admins and developers commonly use `JabraCLI` to:** * Integrate Jabra device verification into login scripts or endpoint provisioning flows * Validate device models and firmware versions before rolling out new configurations * Apply standardized configuration profiles across fleets of Jabra devices from configuration management tools * Collect device information for asset management, compliance, or troubleshooting * Incorporate automated device checks into CI/CD jobs that exercise audio/video test environments To learn about the technical setups and use cases that the `JabraCLI` tool was designed to address, please see the [JabraCLI Reference](./reference.md) and [Using JabraCLI](./use-cases.md) pages. See [Installing JabraCLI](./installation.md) to get access to the tool. ## Supported Devices JabraCLI supports a range of Jabra devices including: | Personal Devices | Room Devices | | ---------------- | ----------------- | | • Evolve/Evolve2/Evolve3 series• Engage series• PanaCast 20• Perform series | • PanaCast 50 (USB)• Speak/Speak2 series | ::: warning PanaCast VBS not supported The PanaCast VBS series is currently not supported by the `JabraCLI`. ::: --- --- url: /sdks-and-tools/jabracli/reference.md --- # JabraCLI Reference `JabraCLI` is a cross-platform command-line tool for managing supported Jabra personal and meeting room devices. This page documents the command groups, subcommands, and options used for scripting and operational workflows. For a scenario-focused overview, see [Using JabraCLI](./use-cases.md). ## Top-Level Usage ```sh jabracli [command] [options] ``` Top-level commands: * `config` Use pre-defined configurations to ensure devices are set up as desired. * `firmware` Update firmware on attached devices. * `device` List and get info about Jabra devices. * `property` Work with properties of attached devices. Top-level options: * `-o, --output-format ` Output format. Supported values: `text`, `json`. * `-?, -h, --help` Show help and usage information. * `--version` Show version information. ## Command Groups ### `device` Use this group to list attached devices and monitor device lifecycle events. Subcommands: * `device list` List attached Jabra devices. * `device watch` Watch device events. Examples: ```sh jabracli device list jabracli device list --all jabracli device watch --names "deviceAdded,deviceRemoved" ``` Options: * `device list --all` Show all devices (disables default filter). * `device watch --names ` Required. Comma-separated list of event names. Parameter hints: * Event names for `--names` can be discovered from `jabracli device watch --help`. * Use `jabracli device list --output-format json` as input for automation workflows. Common uses: * Build an inventory of currently attached Jabra devices. * Trigger workflows when devices are attached or removed. * Feed real-time device lifecycle events into monitoring pipelines. ### `property` Use this group to read, write, and watch supported device properties. Subcommands: * `property read` Read values from an attached device. * `property write` Write values to an attached device. * `property watch` Watch properties from an attached device. Examples: ```sh jabracli property read --pid "" --names "," jabracli property write --pid "" --values "=,=" jabracli property watch --pid "" --names "," ``` Options: * `--pid ` Required for all property subcommands. * `read/watch --names ` Required. Comma-separated property names. * `write --values ` Required. Format: `propertyName1=propertyValue1,propertyName2=propertyValue2`. Parameter hints: * Get `--pid ` values from `jabracli device list --output-format json`. * For `--names`, use supported property names for the connected model. See [Select device properties](https://github.com/gnaudio/jabra-dotnet-device-properties-sample?tab=readme-ov-file#select-device-properties). * For `--values`, first read current values with `property read`, then supply writable `name=value` pairs. For popular selectable properties, see [Select device properties](https://github.com/gnaudio/jabra-dotnet-device-properties-sample?tab=readme-ov-file#select-device-properties). Common uses: * Validate settings before handing devices to end users. * Enforce organization-specific property baselines. * Observe changing device properties during troubleshooting. ### `firmware` Use this group to find, download, and apply firmware files. Subcommands: * `firmware list` List firmware versions available for download from jabra.com. * `firmware download` Download firmware files from jabra.com. * `firmware update` Update firmware on specified attached devices from a local firmware file. Examples: ```sh jabracli firmware list --pid "" jabracli firmware download --pid "" --version "" jabracli firmware update --pid "" --firmware-file "./firmware.zip" jabracli firmware update --pid "" --firmware-file "./firmware.zip" --check-only ``` Options: * `list --pid ` Required. * `download --pid --version ` Required. * `update --pid --firmware-file ` Required. * `update --check-only` Validate upgrade feasibility without modifying the device. Parameter hints: * Get `--pid ` values from `jabracli device list --output-format json`. * Get available `--version ` values from `jabracli firmware list --pid ""`. * `--firmware-file ` should point to a local file downloaded with `jabracli firmware download`. Common uses: * Identify available firmware for a specific device model. * Download firmware for controlled or offline rollout. * Validate and execute firmware updates during maintenance windows. ### `config` Use this group to inspect or apply a configuration JSON file to matching attached devices. Subcommands: * `config show` Show the content of a configuration file. * `config apply` Apply firmware and properties defined in a configuration file. Examples: ```bash jabracli config show --config "./config.json" jabracli config apply --config "./config.json" jabracli config apply --config "./config.json" --check-only ``` Options: * `--config ` Path to configuration JSON file. Default is `config.json` in the current directory. * `config apply --check-only` Validate matching state without modifying the device. Parameter hints: * If `--config` is omitted, JabraCLI uses `config.json` in the current working directory. * Use `jabracli config show --config "./config.json"` to validate file content before `config apply`. Common uses: * Apply a standard firmware and property baseline to many devices. * Run compliance checks without changing device state. * Keep provisioning repeatable by version-controlling configuration files. ## Configuration File Example Sample configuration for a PanaCast 50 firmware workflow: ```json { "Name": "PanaCast 50 Sample", "DeviceModels": [ { "PID": 12305, "Properties": { "zoomMode2" : "intelligentZoom", //fullScreen, intelligentZoom, activeSpeaker "roomCapacity" : 6, "peopleCountEnabled" : true }, "Firmware": { "LocalPath": "./Jabra_PanaCast_50_9.0.5.zip" } } ] } ``` See [Jabra Device Properties Sample app](https://github.com/gnaudio/jabra-dotnet-device-properties-sample?tab=readme-ov-file#select-device-properties) for more examples of supported properties and values to include in the configuration files. Contact [developer support](/support/) if you need help finding the right property names and values for your use case. ## Operational Notes * Prefer `--output-format json` for automation pipelines. * Device support, available firmware, and selectable properties depend on device and firmware capabilities. ### Usage Telemetry Collection JabraCLI will share anonymized usage telemetry with Jabra to support product improvements. This includes command usage patterns and error occurrences. No personally identifiable information or sensitive data is collected. [Contact developer support](/support/) if you have questions or concerns about telemetry collection. ### Debug Logging To enable additional debug logging for troubleshooting, set the following environment variable: ``` JABRA_CLI_ENABLE_DIAGNOSTICS=true ``` Log files are written to the user’s local application data folder under `/Jabra/JabraCli/Logs`. --- --- url: /sdks-and-tools/legacy.md --- # Legacy SDKs & Tools Access to legacy SDKs and documentation is not available at this site. Please contact us through the [support form](/support/) describing your specific need. For information about security advisories, please visit our [Security Center](https://www.jabra.com/supportpages/security-center). Latest versions of select Legacy SDKs and tools: | Legacy SDK/Tool | Latest Version | | -------------------------------------------------- | -------------------: | | **Jabra Linux SDK (gen 2)** | v2.0.4.0 | | **Jabra SDK for Windows (gen2) (C/C++)** | v2.0.4.0 | | **Jabra Mac SDK (gen 2) (Obj-C)** | v2.0.4.0 | | **[Jabra Call Control for Amazon Connect SDK](/sdks-and-tools/amazonconnect)** | v1.1.2 | ### End-user components (for Legacy SDKs) To use the legacy Browser SDK with USB devices, install two Jabra software components on the end-user's computer. Download them below. ::: warning Legacy SDK components These components support integrations built with legacy Jabra SDKs, which are no longer distributed online. For current SDKs, see [components for the latest Jabra SDKs](/sdks-and-tools/javascript/end-user-components). ::: | File | Description | Download | | ------------------------------------------ | -------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Browser Extension for Device Connector(legacy SDK)** | Works across operating systems. Supports Microsoft Edge and Google Chrome. | [Chrome Web Store](https://chromewebstore.google.com/detail/jabra-chromehost-chrome-e/okpeabepajdgiepelmhkfhkjlhhmofma)(for legacy SDKs) | | **Device Connector Application(legacy SDK)** | Installed application required by the Browser Extension | [for Windows](/downloads/EndUserRuntimes/SDK2/jabra-chrome-host2.1.0.msi.zip)[for macOS](/downloads/EndUserRuntimes/SDK2/jabra-chrome-host2.1.1.dmg.zip)(for legacy SDKs) | --- --- url: /use-cases/meeting-room-video-and-audio.md --- # Meeting Room Video & Audio Jabra devices add value by offering in-room camera and audio configuration options within an estate of meeting rooms. This allows applications to automatically set up devices in meeting rooms and manage, update, and configure the Jabra devices in the installation. Jabra SDKs and tools are designed to make this simple and easy to do. *Can be built with * --- --- url: /legal/privacy-policy.md --- # Privacy Policy This privacy policy applies to Jabra SDKs, Integration Software and the website developer.jabra.com. It describes how GN Audio A/S (“*GN*”, "*we*" or "us") processes personal data about you in case; * you download our (i) integration services, (ii) plug ins, (iii) libraries and components provided through our software development kit, (iv) other available software, or documentation (altogether named “*Software*”) from our [Developer Zone](https://developer.jabra.com) or from other third-party websites (in the following we will categorize you as a “*developer*”), or * you are customer using an application, e.g. a contact center software which makes use of the Software (in the following we will categorize you as “*end user*”) We will collect and use your personal data in accordance with applicable law and only to the extent necessary for the achievement of the purpose of use specified in advance and in a proper manner. | Publication Date | Description | |---|---| | 2022-10-04 | First publication| ## 1. Data Controller The legal entity who is controller and responsible for processing your personal data is: *GN Audio A/S, Lautrupbjerg 7*\ *2750 Ballerup/Denmark*\ *Tel. + 45 45 75 00 00*\ *Mail info@gn.com* GN Audio A/S markets products and services under different brand names such as Jabra. ### Data Protection Officer For **general questions** concerning your personal data you may contact our data protection officer on [GN Data Privacy Inquiry Site](https://privacyportal-eu.onetrust.com/webform/4c166da3-c2d4-4751-bbdb-9d0adf1bf864/b7d98407-0979-41ac-8134-388364d88f2d). For **specific requests** concerning your personal data you may contact our data protection officer on [GN Data Privacy Request Site](https://privacyportal-eu.onetrust.com/webform/4c166da3-c2d4-4751-bbdb-9d0adf1bf864/f6b3adea-5764-4c6f-b962-07f8343d86ed). You are also free to contact our Data Protection Officer on telephone +45 45 75 00 00 ## 2. Description of processing – purpose, specific use of personal data and legal basis If you are a **developer**, we will use your personal data in the following ways: * If you use our [Developer Zone](https://developer.jabra.com) as a **Registered User** to access or use our Software, we collect your email, password your name and country, phone no (optional) and mobile phone no (optional) to set you up as a user and to communicate with you. We use your emails to send you emails with information about the content and updates on the developer zone. We assign you an internal *Partner Key* to identify you and to understand how your end users use the functionality embodied in our Software. * If you choose to sign up as a **Integration Partner**, we ask for your company name and contact information in order for us to communicate with you and your company concerning the contact on the developer zone. When you visit our developer zone, we also collect certain **server log information** through automated means, such as your * IP-number * Time of your visit * Visited URL’s/queries on our developer zone * The referring webpage * Your browser version We collect the server log information for security and statistical purposes. * If you download our Software from another website, please refer to the privacy policy of the website in question. * If you visit our Developer Zone only to download runtime components we do not collect any data about you. To the extent use of your personal data is governed by the EU personal data regulation or equivalent national regulation you are hereby informed that the legal basis for our use is our legitimate interest (Article 6.1. (f) of Regulation (EU) 2016/679). We need to register your contact info to communicate with you and collect the log server information to optimize the services on the website for you. Further we need the server log information to reduce security threats which is to your benefit. If you are an **end user of a third-party software**, e.g. a contact center software which is using the Software (embedded in the third-party software) and our products such as headsets, speakerphones, cameras or other products or services (“Products”), we may collect information for diagnostic and development purposes. Please note that we are not able to identify you based on these data and we only collect these data to the extent the third-party software provider, e.g. a contact center software provider, has decided to collect the data about your use of our Software and to transfer this to us. If collected, the information may include information such as a hashed version of your MAC address, which type of the Software you are using, your browser type and operating system, which parts of the Software and Products you use and when you use the Software and Products - to understand how much you use the functionality in the Software and in our Products. Please also refer to the privacy policy of your third-party software provider for further information. ## 3. Cookies Please refer to our cookie policy on developer.jabra.com ## 4. Retention period Your personal data will be stored by us for as long as necessary in order to fulfil the purposes described above. If you are a developer, we store your information as long as you or your company use the Software and for a needed period hereafter for documentary purposes in legal matters. If you are an end user, we only keep your data for a limited period in order to diagnose any problems or challenges and/or to improve our software or products and services, and then your data is anonymized. ## 5. Collection of personal data We only collect your personal data from the following sources: * If you are a developer; we get the information directly from you when you provide them on our website and through your online use of our website, or * If you are a user of a third-party software your data (not personal data) is collected automatically through your use of the Software embedded in the third party software. ## 6. Recipients We will generally limit sharing of your personal data and always only share to the extent necessary. However, we might share your personal information with: * group companies when necessary to carry out the purpose. See more about the GN Group on [www.gn.com](https://www.gn.com) * IT suppliers, e.g. hosting partners, maintenance or technical support. These parties may not process your personal data for their own purposes. ## 7. International transfers In some cases, we will transfer personal data to recipients identified above which may be located in countries outside of your jurisdiction. Such transfers will be conducted in strict accordance with applicable laws, and where required we will provide appropriate safeguards for such transfers. When transferring personal data out of the European Union or other jurisdictions requiring appropriate safeguards, we will use either the standard contractual clauses as approved by the European Commission or equivalent national bodies, or any other contractual agreement approved by the competent authorities as a basis for the transfer and where necessary, implement additional supplementary safeguards to ensure an adequate level of protection. Your personal data will be stored in your jurisdiction if the applicable law requires so. Please contact us by using the contact details in section 1 above, if you would like further information on the specific mechanism used by us when transferring your personal data out of the European Union and/or other jurisdictions requiring appropriate safeguards. ## 8. Your rights Data protection law gives you a range of rights in connection with our processing of your personal data. In this regard you have the right to request access to the personal data concerning you that we process. You may request that we rectify or delete the personal data or restrict the processing of your personal data, if you think they are inaccurate. You may have the right for data portability. We are required to assess and act on your request. The mentioned rights may be subject to conditions or restrictions. Accordingly, there is no certainty that you will be entitled to for example data portability in the specific situation; it will depend on the circumstances of the processing. If you wish to contact us about our processing of your personal data, feel free to contact our Data Protection Officer as specified above in section 1. You have the right to file a complaint with your local data protection agency. ## 9. Additional Information for California Residents In addition to the information stated above the following information also applies to you, if you are a California resident. California Civil Code Section 1798.83 permits you to request and obtain from us once a year, free of charge, information about the personal information, (if any) we disclosed to third parties for direct marketing purposes in the preceding calendar year. If applicable, this information would include a list of the categories of personal information that was shared and the names and addresses of all third parties with which we shared information in the immediately preceding calendar year We do not sell and have not sold personal information in the preceding 12 months. We do not sell the personal information of minors. You have the right to be free from unlawful discrimination for exercising your rights under the CCPA. --- --- url: /sdks-and-tools/dotnet/properties.md --- # Properties The Properties module is used to get and set settings on Jabra devices and to listen for telemetry data events from devices. In the [code samples](./samples-and-reference.md#code-samples), you will find a link to a demo implementation of Device Settings and telemetry, while the main concepts are highlighted in the following. The demo implementation includes details on common properties for selected meeting room, camera, and headset devices. The `Properties` module provides access to the following functionality: * Reading and modifying device settings * Getting telemetry information * Accessing advanced device information such as firmware version ## Set up Properties module To use the `Properties` module, you need to [initialize the core SDK module](./#getting-started) and install the [`Jabra.NET.Sdk.Properties`](https://www.nuget.org/packages/Jabra.NET.Sdk.Properties) nuget package: ```sh dotnet add package Jabra.NET.Sdk.Properties ``` To start interacting with Properties, first create an instance of the `PropertyModule` and then create an instance of the `PropertyFactory`. ```C# //Initialize the SDK's properties module IPropertyModule jabraSdkProps = new PropertyModule(jabraSdk); IPropertyFactory jabraSdkPropsFactory = await jabraSdkProps.CreatePropertyFactory(); ``` ## PropertyMap Before reading or writing properties to/from a device you need to define a PropertyMap of the properties you intend to use. In this example we're using two properties from the Jabra PanaCast 50 meeting room camera. ```C# string[] propertyNames = { "zoomMode2", "(...) other properties you want to interact with" }; IPropertyMap propertyMap = await jabraSdkPropsFactory.CreateProperties(device, propertyNames); ``` ## Read/write property To read the current state of a setting (property) or change a setting, you simply Get the property or start a transaction for setting properties. ::: code-group ```C# [Reading property value] // Reading value of the zoomMode2 property PropertyValue zoomMode2 = await propertyMap["zoomMode2"].Get(); Console.WriteLine($"Zoom mode: {zoomMode2}"); ``` ```C# [Writing property value] //Write properties to device. IPropertyTransaction transaction = propertyMap.StartTransaction(); // Valid values for "zoomMode2": "fullScreen" | "intelligentZoom" | "activeSpeaker" transaction.Set("zoomMode2", new StringPropertyValue("activeSpeaker")); // Additional transaction.Set lines for further settings // you want to change as part of same transaction. await transaction.Commit(); ``` ::: ::: info Some settings trigger reboot Note that some of the settings you can change using properties will trigger Jabra devices to reboot. See [Properties code sample](./samples-and-reference.md#properties-sample) for more. ::: ## Telemetry data Some properties can be read *and* observed for telemetry event data. Examples include the "peopleCount" property available in Jabra PanaCast 50 meeting room camera and the "backgroundNoiseLevel" property available in Jabra Engage 40/50/50 II headsets. ```C# // Observing a property IObservable propertyWatcher = propertyMap["peopleCount"].Watch; propertyWatcher.Subscribe(value => { Console.WriteLine($"Property change observed on '{propertyMap.Device.Name}':"); Console.WriteLine($"Received value (peopleCount): {value}"); }); ``` ## Other properties In the [Properties code sample](./samples-and-reference.md#properties-sample) we're detailing common properties of interest for developers for selected meeting room, camera, and headset devices. If you're interested in other settings or telemetry data points for Jabra devices, please [contact us](/support/), detailing what you're looking for. --- --- url: /sdks-and-tools/javascript/properties.md --- # Properties The Properties module is used to get and set settings on Jabra devices and to listen for telemetry data events from devices. [Live sample implementation](./samples-and-reference.md#code-samples) The demo implementation includes details on common properties for Jabra Engage 40 and 50 II headset devices. ## Initialize Before you can use the Properties module in your application, you must [initialize the core SDK](./) and install the properties npm packages: ```sh npm install @gnaudio/jabra-properties npm install @gnaudio/jabra-properties-definition ``` To start interacting with Properties, first create an instance of the `PropertyModule` and then create an instance of the `PropertyFactory`. ```js // Import the core Property module as well as the default properties definition JSON import { PropertyModule } from '@gnaudio/jabra-properties'; import propertiesDefinition from '@gnaudio/jabra-properties-definition/properties.json' with { type: "json" } // Initialize the SDK's properties module let propertyModule = new PropertyModule(); let propertyFactory = await propertyModule.createPropertyFactory(propertiesDefinition); ``` ## PropertyMap To read, write, or watch properties for a device, you need to define a `PropertyMap` of the properties you intend to use. In this example, we're using selected properties from the Jabra Engage 40, 50, and 50 II headsets. ```js // List the Jabra device properties and prepare them for use on the device const propertyNames = [ "firmwareVersion", "backgroundNoiseLevel", "audioExposure", "customerSpeaking", "agentSpeaking", "microphoneMuteState", "sidetoneEnabled" ]; const propertyMap = await propertyFactory.createProperties(device, propertyNames); ``` ## Read/write property To read the current state of a setting (property) or change a setting, you simply get the property or start a transaction for setting properties. ::: code-group ```js [Reading property value] //Read properties from device const firmwareVersion = await propertyMap.get("firmwareVersion").get(); console.log("Firmware version: " + firmwareVersion, { deviceName: device.name }); ``` ```js [Writing property value] //Write properties to device. const value = true; await propertyMap.startTransaction().set("sidetoneEnabled", value).commit(); ``` ::: ::: info Some settings trigger reboot Note that some of the settings you can change using properties will trigger Jabra devices to reboot. ::: ## Telemetry data Some properties can be observed for telemetry event data. Examples include the "backgroundNoiseLevel" property available in Jabra Engage 40, 50, and 50 II headsets. ```js // Observing a property const backgroundNoiseLevelProperty = propertyMap.get("backgroundNoiseLevel"); backgroundNoiseLevelProperty.watch().subscribe({ next(value) { // When a new value is received console.log(`${backgroundNoiseLevelProperty.name}: ${value}`); }, error(e) { // When an error occurs when setting up or running the watch if (e instanceof JabraError) { console.error(`Could not subscribe to ${backgroundNoiseLevelProperty.name}. It may not be supported by device`, { level: "error" }); } else { console.error(`Failed monitoring ${backgroundNoiseLevelProperty.name}: ${e}`, { level: "error" }); } }, complete() { // When the watch is ended. E.g. when the device is disconnected console.log(`Completed observing ${backgroundNoiseLevelProperty.name}`); } }); ``` ## Other properties In the [Properties & Button Customization demo](./samples-and-reference.md#code-samples) we're detailing common properties of interest for developers for select headset devices. If you're interested in other settings or telemetry data points for Jabra devices, please [contact us](/support/), detailing what you're looking for. --- --- url: /sdks-and-tools/room-scheduler.md --- # Room Scheduler integration Are you developing a room or resource scheduling solution? We'd love to explore integrating your platform with the [Jabra Scheduler](https://www.jabra.com/business/video-conferencing/jabra-scheduler) device. The Jabra Scheduler is designed to streamline meeting room management, and we're open to partnerships that bring innovative scheduling solutions to our hardware. Integration can be achieved through two technical approaches: * **Web-based integration**: Present your solution's browser based app directly on the Jabra Scheduler device * **Native Android integration**: Embed your Android app (APK) within our devices ## Get Started If you're interested in exploring an integration partnership, please reach out through our [developer support ticket form](/support/). We're happy to discuss the technical requirements, integration process, and next steps to bring your scheduling solution to Jabra Scheduler users. --- --- url: /use-cases/room-scheduling.md --- # Room Scheduling Jabra Meeting Room scheduling panels, such as the [Jabra Scheduler](https://www.jabra.com/business/video-conferencing/jabra-scheduler), seamlessly integrate with third-party room booking platforms. This enables organizations to display real-time room availability and booking information outside meeting spaces, improving meeting efficiency and space utilization. Jabra is happy to work with partners to provide integration guidance and support. *Can be built with * --- --- url: /sdks-and-tools/dotnet/samples-and-reference.md --- # Samples and SDK reference ## API reference Please see the relevant API reference for detailed information on the Jabra .NET SDK modules: * SDK Core API reference: [Jabra.NET.Sdk](https://sdk.jabra.com/dotnet/docs/Sdk/latest/index.html) * SDK Properties API reference: [Jabra.NET.Sdk.Properties](https://sdk.jabra.com/dotnet/docs/Sdk.Properties/latest/index.html) * SDK Button Customization API reference: [Jabra.NET.Sdk.ButtonCustomization](https://sdk.jabra.com/dotnet/docs/Sdk.ButtonCustomization/latest/index.html) * SDK Device Pairing API reference: [Jabra.NET.Sdk.DevicePairing](https://sdk.jabra.com/dotnet/docs/Sdk.DevicePairing/latest/index.html) ## Code samples Code samples are hosted on GitHub. Questions or requests for support for code samples should however be raised at this site through the [support form](/support/). ### Easy Call Control sample The [Easy Call Control sample](https://github.com/gnaudio/jabra-dotnet-easy-call-control-sample) demonstrates how to implement call control for Jabra devices in e.g. softphones using the recommended Jabra Easy Call Control SDK module. ### Properties sample The [Properties code sample](https://github.com/gnaudio/jabra-dotnet-device-properties-sample) demonstrates how to read, write and observe common settings and telemetry data properties for the Jabra PanaCast 50 meeting room camera and various Jabra headsets. ### Bluetooth Pairing sample The [Bluetooth Pairing sample](https://github.com/gnaudio/jabra-dotnet-bt-pairing-sample) demonstrates how to pair/unpair and connect/disconnect headsets with the Jabra Link 380 or Jabra Link 390 BT dongle using the Jabra .NET SDK. --- --- url: /sdks-and-tools/javascript/samples-and-reference.md --- # Samples and SDK reference ## Code samples ### Easy Call Control demo app Please see the comprehensive demo project for Easy Call Control. The recommended transport to use for the demo is "Chrome Extension with WebHID fallback". :::warning Please ignore other demos in the demo source project The source code download for this demo contains other demo code. We recommend only basing off the Easy Call Control (multi-call option) sample code as that is the recommended way to integrate call controls for Jabra headsets. ::: [Try the Easy Call Control demo](https://sdkjsproduction.z16.web.core.windows.net/demos/ecc-demo-multi/) — Source available for download from the demo. Source available for download from the demo ### Properties & Button Customization demo Please see the demo page for working with device properties and button customization. It demonstrates the following in JavaScript/TypeScript: * How to read/write settings from devices * How to subscribe to data telemetry events like background noise (on supported devices) * How to take over buttons and LEDs (on supported devices) [Try the Properties & Button Customization demo](https://gnaudio.github.io/jabra-js-device-properties-sample/) — [Source on GitHub](https://github.com/gnaudio/jabra-js-device-properties-sample). View [source on GitHub](https://github.com/gnaudio/jabra-js-device-properties-sample) ## API references Please see the relevant API reference for detailed information on the SDK: * SDK Core API reference: [@gnaudio/jabra-js](https://sdk.jabra.com/javascript/docs/jabra-js/latest/index.html) * SDK Properties API reference: [@gnaudio/jabra-js-properties](https://sdk.jabra.com/javascript/docs/jabra-js-properties/latest/index.html) * SDK Button Customization API reference: [@gnaudio/jabra-js-button-customization](https://sdk.jabra.com/javascript/docs/jabra-js-button-customization/latest/index.html) --- --- url: /use-cases/telemetry.md --- # Telemetry The latest Jabra audio and video devices can provide real-time telemetry data during usage for meeting rooms and personal devices. Data available includes people counting, headset boom arm position, background noise measurement, and wireless link quality. These new use cases provide real-time insights into device usage, meeting room dynamics and overall call quality. Jabra SDKs are designed to make this simple and easy to do. *Can be built with * --- --- url: /launch.md --- # Tell us what you build, so we can help you launch Once your integration is complete, please tell us about your company and application by completing the form on this page. We can then add your application to our online [Compatibility Guide](https://www.jabra.com/compatibilityguide). This can help promote your solution and organization 🚀 *** --- --- url: /legal/third-party-licenses.md --- # Third Party Licenses This section contains third party licenses for Jabra SDK and Jabra Integration Software. |Version | Publication Date | Description | |---|---|---| |**1.3**|2023-07-10|libjsoncpp added.| |**1.2**| 2023-02-20 | DotNetZip, Json.NET, NLog, JZLIB, ZLIB and BZIP2 added.| |**1.1**| 2023-01-04 | Miniz and Shoco licenses added.| |**1.0**| 2022-10-04 | First online publication of third party licenses.| ## BZIP2 The managed BZIP2 code included in Ionic.BZip2.dll and Ionic.Zip.dll is modified code, based on Java code in the Apache commons compress library. Apache Commons Compress is provided under the Apache 2 license: [Apache Commons Compress](http://commons.apache.org/proper/commons-compress/) Copyright 2002-2014 The Apache Software Foundation Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at [www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0). Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Many thanks to Julian Seward for the original C implementation of \[BZip2] ( http://www.bzip.org/). ## DotNetZip As DotNetZip includes work derived from other projects, you are required to comply with the terms and conditions for each of them. These licenses include BSD, Apache, and zlib. To use the software, you must accept the licenses. If you do not accept the licenses, do not use the software. Original intellectual property in DotNetZip is provided under the Ms-PL: Copyright (c) 2006 - 2011 Dino Chiesa Copyright (c) 2006, 2007, 2008, 2009 Dino Chiesa and Microsoft Corporation. ### Microsoft Public License (Ms-PL) This license governs use of the accompanying software, the DotNetZip library ("the software"). If you use the software, you accept this license. If you do not accept the license, do not use the software. ### 1. Definitions * The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under U.S. copyright law. * A "contribution" is the original software, or any additions or changes to the software. * A "contributor" is any person that distributes its contribution under this license. * "Licensed patents" are a contributor's patent claims that read directly on its contribution. ### 2. Grant of Rights **(A) Copyright Grant** - Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create. **(B) Patent Grant** - Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software. ### 3. Conditions and Limitations * **(A) No Trademark License** - This license does not grant you rights to use any contributors' name, logo, or trademarks. * **(B)** If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically. * **(C)** If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software. * **(D)** If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license. * **(E)** The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement. ## Json.NET The MIT License (MIT) Copyright (c) 2007 James Newton-King Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without imitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ## jsoncpp Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "*Software*"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: **The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Updated license information on [GitHub](https://github.com/open-source-parsers/jsoncpp/blob/master/LICENSE). ### JZLIB The managed ZLIB code included in Ionic.Zlib.dll and Ionic.Zip.dll is derived from jzlib. [jzlib](https://github.com/ymnk/jzlib) is provided under a BSD-style (3 clause) Copyright (c) 2000,2001,2002,2003 ymnk, JCraft, Inc. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ## libcurl Copyright (c) 2015 Andreas Rumpf Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “*Software*”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: **The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.** THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Updated license information on [GitHub](https://github.com/Araq/libcurl/blob/master/LICENSE.txt). ## libjsoncpp Copyright (c) 2007-2010 Baptiste Lepilleur Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Updated license information can be found on [libjsoncpp license information](https://github.com/open-source-parsers/jsoncpp/blob/master/LICENSE). ## Miniz Copyright 2013-2014 RAD Game Tools and Valve Software Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC All Rights Reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Updated license information can be found [Miniz license information](https://github.com/richgel999/miniz/blob/master/LICENSE). ## NAudio Copyright (c) 2020 Mark Heath Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: **The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Updated license information on [GitHub](https://github.com/naudio/NAudio/blob/master/license.txt). ## NLog Copyright (c) 2004-2018 Jaroslaw Kowalski (jaak@jkowalski.net), Kim Christensen, Julian Verdurmen All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Jaroslaw Kowalski nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ## pugixml Copyright (c) 2006-2018 Arseny Kapoulkine Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “*Software*”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: **The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.** THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Updated license information on [pugixml.org](https://pugixml.org/license.html). ## Shoco The MIT License (MIT) Copyright (c) 2014 Christian Schramm Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Updated license information can be found in [shoco license information](https://github.com/Ed-von-Schleck/shoco/blob/master/LICENSE). ## ZLIB The jzlib library, itself, is a re-implementation of ZLIB v1.1.3 in pure Java. zlib is provided under the zlib license: Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler The ZLIB software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly (jloup@gzip.org), Mark Adler (madler@alumni.caltech.edu) --- --- url: /sdks-and-tools/javascript/transport-mode.md --- # Transport mode for web apps ::: info This section is relevant for Browser apps only ::: For web applications, running directly in Chrome, Edge or another Chromium based web browser, you need to consider the transport mode used to communicate with Jabra devices. ::: warning Always choose "Chrome extension with WebHID fallback transport" when initializing the SDK As mentioned previously, we strongly recommend that you choose "Chrome extension with WebHID fallback transport" when initializing the SDK. This way, the SDK automatically selects the optimal transport based on whether [End-user components](./end-user-components.md) are installed on the end user's PC or not. ::: The SDK can use either "WebHID" or "Chrome Extension" transport mode for web apps. To check which transport mode is currently used: ```js switch (jabraSdk.transportContext){ case TransportContext.WEB_HID: console.log('Using WebHID transport'); break; case TransportContext.CHROME_EXTENSION: console.log('Using Chrome Extension transport'); break; default: break; } ``` ## WebHID transport mode This means that the Jabra SDK uses the browser's native WebHID API to communicate with Jabra devices. WebHID requires no installed software and therefore works across any desktop version of Chrome/Edge or other Chromium based browsers. WebHID requires end user consent to access a headset device controls, similar to how access to microphone or camera requires consent. The WebHID consent dialog can only be triggered by an end user interaction, such as clicking a button. Consent is persisted in the browser, so end users only need to consent once per Jabra device in your web app. See [Device added/removed](./index.md#device-addedremoved) for example on how to trigger WebHID consent dialog. ### WebHID policies To avoid the end-user consent dialogue, an IT administrator can use Chrome/Edge administrator policies to allow access to Jabra headsets from defined URLs. Please see: [Chrome WebHID policy](https://chromeenterprise.google/policies/#WebHidAllowDevicesForUrls) [Edge WebHID policy](https://learn.microsoft.com/en-us/deployedge/microsoft-edge-policies#webhidallowdevicesforurls) **Example policy** for Chrome on Windows, allowing all Jabra devices (vendor ID 2830) - replace www.example.org with the URL of the app you want to grant access, and save as a .reg file - then open .reg file to test policy: ``` Windows Registry Editor Version 5.00 [HKEY_CURRENT_USER\Software\Policies\Google\Chrome] "WebHidAllowDevicesForUrls"="[ { \"devices\": [ { \"vendor_id\": 2830 } ], \"urls\": [ \"https://sdk.jabra.com\", ] }]" ``` ### WebHID limitations While the SDK generally ensures that multiple softphones can have Jabra call control integrations co-exist without conflicts, part of this protection against softphone conflicts cannot work only with WebHID. Additionally, features around device connections, properties, and button customization do not work through WebHID on all Jabra devices. By installing the [End-user components](./end-user-components.md) device communication will be handled through the Jabra Device Connector application which resolves these limitations. *If a customer of your softphone run into conflicts with other softphones accessing the headset, please instruct your customer to install the [End-user components](./end-user-components.md).* ## Chrome Extension transport mode If [End-user components](./end-user-components.md) are installed, your web app will automatically use the Chrome Extension transport mode. In this transport mode the SDK sends messages to/from the browser extension. The extension then uses [native messaging](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging) to communicate with the Jabra Device Connector application. The Jabra Device Connector application has full access to all Jabra device features, and manages conflicts between multiple softphones using the Jabra headset, at the same time. --- --- url: /sdks-and-tools/jabraplusapis/usage-terms.md --- # Usage Terms, Rate Limits, and Error Handling *Usage of the Jabra Plus APIs is free during the beta period. After this, APIs may become available as a paid service.* For legal terms, see [Jabra Plus legal agreements](https://cloud.jabra.com/profile/legal). ## Rate limits and quota The Jabra Plus APIs are governed by the following general limits (both apply): * 10,000 API calls every five minutes * 100 API calls per second For firmware updates, device setting changes, and reboot operations: * One API request every minute *per device* When limits are exceeded, the API returns **HTTP 429 Too Many Requests** with a `Retry-After` header. Clients should treat HTTP 429 as an expected condition and: * Respect the `Retry-After` header * Apply exponential backoff and jitter ## Best practices * Cache responses when appropriate * Use pagination efficiently with a page size of 100 * Batch non-urgent operations during off-peak periods ## Error handling Common HTTP status codes: * 200 OK: Successful request * 400 Bad Request: Invalid parameters * 401 Unauthorized: Missing or invalid subscription key * 404 Not Found: Room or device not found * 429 Too Many Requests: Rate limit exceeded * 500 Internal Server Error: Server-side issue --- --- url: /use-cases.md --- # Use cases * [Call Control](/use-cases/call-control.md) — Enable answer, mute, and hang up directly from Jabra devices. * [Telemetry](/use-cases/telemetry.md) — Capture real-time device and room telemetry during usage. * [Device Management](/use-cases/device-management.md) — Monitor, configure, and update devices at scale from software. * [Meeting Room Video & Audio](/use-cases/meeting-room-video-and-audio.md) — Configure and manage in-room Jabra video and audio settings. * [Room Scheduling](/use-cases/room-scheduling.md) — Integrate room panels with booking platforms for live availability. --- --- url: /sdks-and-tools/jabracli/use-cases.md --- # Using JabraCLI **This page provides an introduction to the use cases and scenarios `JabraCLI` is designed for.** JabraCLI is intended for technical users who need predictable and scriptable device control, including: * IT administrators managing fleets of USB connected Jabra devices in shared offices and home-office environments * Integration engineers embedding device management tasks into enterprise tooling * Support and operations teams validating device state during troubleshooting For a detailed reference of commands and options, see [JabraCLI Reference](./reference.md). ::: info USB connected devices only Be aware that only USB connected Jabra devices (including dongle connected headsets) are currently supported. See [Supported Devices](./#supported-devices). ::: ## Manage Devices Offline ::: warning Consider more user-friendly options To manage a fleet of Jabra personal or meeting room devices - or update a single device - consider signing up for a [Jabra Plus](https://www.jabra.com/software-and-services/jabra-plus) account or use [Jabra Direct](https://www.jabra.com/software-and-services/jabra-direct) or [Jabra Xpress](https://www.jabra.com/software-and-services/jabra-xpress). These are simpler options for a more user-friendly experience. ::: Customers looking to implement a fully offline device management solution - e.g. for secure environments without internet access - can use `JabraCLI` as the basic building block to update firmware and manage centrally defined device settings without any cloud dependencies. For example, this enables IT administrators to apply a pre-defined configuration on Jabra devices to ensure they are always set up according to company policy when connected. This is what the `jabracli config` commands are designed for. A high-level outline to achieve this could look like this: 1. Create a `config.json` file with the desired device settings and firmware versions for the devices you intend to manage. * See [Configuration File Example](./reference.md#configuration-file-example) for details on the configuration file format and options. * Use `jabracli device list`, `jabracli firmware list` to get product ID (PID) and firmware version information to include in the configuration file. * Use `jabracli config show` to validate that the configuration file is correctly set up to apply the desired settings and firmware versions on the target devices. 2. Download the target firmware file(s). From https://www.jabra.com/support or via `jabracli firmware download`. 3. Distribute the configuration file(s) and firmware file(s) to a location available through the local file system on the target machines. 4. Deploy `JabraCLI` to all target machines where you expect to have Jabra devices connected. This can be done via software distribution tools or manual installation. 5. Set up automation to run `jabracli config apply --config-file ` on the target machines to apply the configuration and firmware updates on connected devices. ## Integrate with Purpose-Built Multi‑Vendor Enterprise Systems Customers with niche needs for device management setup - e.g. need for uniform device management across different brands of devices, or need to integrate device management into existing enterprise software - can use `JabraCLI` as a component in a more complex solution that combines the tool with other software and scripts. The not-continuously-running nature of the `JabraCLI` commands makes it suitable for integration into larger scripts and software solutions that perform multiple tasks, where device management is just one part of the overall workflow. ## Run One-Off Device Tasks Technical users can also use `JabraCLI` for one-off device management operations, e.g. to update the firmware on a specific Jabra device or to read a specific device property for troubleshooting purposes. ## Embed Device Management in Third-Party Software Integration partners building software with Jabra device management capabilities can use `JabraCLI` as a component in their solution to perform specific device management tasks like updating firmware, applying configurations, or retrieving device information. For this use case it is recommended to also understand the capabilities of the [Jabra SDKs](/sdks-and-tools/). They integrate more naturally into supported development stacks (JavaScript and .NET). However, for firmware update capabilities `JabraCLI` is currently the only option. --- --- url: /sdks-and-tools/jabraplusapis/webhooks.md --- # Webhooks Use Jabra Plus webhooks to receive near real-time updates for meeting room devices. You can subscribe to notifications for events such as: * Device status changes (for example, offline, online, or rebooted) * Firmware changes (for example, update completed) The webhook payload schema can be downloaded when creating or editing a webhook in [Jabra Plus Management](https://cloud.jabra.com/integrations/configurable-webhooks). ::: warning Webhooks are limited to meeting room devices Webhooks are available only for meeting room devices. For personal device state, use REST API polling at an interval that complies with [rate limits and quota](./usage-terms#rate-limits-and-quota). ::: ## Add a webhook **Prerequisites** * You have admin access to Jabra Plus Management with the *Owner* role * You have a publicly reachable HTTPS endpoint to receive events **Procedure** 1. Sign in to Jabra Plus Management with an account that has the *Owner* role. 2. In the left navigation, select **Integrations**. 3. On **Configurable Webhooks**, select **Add webhook**. 4. In **Add webhook for meeting rooms**: * Enter a webhook name * Enter the **Webhook URL** (your callback endpoint) * Select authentication method (**None** or **Basic**) * Select event types, for example **Device status changed** and **Firmware changed** 5. Select **Add webhook**. After creation, Jabra Plus sends a validation event to your callback URL. To complete validation, inspect the event payload, locate `validationUrl`, and send an HTTP GET request to that URL within 10 minutes. If validation succeeds, the webhook is activated and starts sending events for the selected event types.