51Degrees API Documentation  4.5

Search

Documentation

• Device Detection
• Device Detection Quick Start

Device Detection Quick Start

Getting Started with Device Detection🔗

51Degrees Device Detection offers two integration options. Each has different benefits to match your needs:

Choose Your Integration🔗

Cloud Service {#cloud-integration}**Best for:** Quick setup, minimal infrastructure, cost-effective scaling🔗

Benefits:

• No setup needed - No data files or local infrastructure required
• Always updated - Latest device data without manual updates
• Minimal resources - Very low CPU/RAM usage on your servers
• Pay-as-you-go - Cost scales with usage
• Global availability - Multiple data centers for low latency

Things to consider:

• Network dependency - Requires internet connectivity and handles latency (typically 10-50ms)
• External service - Detection processing occurs on 51Degrees infrastructure

Authentication: Requires a Resource Key

---

On-premise Deployment {#On-premise-integration}**Best for:** High-performance, privacy-sensitive, or offline environments🔗

Benefits:

• Low latency - Microseconds per detection when the data file is held in memory, with no network call
• Complete privacy - All processing stays within your infrastructure
• High throughput - Over 1 million detections per second on an eight-core AWS Graviton3 instance, with the data file in memory (measured results)
• Fast startup - Loads the data file into memory and is ready to detect in under 150 milliseconds on the same Graviton3 instance, which matters most where servers start and stop as demand changes
• Offline capable - No internet dependency for detection
• Full control - Customize update schedules and deployment architecture

Things to consider:

• Setup required - Initial configuration and data file management
• Resource usage - Uses local CPU/RAM (optimized but measurable)
• Update management - Periodic data file updates needed for latest devices (automatic updates available)

Licensing: Requires a License Key

---

Which Integration Should I Choose?🔗

Use Case	Recommended	Why
Prototyping & Development	Cloud	Fastest setup, no infrastructure overhead
Low-volume Production	Cloud	Cost-effective, automatic updates
High-traffic Web Servers	On-premise	Maximum performance, cost efficiency at scale
Real-time Applications	On-premise	Microsecond latency requirements
Edge/CDN Integration	On-premise	Offline capability, minimal latency
Privacy-sensitive Applications	On-premise	Data never leaves your infrastructure
Variable Traffic Patterns	Cloud	Pay-as-you-go scaling

---

Enhanced Accuracy Options🔗

For more accurate results (especially for identifying specific iPhone/iPad models), consider enabling client-side evidence collection.

---

Language-Specific Integration🔗

Most programming languages support both integration models. Select your language below for detailed setup instructions:

C C++ C# Java Node.js PHP Python Varnish Nginx Go Rust

Select a language.

C does not have a Pipeline implementation or the ability to use the cloud-based version of Device Detection. To get started with C device detection On-premise:

1. Clone the GitHub repository.
2. Ensure you have Git LFS installed. The device data files are large binary files that can cause problems if stored in a Git repository directly, so Git LFS is used.
3. Ensure all submodules are checked out by running git submodule update --init --recursive in the repository.
4. Follow the installation instructions to get set up with the project.
5. Follow the linked example here: Getting Started.
6. (optional) Obtain a License Key by purchasing a subscription and download a data file with access to more devices and properties, see our pricing page for details.

C++ does not have a Pipeline implementation or the ability to use the cloud-based version of Device Detection. To get started with C++ device detection On-premise:

1. Clone the GitHub repository.
2. Ensure you have Git LFS installed. The device data files are large binary files that can cause problems if stored in a Git repository directly, so Git LFS is used.
3. Ensure all submodules are checked out by running git submodule update --init --recursive in the repository.
4. Follow the installation instructions to get set up with the project.
5. Follow the linked example here: Getting Started.
6. (optional) Obtain a License Key by purchasing a subscription and download a data file with access to more devices and properties, see our pricing page for details.

Standalone pipeline / off-line processing🔗

1. Install the FiftyOne.DeviceDetection package via Nuget.
2. Follow the appropriate example from the options below:
   
   • Cloud Example - Negligible processing and memory overhead but slower due to Internet latency.
   • On-premise Example - Device detection processing is performed locally using a data file that must be kept updated.

ASP.NET Core integration.🔗

1. Install the FiftyOne.DeviceDetection and FiftyOne.Pipeline.Web packages via Nuget.
2. Follow the web example to add the Pipeline middleware.
3. Configure the pipeline using the configuration from the appropriate example from the options below:
   • Cloud Example - Negligible processing and memory overhead but slower due to Internet latency.
   • On-premise Example - Device detection processing is performed locally using a data file that must be kept updated.
4. (optional) Configure client-side evidence to get better results. Particularly for iPhone/iPad.

Standalone pipeline / off-line processing🔗

1. Install the com.51degrees.pipeline.device-detection package via Maven.
2. Follow the appropriate example from the options below:
   • Cloud Example - Negligible processing and memory overhead but slower due to Internet latency.
   • On-premise Example - Device detection processing is performed locally using a data file that must be kept updated.
     

Web servlet integration.🔗

1. Install the com.51degrees.device-detection and com.51degrees.pipeline.web packages via Maven.
2. Follow the servlet example to add the Pipeline filter.
3. Configure the pipeline using the configuration from the appropriate example from the options below:
   • Cloud Example - Negligible processing and memory overhead but slower due to Internet latency.
   • On-premise Example - Device detection processing is performed locally using a data file that must be kept updated.
4. (optional) Configure client-side evidence to get better results. Particularly for iPhone/iPad.

Spring MVC integration.🔗

1. Install the com.51degrees.device-detection and com.51degrees.pipeline.web packages via Maven.
2. Follow the Spring MVC example to add the Pipeline filter.
3. Configure the pipeline using the configuration from the appropriate example from the options below:
   • Cloud Example - Negligible processing and memory overhead but slower due to Internet latency.
   • On-premise Example - Device detection processing is performed locally using a data file that must be kept updated.
4. (optional) Configure client-side evidence to get better results. Particularly for iPhone/iPad.

1. Install the fiftyone.devicedetection package from NPM.
2. Follow the appropriate example from the options below:
   
   • Cloud Example - Negligible processing and memory overhead but slower due to Internet latency.
   • On-premise Example - Device detection processing is performed locally using a data file that must be kept updated.

Cloud🔗

This implementation of device detection makes use of 51Degrees' Cloud Service. In PHP, the cloud version is much easier to work with than the On-premise implementation as well as having much lower memory and CPU requirements. However, it is slower due to Internet latency. If you want faster detections, you should consider On-premise.

1. Install the 51degrees/fiftyone.devicedetection package using Composer.
2. Follow the Cloud Example.

On-premise🔗

Device detection processing is performed locally using a data file that must be kept updated. Due to the restrictions imposed by Composer and Packagist, we cannot supply the On-premise Engines through the usual package management ecosystem. Instead, you'll need to clone the repository from GitHub and follow the instructions there in order to build and use the On-premise implementation.

1. Install the fiftyone_devicedetection package from PyPI.
2. Follow the appropriate example from the options below:
   
   • Cloud Example - Negligible processing and memory overhead but slower due to Internet latency.
   • On-premise Example - Device detection processing is performed locally using a data file that must be kept updated.

Varnish does not have a Pipeline implementation or the ability to use the cloud-based version of Device Detection. To get started with Varnish device detection On-premise:

1. Clone the GitHub repository.
2. Ensure you have Git LFS installed. The device data files are large binary files that can cause problems if stored in a Git repository directly, so Git LFS is used.
3. Ensure all submodules are checked out by running git submodule update --init --recursive in the repository.
4. Follow the installation instructions to get set up with the project.
5. Follow the linked example here: Getting Started.
6. (optional) Obtain a License Key by purchasing a subscription and download a data file with access to more devices and properties, see our pricing page for details.

Nginx does not have a Pipeline implementation or the ability to use the cloud-based version of Device Detection. To get started with Nginx device detection On-premise:

1. Clone the GitHub repository.
2. Ensure you have Git LFS installed. The device data files are large binary files that can cause problems if stored in a Git repository directly, so Git LFS is used.
3. Ensure all submodules are checked out by running git submodule update --init --recursive in the repository.
4. Follow the installation instructions to get set up with the project.
5. Follow the linked example here: Getting Started.
6. (optional) Obtain a License Key by purchasing a subscription and download a data file with access to more devices and properties, see our pricing page for details.

Currently, we have a light set of device detection features for Go users to try and evaluate the capability of 51Degrees device detection. Documentation for Go can be found via the following GitHub repositories: device-detection-go, device-detection-examples-go. To get started with Go device detection On-premise:

1. Clone the GitHub repository.
2. Ensure you have Git LFS installed. The device data files are large binary files that can cause problems if stored in a Git repository directly, so Git LFS is used.
3. Ensure all submodules are checked out by running git submodule update --init --recursive in the repository.
4. Follow the installation instructions to get set up with the project.
5. Follow the linked example here: Getting Started.
6. (optional) Obtain a License Key by purchasing a subscription and download a data file with access to more devices and properties, see our pricing page for details.

Standalone pipeline / off-line processing🔗

1. Add the fiftyone-device-detection crate from crates.io (for example with cargo add fiftyone-device-detection).
2. Follow the appropriate example from the options below:
   • Cloud Example - Negligible processing and memory overhead but slower due to Internet latency.
   • On-premise Example - Device detection processing is performed locally using a data file that must be kept updated.

Web integration (axum)🔗

1. Add the fiftyone-device-detection, fiftyone-pipeline-web and fiftyone-pipeline-web-axum crates.
2. Follow the web example to mount the pipeline in an axum application.

Have a data or code question? Get in touch and explore subscription options.