# io.Connect APIs and Use Case examples

**URL:** <https://community.interop.io/t/io-connect-apis-and-use-case-examples/627>\
**Category:** io.Connect Desktop\
**Tags:** tech-blog\
**Created:** [October 15, 2026, 1:36pm UTC](https://community.interop.io/t/io-connect-apis-and-use-case-examples/627 "2026-10-15T13:36:42Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![toni.petrov](https://yyz2.discourse-cdn.com/flex028/user_avatar/community.interop.io/toni.petrov/32/17_2.png) [@toni.petrov](https://community.interop.io/u/toni.petrov)\
**Post date:** [October 15, 2026, 1:36pm UTC](https://community.interop.io/t/io-connect-apis-and-use-case-examples/627/1 "2026-10-15T13:36:42Z")

</div>

io.Connect offers a broad range of APIs, accessible via the global io object in a client app (or corresponding library in .NET, Java, etc.), enabling everything from app lifecycle control to data sharing. Below is a summary of the major API domains and their use cases:

| API/ Feature | Description & Use Case |
| --- | --- |
| Windows Management (io.windows) | Open, find, inspect, and control individual io.Connect windows and window groups. Apps can manage bounds, focus, visibility, title, size, position, state, and lifecycle.   
**Use case:** opening a pop-out tool window on a specific monitor or activating an existing window. |
| Workspaces (io.workspaces) | Compose multiple app windows into a unified interface inside Workspace Frames. Windows can be arranged in rows, columns, groups, and tabs, and the structure can be created, restored, and modified dynamically.   
**Use case:** combining a watchlist, chart, news feed, and trade ticket into a single multi-app desktop experience. |
| Layouts (io.layouts) | Save and restore application arrangements and state. Layout types include Global layouts, App Default layouts, and Workspace layouts.   
**Use case:** restoring a user’s complete working environment or reopening an app with its previously saved state. |
| Notifications (io.notifications) | Unified desktop notifications system. Apps can raise notifications via the platform, which aggregates and displays them in a consistent way to the user.  
**Use case:** instead of each app spawning its own OS notification, io.Connect channels them into a single notification center. For example, a trading alert from one app and a chat message from another can both appear in a unified notification UI provided by the platform. Notifications can include action buttons that launch Intents or apps, creating actionable alerts. |
| Search (io.search) | Provide federated search through a provider-and-client model. Providers query custom data sources and return results asynchronously; clients initiate and cancel searches and receive results in batches.   
**Use case:** searching CRM records, instruments, research, files, and internal knowledge from one interface. |
| FDC3 (fdc3) | Provide standards-based interoperability for financial applications, including contexts, Channels, Intents, and App Directory integration. **Use case:** allowing an io.Connect app to participate in FDC3 workflows with applications from other vendors. |
| App Management (io.apps) | Manage registered app definitions, dynamically defined apps, running instances, and the current app instance.   
**Use case:** implementing a launcher, starting apps with context, monitoring instance lifecycles, or orchestrating a multi-app workflow. |
| App Preferences (io.prefs) | Store persistent, user-specific settings associated with an app.   
**Use case:** remembering filters, selected views, display options, feature settings, or user-defined defaults. |
| Modals (io.modals) | Display platform-consistent alerts and interactive dialogs. **Use case:** requesting confirmation, collecting a structured response, or presenting a blocking warning without implementing a separate modal system in every app. |
| Hotkeys (io.hotkeys) | Register global keyboard shortcuts (hotkeys) that trigger functions in your app.   
**Use case:** define a hotkey (e.g. Ctrl+Alt+N) to open a new note in your note-taking app, accessible even when the app is not focused The Hotkeys API ensures no conflict and that hotkeys work across the integrated desktop. |
| Interception (io.interception) | Low-level hooks into platform operations. This lets you intercept certain actions (like window creation, app launch, etc.) and run custom code before or after the platform’s default behaviour.   
**Use case:** applying governance or filtering rules when resolving and raising Intents e.g. inject authentication logic when a certain app starts. |
| Logging (io.logger) | Write structured platform and application logs into the io.Connect logging system and create named sub-loggers for individual modules or services.   
**Use case:** troubleshooting an integration workflow or correlating application behavior with platform logs. |
| Platform Lifecycle (io.platform) | Control and observe the lifecycle of io.Connect Desktop. Apps can initiate restart or shutdown operations and respond when the platform begins shutting down. **Use case:** saving state, completing cleanup, or temporarily preventing shutdown while critical work is unfinished. |
| Shared Contexts (io.contexts) | Share stateful data between apps through named context objects. Any app can update or subscribe to a shared context by name.  
**Use case:** synchronizing a selected customer, security, portfolio, or form state across multiple apps. |
| Channels (io.channels) | Create user- or app-managed linking groups backed by shared Channel data (often represented by color). Apps can join and leave Channels, publish data, subscribe to changes, and dynamically add or remove  
**Use case** : dynamic grouping of apps - e.g. user links two (io.channels)charts by putting them on the Blue channel so they show the same symbol; switching one chart’s symbol updates the other. Useful for user-managed context syncing. |
| Intents (io.intents) | Action-based integration allowing apps to raise intents (requests) for other apps to handle. Handlers for Intents can be declared in app config or at runtime.   
**Use case:** launching or activating the appropriate app to handle a user’s request - e.g. raise an OpenClientProfile intent from a CRM list app to open the full client profile in another app. The Intents API handles discovering handlers, presenting the resolver UI if multiple choices, and launching the target. This enables cross-app workflows with minimal coupling |
| Interop Methods(io.interop) | Service-oriented RPC (Remote Procedure Call) and streaming between apps. Apps can register methods (with names and defined input/ output) and other apps can invoke those methods, as well as discover what methods are available.  
**Use case:** one app provides a function like getRates(currencyPair) or a calculateRisk(portfolio) that others can call and receive back a result. Also supports streams - an app can publish a continuous stream of data (like market data ticks) and others subscribe. This is ideal for real- time data services or implementing a microservice-style architecture on the desktop. |
| Pub/Sub Messaging](io.pubsub) | Provide transient, topic-based messaging, including routing keys and publisher or subscriber targeting.   
**Use case:** integrating legacy apps that communicate via a topic (e.g. an old chat or ticker plant) or simply as an alternative to shared contexts when a transient message (event) is preferred over stored state. This API provides raw pub/sub support and can bridge existing pub-sub infrastructures into io.Connect. |
| Themes (io.themes) | Discover available platform themes, select a theme, retrieve the current theme, and subscribe to theme changes. **Use case:** keeping an app’s custom UI components synchronized with the active light, dark, or organization-specific theme. |

To dive deeper into topics like Shared Contexts, Interop Methods and Intents read:

- [Key io.Connect Integration Concepts](https://community.interop.io/t/key-io-connect-integration-concepts-explained/255)
- [io.Connect Patterns](https://community.interop.io/t/io-connect-patterns-and-apis-making-the-right-choice/570)

If you are just getting started and want to get a better overview and the bigger picture check:

- [Intro to io.Connect](https://community.interop.io/t/io-connect-desktop-introduction/567)
- [Interop Examples for Beginners](https://community.interop.io/t/interop-use-cases-for-beginners/616)