# App Assets Source: https://docs.titanos.tv/app-assets-specifications To ensure proper display within the operating system, each application is required to provide a set of assets: icons, backgrounds and logo. ## Icons We request partners to provide two icon formats, each serving specific purposes: 1. **Main Icon** * Format: *JPG or PNG, **No transparency*** * Size: *1024x1024px.* * Usage: *This icon is used for displaying the application on the Home Screen.* 2. **App Store Icon** * Format: *JPG or PNG, **No transparency*** * Size: *Minimum of 960x540px.* * Usage: This icon is displayed on the Apps Page and in Search Results. **Note on the file size:** The size of each file should not exceed 10Mb.
## Logo To facilitate the possible promotion of your app, we request that you provide us with the logo on a transparent background. This logo could be used in the banners on the Home Screen and on the Apps Page, as well as on the App Detail Page. 1. **Requirements** * Format: *PNG* * Size: *Minimum height of 512px. The width depends on the logo dimensions.* * Maximum file size: *10MB* 2. **Design considerations** * The logo should appear clear and contrast well against a dark/black background. * Please crop all empty space around the logo; it should fit tightly inside its area without margins. ## Background In the latest version of the operating system, each application will have its own detailed page. To enhance the user experience, we request the provision of one to three images that will be used as the background for this page. If more than one image is provided, Titan will chose which one to use. Example of using Background in the interface 1. **Requirements** * Format: *JPG or PNG* * Size: *Minimum of FullHD (1920x1080px); ideally 4K (3840x2160px)* * Maximum file size: *10MB* 2. **Design considerations** * Avoid placing any important elements or text in the left half of the image. This area will be overlaid with the application's name and description, potentially obscuring it. * These images can represent either high quality screenshots of the application or specially designed artworks that reflects the app's theme. ## Screenshots In the current version of the operating system, we do not use and display application screenshots. However, for compatibility with earlier, unupdated devices released before 2022, we request developers to upload at least one screenshot. The maximum number of screenshots allowed is three. 1. **Requirements** * Format: *JPG or PNG* * Size: *Minimum of FullHD (1920x1080px); ideally 4K (3840x2160px)* * Maximum file size: *10MB* # FAST Channel Assets Source: https://docs.titanos.tv/channel-assets-specifications To ensure proper display within the operating system, each FAST channel is required to provide a set of assets: thumbnail, logo and background. ## Logo The Logo will be used in the future versions of Titan OS. It could also be used as a watermark. ### Requirements 1. Format: *White PNG with **transparent background*** 2. Size: *At least 640px on the longer side* 3. File size: **Should not exceed 1Mb** ### Design considerations * There should be no padding between the logo and the file boundaries — the logo should extend fully to the edges, regardless of its aspect ratio. No empty space around the edges allowed. * The logo must be white and contain no colour, but it could have semi-transparent white elements. * It is strongly recommended to use the full logo, including the channel name. The logo may appear alongside logos of other channels, so it should remain clear and easily identifiable. *** ## Thumbnail We request partners to provide the channel Thumbnail to be used in the EPG and search results. ### Requirements 1. Format: *JPG or PNG, **No transparency*** 2. Size: *At least 640x360px* 3. Aspect ratio: *16:9* 4. File size: ***Should not exceed 1Mb*** ### Design considerations * The best way to make the channel easily recognisable is to use a logo over a contrasting background. * Ensure the logo is large, clear and (optional) centred. * Don’t add any additional text or elements to the thumbnail.
*** ## Background The background image serves as a placeholder while the channel stream loads. It should reflect the channel’s theme subtly, without being overly distracting. ### Requirements 1. Format: *JPG or PNG, **No transparency*** 2. Size: ***Exactly** 1920x1080px ⚠️* 3. Aspect ratio: *16:9* 4. File size: ***Should not exceed 2Mb ⚠️*** ### Design considerations * Avoid adding any text or elements that might appear interactive or clickable to prevent user confusion. * Avoid using solid colour fills. If a single-colour background is necessary, consider applying a gradient or pattern to add visual depth.
# Cookies & Local Storage Source: https://docs.titanos.tv/cookies The TitanOS application environment provides standard web mechanisms for storing data on the client-side, such as user sessions, preferences, and application state. Our platform supports `Cookies` and `Local Storage`, behaving identically to a modern, secure web browser. This guide outlines how to use these standard web APIs within your application. ## LocalStorage This method is used for storing persistent client-side data, such as JWT tokens, user settings (e.g., language preference), or application state. Data stored in `LocalStorage` is specific to your app's origin and persists even after the TV is turned off and on again. * **Characteristics:** Persistent storage, larger capacity (typically 5-10 MB), data is not sent with every HTTP request. * **Use via:** Standard JavaScript `window.localStorage` API. JavaScript Example: ```javascript theme={null} // Save a JWT token to LocalStorage const jwtToken = 'your_auth_token_here'; localStorage.setItem('user_token', jwtToken); // Retrieve the token later const savedToken = localStorage.getItem('user_token'); if (savedToken) { console.log('User is authenticated!'); } // Remove the token (e.g., on logout) localStorage.removeItem('user_token'); ``` ## Cookies Cookies are also fully supported and work as they do in a standard web browser. They are primarily useful when your application's authentication model requires the browser to automatically send session identifiers with every API request to your backend. * **Characteristics:** Can have an expiration date, smaller capacity (approx. 4 KB), data is sent with every HTTP request to your domain. * **Use via:** Standard JavaScript `document.cookie` API or via `Set-Cookie` HTTP headers from your server. JavaScript Example: ```javascript theme={null} // Set a simple session cookie that expires in 1 day const expiryDate = new Date(); expiryDate.setDate(expiryDate.getDate() + 1); document.cookie = `session_id=abc123; expires=${expiryDate.toUTCString()}; path=/`; ``` ## Is there a preferable method to use? Both `LocalStorage` and `Cookies` are fully supported on the TitanOS platform, and the choice of which to use depends on your application's specific architecture and session management strategy. Your team should choose the mechanism that best fits your needs. However, for most modern client-side storage use cases on a Smart TV application, `LocalStorage` is generally the recommended method due to several key benefits: **Larger Storage Capacity:** `LocalStorage` offers a significantly larger storage capacity (typically 5-10 MB) compared to the 4 KB limit of cookies. This makes it ideal for caching application data, user profiles, or complex state information. **Better Performance:** Data stored in `LocalStorage` is not automatically sent with every HTTP request to your server. This reduces network overhead and can improve your application's overall performance, which is especially important on embedded devices. **Simpler API:** The JavaScript API for `LocalStorage` (`setItem()`, `getItem()`, `removeItem()`) is much cleaner and more straightforward to use than the manual string parsing required for managing document.cookie. In summary, while both methods are available, we recommend `LocalStorage` for most use cases, such as managing JWT authentication tokens or caching user preferences. `Cookies` remain a perfectly valid option for traditional server-managed sessions or when specific features like `HttpOnly` security are a requirement. ## Alternative Strategy: Server-Side Sessions While client-side storage is fully supported and often sufficient, some partners may opt for a server-side session management strategy. In this model, the application state is stored on the partner's backend servers and associated with a unique device identifier. TitanOS provides the Titan SDK through which your application can retrieve a unique `deviceId`. This ID can then be used to create and manage server-side sessions. This is a valid architectural choice that is fully enabled by our platform, but it is up to each application partner to decide if this model best fits their needs. # Debugging your app Source: https://docs.titanos.tv/debugging This guide provides step-by-step instructions for debugging applications on Titan OS. The process varies slightly depending on your TV manufacturer. ## Debbuging on Philips devices Ensure both your TV and PC are connected to the same network. Open the DevView app on your TV. If you're not familiar with DevView, please refer to the [how to test on your TV](https://docs.titanos.tv/devviewinstall) documentation. * Navigate to the Settings menu. * Toggle the "Enable Debug Mode" option to ON. Your TV is now ready for debugging. It should enable the debug mode on this device. From that point your device should becomes visible by chrome inspect. * Open Chrome on your PC and enter chrome://inspect/devices. * Check the "Discover network targets" option and click on "Configure." * Enter the TV's local IP address and port number (e.g., `:9222` or `:7001`). Some devices have the port fixed at `9222`, and some others `7001`. It's expected if only one of them works. * After configuration, Chrome will display the URLs opened on the TV. * Click "inspect" to open Chrome Devtools and debug the page loaded on the TV. ## Debbuging on Vestel devices For Vestel devices, debugging is enabled by default though port `4725`. You can connect to your TV directly without changing any settings in DevView. * Open Chrome on your PC and enter chrome://inspect/devices. * Check the "Discover network targets" option and click on "Configure." * Enter the TV's local IP address and port number (e.g., `:4725`). The port number is fixed at `4725`. * After configuration, Chrome will display the URLs opened on the TV. * Click "inspect" to open Chrome Devtools and debug the page loaded on the TV. ## Debugging on Philips 2020-2022 For partners who owns Philips devices from 2020 to 2022, these devices require a special "debug firmware" to enable debugging. This process involves a "package burn" to flash a new firmware version onto the device. * To get started, you'll need to contact our support team ([apponboarding@titanos.tv](mailto:apponboarding@titanos.tv)) to obtain the correct debug firmware file for your TV model. * For step-by-step instructions on how to install debug firmware, please see our [Firmware Installation Guide](). Once the firmware is installed, you can proceed to debug it in your chrome browser by doing the following steps: * Open Chrome on your PC and enter chrome://inspect/devices. * Check the "Discover network targets" option and click on "Configure." * Enter the TV's local IP address and port number (e.g., `:7001`). The port number for Philips from 2020 to 2022 is fixed at `7001`. * After configuration, Chrome will display the URLs opened on the TV. * Click "inspect" to open Chrome Devtools and debug the page loaded on the TV. ## Chromium 135+ Compatibility Note Starting with Chrome version 135 and newer, developers may experience issues where the Network Throttling (under the Network tab) and Local Storage (under the Application tab) in DevTools, appear completely empty when inspecting smart TV applications. This is a known behavior with modern Chromium remote debugging across various TV brands. If your workflow heavily relies on network performance simulation or inspecting local storage data, please utilize the following workarounds to remain unblocked: **Downloading a Compatible Chromium Version** If you strictly require the visual Network Throttling panel or the graphical Local Storage UI, you must use a version of Chrome older than version 135: * Open your terminal or command prompt. * Navigate to the folder where you want to download the browser. * Run the following command to download and extract Chrome version 134: ```bash theme={null} npx @puppeteer/browsers install chrome@134 ``` **Note:** You can replace 134 with any preferred older version stable for your ecosystem. Find more details on how to download other chromium versions at the [Chromium Org: Chrome for testing link](https://www.chromium.org/getting-involved/download-chromium/#chrome-for-testing). * Open the downloaded executable file inside the newly created folder to launch your dedicated debugging browser. **Managing Local Storage via the Console** Alternatively, if you are using Chrome 135+ and only need to read, write, or inspect local storage properties, you can interact with it directly via the Console tab using standard JavaScript methods: View all stored data: ```javascript theme={null} console.table(localStorage); ``` Retrieve a specific value: ```javascript theme={null} localStorage.getItem('KeyName'); ``` Set or update a value: ```javascript theme={null} localStorage.setItem('KeyName', 'Value'); ``` Learn how to test your app using DevView. Learn how to learn how install or update the firmware version. # Device allowlisting Source: https://docs.titanos.tv/device-allowlisting Allowlisting devices is a strategy used to segment, whitelist or block an app for specific devices, allowing the application to adjust its behavior based on the brand or model that the app is running on. This serves several purposes: * Enabling Titan OS devices access to the application. * Creating a restricted allowlist of devices permitted to run the app while blocking unauthorized brands or specific models. * Manually defining playback rules to serve content based on hardware capabilities (e.g., restricting UHD playback on 2K-only devices). * Blocking the app in specific regions (e.g., when the contract is limited to LATAM devices). * Displaying a "Not Available on this device" message for specific device segments. ## Identifying Titan OS Devices To whitelist devices, we recommend using the Titan SDK. The library exposes properties to validate the operating system and the specific platform (model) on which the app is running on. If your architecture requires the SDK to be imported dynamically, you can verify if a device is running Titan OS by checking the User Agent. This approach is common for cross-platform apps deployed across multiple TV brands. For more details, please refer to [Detecting Titan OS and Saphi](/user-agents-specifications#detecting-titan-os-and-saphi). **Note:** Checking the User Agent is sufficient if your whitelist allows any Titan OS-powered device to access the application. ## Segmenting Device Groups Once the SDK is imported, use the Product.platform property (Reference: [Titan SDK Dictionary](/titan-sdk#dictionary)) to identify the specific hardware platform. Here's an example on how you can use it: ```javascript theme={null} const deviceInfo = await titanSDK.deviceInfo.getDeviceInfo(); const platform = deviceInfo.Product.platform; const allowedPlatforms = ['TPM268L', 'TPM266L', 'TPM267L']; if (allowedPlatforms.includes(platform)) { // Proceed to home page } else { // Display a message that the device is not supported } ``` The following table is a reference of platforms for you to use in your list. If you need more details about these devies, please refer to the [Device Specifications](/platform-versions) page. | Device | Region | Platform | | :---------------------- | :----- | :------- | | Philips 2026 MT9676 2K | LATAM | TPM268L | | Philips 2026 MT9676 4K | EU | TPM266E | | Philips 2026 MT9676 4K | LATAM | TPM266L | | Philips 2026 MT9620 4K | EU | TPM267E | | Philips 2026 MT9620 4K | LATAM | TPM267L | | Philips 2026 NT690E | EU | TPN266E | | Philips 2026 NT676 | EU | TPN258E | | Sharp 2026 NT690 2K | EU | TSN257E | | Philips 2025 NT690 2K | LATAM | TPM256L | | AOC 2025 NT690 2K | LATAM | TAM256L | | Philips 2025 NT690 4K | LATAM | TPM257L | | Philips 2025 NT690 2K | EU | TPN257E | | Philips 2025 NT690 4K | EU | TPN256E | | Philips 2025 NT676 4K | EU | TPN258E | | JVC 2025 MB190 4K | EU | MB190 | | JVC 2025 MB191 2K | EU | MB191 | | JVC 2025 NT690 2K | EU | TJN257E | | Philips 2024 NVT690 2K | EU | TPN247E | | Philips 2024 NVT690 2K | LATAM | TPN247L | | Philips 2024 NVT690 4K | EU | TPN246E | | Philips 2024 NVT690 4K | LATAM | TPN246L | | AOC 2024 NVT690 4K | LATAM | TAN246L | | Philips 2024 NVT676 4K | EU | TPN248E | | Philips 2024 NVT676 4K | LATAM | TPN248L | | Philips 2023 NVT690 2K | EU | TPN237E | | Philips 2023 NVT690 4K | EU | TPN236E | | Philips 2023 NVT676 4K | EU | TPN238E | | Philips 2022 NVT690 4K | EU | TPN226E | | Philips 2021 NVT671 4K | EU | TPN216E | | Philips 2020 MTK9288 2K | EU | TPM207E | | Philips 2020 MTK9288 2K | LATAM | TPM207L | | Philips 2020 NVT671 4K | EU | TPN206E | ## Whitelisting via User Agent As mentioned at the [first topic](/device-allowlisting#identifying-titan-os-devices), whitelisting via User Agent is recommended when you want to allow any Titan OS-powered device to open your app. If that's the case, please refer to the [Detecting Titan OS and Saphi](/user-agents-specifications#detecting-titan-os-and-saphi) topic from the User Agents page. # DeviceInfo API [Deprecated] Source: https://docs.titanos.tv/deviceinfoapi The Device Info API is DEPRECATED and has been replaced by the [Titan SDK](https://docs.titanos.tv/titan-sdk). This API offers essential services and features for Titan OS through JavaScript functions tailored for accessing TV-specific features and capabilities. With the DeviceInfoAPI, not only do you gain enhanced compatibility, but you can also conveniently access most DeviceAPI functions directly from your development computer. The values returned by the SDK on computer browsers may differ from those on TVs. In most cases, running on computer browsers will return a string with the value of `"unknown"`. Please consider this variation when developing and testing your applications across different platforms. You can integrate this script into your app. Ensure that you're using the latest script to avoid potential compatibility issues. We recommend linking directly to the our CDN URL. To access the device info, you first must add an external JS file which will allow you to read them via an external object. ```javascript theme={null} ``` After the script is loaded, it will create a global object named TitanSDK on the window object. You can access it directly in your JavaScript files to start using the SDK's functionalities. ```javascript theme={null} // The TitanSDK variable is now globally available const titanSDK = TitanSDK; console.log('Titan SDK has been loaded:', titanSDK); ``` ## Usage Example Here is a practical example of how to fetch device information using the CDN method. Note that, just like the npm version, function calls are asynchronous. ```javascript theme={null} document.addEventListener('DOMContentLoaded', async () => { try { // 1. Access the global variable const titanSDK = TitanSDK; // 2. Call the function to get device information const deviceInfo = await titanSDK.deviceInfo.getDeviceInfo(); // 3. Log the information to the console console.log('TV Brand:', deviceInfo.Product.brand); console.log('Model Year:', deviceInfo.Product.year); } catch (error) { console.error('Failed to use the Titan SDK:', error); } }); ``` ## Next Steps View the main documentation and the recommended npm installation method. Consult the detailed guide for migrating from the old DeviceInfo API. # How to Use the Titan SDK with TypeScript Source: https://docs.titanos.tv/typescript The Titan SDK is built in JavaScript and delivered via a CDN, meaning it's not a standard npm module. As a result, your modern TypeScript project won't automatically have access to its type definitions. To get the benefits of autocompletion and type-checking, you'll need to manually integrate the type declaration file (`.d.ts`) we provide. ## Integrating the TitanSDK types Here is a suggestion on how to integrate our type declarations into your project. **1. Download the .d.ts File** First, get the declaration file and save it locally. You can do this by opening the CDN URL in your browser and saving the content or by using a command-line tool like curl. **Note:** The interface should not change, but sometimes we might add new properties to the SDK. The declaration file (`d.ts`) is updated automatically once we add something new to the interface. Example URL: [https://sdk.titanos.tv/sdk/sdk.d.ts](https://sdk.titanos.tv/sdk/sdk.d.ts) Recommended Location: Create a new folder, src/types, and save the file there. This keeps your project organized and separate from your main code. Your project structure should look like this after this step: ``` ├ /your-project ├─└─ /src ├────└── /types ├────└───└── /sdk.d.ts <-- The downloaded file ├────└── /App.tsx ├─└── /tsconfig.json ``` **2. Declare the Global Variable** The library's main variable (TitanSDK) is available on the global window object when the script is loaded via the CDN. However, TypeScript needs to be told about this to avoid errors. You must declare that this global variable exists and what its type is. Create a new file, src/types/globals.d.ts, and add the following code. This file is a special declaration file that tells TypeScript to "merge" your new type definitions with the built-in window object. If you already have a declaration file, just post this code there. ```TypeScript theme={null} // src/types/globals.d.ts // Import the type definition from the sdk.d.ts file you just saved. import { TitanSDK } from './sdk.d.ts'; // Use declaration merging to add the TitanSDK property to the global Window interface. declare global { interface Window { TitanSDK: TitanSDK; } } // This empty export is necessary to make this file a module // and prevent it from being treated as a global script. export {}; ``` **3. Use the Types in Your Code** Once the global variable is declared, you can use `window.TitanSDK` directly in your TypeScript or JavaScript files. Your code editor will now provide IntelliSense, autocompletion, and type-checking for all the functions and properties defined in the .d.ts file. You no longer need to import the types or variables; TypeScript automatically links them based on their names. TypeScript in action in a React Component: ## Real-World Examples & Resources To see these it in action and understand more about the integration on our GitHub examples repository: * **[Example: Using Typescrip](https://github.com/Titan-OS/titan-sdk-examples/tree/master/7-example-typescript)**: A simple carousel with TTS using React + Vite + Typescript. We are committed to receiving feedback and continuously improving our documentation and examples. ## Next steps Introduction to the new TitanSDK Learn how to migrate from the DeviceInfo API to the new TitanSDK # Updates Source: https://docs.titanos.tv/updates ## Deprecation of MSS Support Titan OS will end support for MSS across TV platforms by June 30, 2026. This change aligns with current industry standards, where HLS and MPEG-DASH (ideally CMAF-packaged) are the supported and recommended streaming formats across Connected TV platforms. What this means for you: If your app or content delivery currently relies on MSS, you must migrate to HLS and/or MPEG-DASH to ensure continued compatibility with Titan OS devices. MSS should be considered a legacy format and should not be used for new deployments or updates. ## New Titan SDK changelog section Keep your Titan SDK updated! We are constantly improving the it. If you are unable to upgrade immediately due to internal versioning policies, please monitor the [Titan SDK Changelog](/sdk-changelog) to stay informed about essential updates and compatibility fixes. ## Managing Cookies and Local Storage We've published a new documentation page: "Managing Cookies and Local Storage." This has been a frequent question from our partners, and this new guide clarifies how to handle client-side storage and session management on the TitanOS platform using standard web APIs. You can find the new page here: [Cookies and Local Storage](/cookies) ## Titan SDK is Now on npm! To support modern development workflows, the Titan SDK is now officially available as an npm package. This change makes it easier to integrate and manage the SDK in your applications. Key advantages: **Dependency Versioning:** You can now lock the SDK to a specific version in your package.json, ensuring stable and predictable builds. **Modern libraries:** Seamlessly integrate the SDK with bundlers like Vite, Webpack, and other modern development tools. **TypeScript:** The package comes with bundled type definitions for a great developer experience with autocompletion and type safety. Our documentation has been updated to reflect this new, recommended approach. Check out the [Get Started](/titan-sdk) guide to learn more. ## Technical documentation refresh We’ve made a major refresh of our Titan OS technical docs **Highlights:** * **Device capabilities:** Expanded details to help your app run better across devices * **User agents:** Clarified formats and detection guidance * **Titan SDK:** New SDK replacing the Device Info API, with a migration guide and best-practice use cases * **Media specifications:** Updated audio/video, DRM, and streaming requirements * **Testing on devices:** Updated guidance for testing across brands and manufacturers * **Issues & troubleshooting:** Consolidated common issues and fixes * **JVC 2025 devices:** Added device and support details We continuously update the documentation and welcome your feedback. Please send suggestions or report gaps to [apponboarding@titanos.tv](mailto:apponboarding@titanos.tv). ## New Titan SDK In the coming weeks, Titan OS is pleased to announce the launch of the Titan SDK, a new and improved library that will replace the current Device Info API script. The new SDK will offer extended functionality, including: * Device capabilities. * Accessibility settings (e.g. text-to-speech, text magnification). * App control features (including app-to-app linking). * Most up-to-date features and support to upcoming Titan OS devices from new manufacturers. This change will require changing the current Device Info script to the new SDK in the future, so make sure you have this change planned. 👉 Important: The new Titan SDK is not yet available, so no action is needed at this time! We will notify you once it’s officially released in the coming weeks, along with clear instructions on how to update. If you don't know what Device Info is, we suggest you to read the following topic: 🔗 [https://docs.titanos.tv/deviceinfoapi](https://docs.titanos.tv/deviceinfoapi) If you’re interested in testing the beta version, feel free to reach out. Let us know if you have any questions in the meantime. # User Agents Source: https://docs.titanos.tv/user-agents-specifications A User Agent (UA) is a text string automatically sent by the browser to web servers. In general, it identifies the browser, device type, and operating system. For Titan OS, some developers may choose using the User Agent as a strategy to perform some logics before importing the Titan SDK, such as: * Applying device specific logic (for example, whitelisting support for certain models) * Performing a quick check if the device is running Titan OS before loading the SDK * Fallback for the TitanSDK for values such as Firmware version, Model and Year. The User Agent provides information such as: * If it's a Titan OS device * Browser and engine version * Device model and platform * Firmware version and release year We only recommend the usage of the User Agent to perform some quick logics if needed, similar to the strategies listed above. It depends on your app architecture and it's up to the engineer to determine if it would be helpful to improve your app performance. For example, a common scenario is an application that runs on multiple operating systems. In that case, it's a valid strategy to check if the app is running on Titan OS before importing the Titan SDK. However, if the app is dedicated to Titan OS, this check is not needed. To conclude, the usage of the User Agent is recommended only if it improves somehow the performance of your app. For retrieving specific information about the device, such as the model and firmare version, use the Titan SDK instead. ## User Agent Structure User Agents are structured but not static, it means that its values may vary depending on the platform, model, or firmware version. For this reason, applications should extract only the relevant parts (for example: if it's a Titan OS and, if needed, the firmware or model) instead of using the full string as an identifier. Each device has a User Agent that follows a consistent structure, although individual fields differ. Below are examples showing how User Agents are structured for different manufacturers: ### Philips devices ### JVC devices These images illustrate which parts of the User Agent represent the Operating System, browser version, platform, model, Titan OS version, and other details. ### Philips devices (2020–2022) Some Philips models released between 2020 and 2022 run an OS called Saphi, identified as WhaleTV/ or SmartTvA/ in the User Agent. For example: `... TV_NT72690_2022/... WhaleTV/2.0 ...` `... TV_NT72671_2021/... SmartTvA/5.0.0 ...` These devices are not Titan OS, but they are maintained by Titan OS and are fully supported by the Titan SDK. If your application supports Saphi, you can detect these devices by checking for the presence of WhaleTV/ or SmartTvA/ in the User Agent. ## Detecting Titan OS and Saphi The presence of `TitanOS/` in the User Agent always indicates a Titan OS device. The presence of `WhaleTV/` or `SmartTvA/` indicates a Saphi device (2020–2022 Philips). Example: ```javascript theme={null} function detectOS(ua) { if (ua.includes("TitanOS/")) { return "Titan OS"; } if (ua.includes("WhaleTV/") || ua.includes("SmartTvA/")) { return "Saphi (WhaleTV)"; } return "Other"; } ``` ## Extracting Values Programmatically The Titan SDK is the recommended way to retrieve device information such as platform, model, or Titan OS version. It is actively maintained and tested to ensure stability across devices and firmware versions. In some situations, developers also choose to parse the User Agent directly as a lightweight alternative. This can be useful when: * Performing a quick check if the device is running Titan OS before loading the SDK * Applying device specific logic (for example, whitelisting support for certain models) **⚠️ Note:** Do not hardcode or whitelist full User Agent strings. Always parse only the fields you need. **Philips Example** UA sample (2025, NT690 4K): ``` Mozilla/5.0 (Linux armv7l) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.4147.62 Safari/537.36 OPR/46.0.2207.0 OMI/4.24, TV_NT72690_2025_4K / (Philips, , wired) CE-HTML/1.0 NETTV/4.6.0.8 SignOn/2.0 SmartTvA/5.0.0 TitanOS/3.0 en Ginga ``` ```javascript theme={null} function parsePhilipsUA(ua) { return { OS: (ua.match(/\b(TitanOS)\b/) || [])[1], // e.g. "TitanOS" brand: (ua.match(/\((Philips)[.,;]/i) || [])[1], // e.g. "Philips" model: (ua.match(/TV_([A-Za-z0-9_]+)/) || [])[1], // e.g. "MT9676_2025_4K" year: (ua.match(/TV_[A-Za-z0-9]+_([0-9]{4})/) || [])[1], // e.g. "2025" resolution: (ua.match(/TV_[A-Za-z0-9]+_[0-9]{4}_([0-9A-Za-z]+)/) || [])[1], // e.g. "4K" }; } parsePhilipsUA(navigator.userAgent); ``` Expected result: ```javascript theme={null} {OS: 'TitanOS', brand: 'Philips', model: 'NT72690_2025_4K', year: '2025', resolution: '4K'} ``` **JVC Example** UA sample (2025, Vestel MB190): ``` Mozilla/5.0 (Linux ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.6261.128 Safari/537.36 OMI/4.24.3.93.MIKE.227 Model/Vestel-MB190 VSTVB MB100 FVC/9.0 (VESTEL; MB190; ) HbbTV/1.7.1 (+DRM; VESTEL; MB190; 0.9.0.0; ; _TV__2025;) TitanOS/3.0 (Vestel MB190 VESTEL) SmartTvA/3.0.0 ``` ```javascript theme={null} function parseVestelJVC_UA(ua) { return { OS: (ua.match(/\b(TitanOS)\b/) || [])[1], // e.g. "TitanOS" brand: (ua.match(/\(([A-Za-z]+);/) || [])[1], // e.g. "VESTEL" ou "JVC" model: (ua.match(/\(.*;\s*([A-Za-z0-9-]+);/) || [])[1], // e.g. "MB190" year: (ua.match(/_TV__([0-9]{4});/) || [])[1], // e.g. "2025" }; } parseVestelJVC_UA(navigator.userAgent); ``` Expected result: ```javascript theme={null} {OS: 'TitanOS', brand: 'VESTEL', model: 'MB190', year: '2025'} ``` Recommended practices: * Parse only the fields you need * Use the Titan SDK whenever full and reliable device information is required * Use User Agent parsing mainly as a first filter or fallback * The examples provided at this page are just for context. Prefer to create or adapt these to fit your specific needs. ## Platform Reference by Year Titan OS platforms evolve each year. At the [Device Specifications](https://docs.titanos.tv/device-specifications) page you the reference of platforms used by release year. Note that, as mentioned in the [topic](/user-agents-specifications#philips-devices-2020–2022), Philips devices have a different OS name for old devices (2020-2022).