# FAQ
How do I verify if a user is already registered to a license in FSv2?
After registering a user, query the registered users for any license using `getLicenseUsers(licenseId)`:
```java
List users = service.getLicenseUsers(licenseId);
```
Each entry includes `username`, `email`, `maxActivations`, `timesActivated`, and `borrowedUntil` so you can check if a specific user is already registered and whether they have an active borrow. Similarly, `getLicenseFeatures(licenseId)` returns which users have which features registered.
How do I check the current state of a license in FSv2?
Use `getLicenseById(licenseId)`, which returns the full license object including:
* `floatingInUseDevices` how many users are currently registered
* `floatingUsers` the maximum allowed
* `isValid`, `licenseActive`, `licenseEnabled` license status flags
This is the FSv2 equivalent of checking license status.
How do FSv2 operations map to FSv1 / online floating operations?
FSv2 uses different terminology from FSv1 and online floating. The key equivalences are:
| FSv2 | FSv1 / Online Equivalent |
| ----------------------------------------- | ------------------------------------------------------- |
| `registerUserToLicenseV2` | Activate , reserves a floating slot |
| `unregisterUserFromLicenseV2` | Deactivate, releases the slot |
| Re-registering an already-registered user | Periodic check-in, resets the floating timeout |
| `getLicenseById` | Check license status |
| `getLicenseUsers` | View active registrations (new in V2, no V1 equivalent) |
Are FSv1 endpoints available on a FSv2 server?
No. FSv1 and FSv2 are separate implementations. V1 endpoints are not available on the V2 server. The SDK handles this automatically based on the detected server version.
Where can I find the full FSv2 Java SDK API reference?
The documentation has been updated with the full API reference: [Floating Server V2 Docs](https://docs.licensespring.com/3EG9-floating-server-v2). A new version of the Java SDK with updated Floating Server V2 support is also available: [Java SDK v2.27.0 — February 10th, 2026](https://docs.licensespring.com/sdks/java#february-10th-2026-v2270).
How do I get started integrating FSv2 with the Java SDK?
FSv2 uses `ProxyFloatingService` and `ProxyConfiguration`. Below is a working starting point:
```java
ProxyConfiguration proxyConfiguration = ProxyConfiguration.builder()
.host("localhost")
.port(8080)
.proxyUser("admin")
.proxyPass("admin")
.product("")
.build();
ProxyFloatingService service = new ProxyFloatingService(proxyConfiguration);
// Fetch available licenses
List licenses = service.getLicenses();
LicenseData license = licenses.get(0);
Long licenseId = license.getId();
// Register a user to a license
RegisterUserToLicenseRequest req = RegisterUserToLicenseRequest.builder()
.email("")
.username("")
.build();
service.registerUserToLicenseV2(licenseId, req);
```
The key methods for managing licenses, users, features, and consumptions are:
* `getLicenses` fetch available licenses
* `registerUserToLicenseV2` / `unregisterUserFromLicenseV2` register or release a floating slot
* `registerFeatureForUserV2` / `unregisterFeatureForUserV2` manage feature access per user
* `addConsumptionToLicenseV2` / `addConsumptionToFeatureV2` record consumption
See the full API reference at [Floating Server V2 Docs](https://docs.licensespring.com/3EG9-floating-server-v2).
I get a "missing proxyCertPath in ProxyConfiguration" error. What does this mean?
FSv2 requires the Floating Server instance to be provisioned and the resulting certificate to be passed to the SDK. You must provision a Floating Server instance via the LicenseSpring Platform as described in the [Configuration & Provisioning guide](https://docs.licensespring.com/Floating-server-v2/configuration-and-provisioning), then provide the proxy certificate path in `ProxyConfiguration` as detailed in the [FSv2 SDK integration docs](https://docs.licensespring.com/3EG9-floating-server-v2#PEtqT).
Why does registering a floating slot fail when I pass only the license key?
FSv2 requires the server-side license ID, not just the license key. Registering using only a license key is a FSv1 behavior and is not supported in FSv2. Use `ProxyFloatingService::getLicenses` to retrieve available licenses with their server-side IDs, then pass the correct ID when registering.
Which C++ SDK functions are required when connecting to FSv2?
When using the C++ SDK with FSv2, you must:
* Set the Floating Server URL using `ExtendedOptions::setAlternateServiceURL`
* Provide the certificate chain using `ExtendedOptions::setCertificateChain` or `ExtendedOptions::setCertificateChainFromFile` the SDK verifies the chain and automatically extracts the public key from the leaf certificate
`ExtendedOptions::setAlternateKey` is **not** needed when connecting to FSv2.
What is the ServerPublicKey field in default.yaml and where does it come from?
The `ServerPublicKey` field can be left empty by default:
```yaml
ServerPublicKey: "" # default: LicenseSpring Prod public key
```
When left blank, the server automatically uses LicenseSpring's production public key. You only need to set this field if LicenseSpring has provided you with a custom public key for your deployment.
Does FSv2 support a custom port number?
Yes. Custom port configuration is supported from v2.3.0 onwards. Full details are available in the [Changelog](https://docs.licensespring.com/floating-server/floating-server-v2/changelog) and [Configuration & Provisioning](https://docs.licensespring.com/floating-server/floating-server-v2/configuration-and-provisioning) docs.
Does FSv2 support high-availability (HA) deployments?
Yes. HA support was introduced in Floating Server v2.3.0. Two deployment approaches are supported:
* **Kubernetes-based deployment** a fully containerized HA setup with multiple replicas and SDK-side load balancing, documented via Helm. See the [Helm Setup guide](https://docs.licensespring.com/floating-server/floating-server-v2/helm-setup).
* **Bare-metal deployment** supported with SDK adjustments; server and database provisioning must be handled by the customer's infrastructure team.
Note: FSv1 does not include high-availability support.
Does FSv2 have a Helm chart?
Yes, as of v2.3.0. Setup instructions are available in the [Helm Setup documentation](https://docs.licensespring.com/floating-server/floating-server-v2/helm-setup).
Is a native FSv2 executable available for macOS?
macOS support is available in terms of functionality but has not been officially published yet. In the meantime, customers can deploy FSv2 via Docker on macOS. An official macOS build will be announced when available.
Does FSv2 prevent duplicate deployments in containers or virtual machines?
A hardware key (YubiKey) is currently the supported way to prevent duplicate deployments in containerized or virtualized environments.
Do FSv2 sync operations count toward LicenseSpring API usage limits?
Sync and related operations between the **client application and the Floating Server** do not count toward API usage limits. Operations between the **Floating Server and LicenseSpring Cloud** do count.
Does Floating Cloud count toward API usage limits?
Yes. Floating Cloud operations such as license checks do count toward API usage limits.
Can I control or reduce how often FSv2 syncs with LicenseSpring Cloud?
Yes. Sync frequency is configurable via `SyncIntervalHours` and `SyncIntervalMinutes` in `default.yaml`. The total interval must be between 5 minutes and 24 hours.
To further reduce API calls on the client side, you can implement custom timing logic, for example, storing the timestamp of the last online license validation and only performing a fresh check after a chosen interval, or requiring an online check once per day using a custom field.
Can I add multiple licenses for the same product in FSv2?
Yes. FSv2 supports adding multiple licenses for the same product. This is a change from FSv1, where only one license per product was allowed.
Do deactivated licenses still appear in getAllLicenses and allow registration in FSv2?
This was a regression introduced in a recent FSv2 release. It has been resolved, deactivated licenses are now correctly excluded from `getAllLicenses` results and registration attempts against them return an error as expected. Ensure you are running the latest version of Floating Server v2.
What does the "Set certificate expiration" option control, and what happens when it expires?
The certificate expiration setting controls how long the issued server certificate remains valid. It does not affect the private key, which does not expire on its own.
When the certificate expires, the Floating Server will no longer authenticate successfully. To renew, submit a new CSR to obtain a new certificate, you can reuse the existing private key or generate a new one. Certificate expiry is independent of license terms and floating seat allocation; it only governs the server's authentication credential.
Can the FSv2 UI be accessed from a remote machine or another device on the network?
The Floating Server UI is designed to run on the local machine and is not intended for remote access. If you need to manage the server from another device, deploy via Docker or Kubernetes and access it through the appropriate network configuration. Remote access in versions before v2.3.0 was unreliable due to a hardcoded `localhost` URL in the frontend, this was resolved in v2.3.0.
Is there an end-of-life date for Floating Server V1?
No end-of-life date has been defined for FSv1. Support is currently limited to security patches and critical bug fixes. LicenseSpring strongly recommends migrating to FSv2.