Linux Links Open the Software Store Instead of the Installed App: How to Fix

Quick Answer

When a website’s “Open in app” button opens the Linux software store instead of an installed application, first check the link’s destination. An appstream: link is intended for a software center. An application-specific link needs a working protocol association pointing to the correct installed application.

If the link is an application link, confirm that the application launches normally, identify its .desktop launcher, and set that launcher as the default for the link’s x-scheme-handler/SCHEME association. Flatpak and AppImage require different integration checks. If the link works from the desktop but fails in a browser, investigate browser permissions or the desktop portal.

What Makes a Link Open an Application?

A URI scheme is the part before the first colon in a link. For example, https: identifies a web link. Applications can register their own schemes for opening meetings, projects, documents, or other resources.

On Linux, URI schemes are associated with applications through names such as x-scheme-handler/myapp. Here, myapp is an illustrative scheme, not a real application recommendation. The handler is identified by a desktop file ID, usually a filename ending in .desktop. :chatgpt-content-reference{index="0"}

XDG refers to desktop interoperability specifications and related tools. It is not one application or service. The relevant components include desktop launchers, application associations, desktop opening tools, and, in some environments, XDG Desktop Portal.

1. Check Whether the Link Should Open the Store

Where available, right-click the button and copy its link address. Inspect it locally. A scripted button may not expose its final destination this way; consult the application’s documentation or inspect the page’s behavior if necessary.

AppStream defines its URI scheme for software-center handling. Do not redirect that scheme to an unrelated installed application simply to avoid the store. :chatgpt-content-reference{index="1"}

If an application-specific link produces a store or “find an application” prompt, a missing or unusable handler is a possibility. The symptom alone does not establish the cause.

2. Perform the Basic Checks

1. Open the application directly from the application menu. For an unintegrated AppImage, open the trusted AppImage file.
2. If it does not launch, resolve that startup problem first.
3. Confirm that the application’s Linux version supports the link’s scheme. Installation alone does not prove support.
4. If multiple editions are installed, decide which should open links.
5. If Flatpak or desktop integration was just installed, save your work, sign out, and sign back in before retesting.

The commands below use Bash in a terminal within your normal graphical Linux session. Run them as the affected user, without administrator privileges. Do not use a root terminal, an SSH-only session, or a terminal inside an application sandbox for these host-desktop checks.

If a utility is unavailable, obtain it through your distribution’s supported package manager. Package names and installation procedures vary.

3. Identify the Current Protocol Handler

Replace myapp with the actual scheme, excluding the colon and any slashes. Keep the same terminal open for subsequent commands.

scheme='myapp'
xdg-mime query default "x-scheme-handler/$scheme"

This read-only query reports the default desktop file ID. Record the result before changing anything. An empty result means this query did not find a default; it does not prove that the application is absent.

If GIO is available, this additional read-only check lists its default and registered candidates:

gio mime "x-scheme-handler/$scheme"

GIO is a desktop I/O library used by GNOME and other software. Its results help identify candidate launchers, although other desktop components can follow different opening paths. :chatgpt-content-reference{index="2"}

4. Find the Correct Desktop Launcher

A desktop launcher describes how an application starts. Use the launcher actually installed for your chosen edition; do not guess its filename from the application’s display name.

Common locations include:

These are common defaults. A customized XDG_DATA_HOME, additional XDG_DATA_DIRS entries, or a custom Flatpak installation can introduce other locations.

Open a candidate launcher in a text editor and inspect its main [Desktop Entry] section:

• Name should identify the intended application.
• Exec should target the correct installation.
• MimeType should declare support for the required scheme.
• Hidden=true disables the entry; an invalid TryExec can make it unavailable.

A normal NoDisplay=true entry can still act as a handler. Applications using DBusActivatable=true may launch through D-Bus, so inspecting Exec alone is not conclusive. :chatgpt-content-reference{index="3"}

5. Set and Verify the Default Handler

Proceed only after confirming that the installed launcher supports the scheme. If your desktop offers an application chooser for the link, selecting the correct application there may be sufficient.

For the command-line method, replace org.example.App.desktop below with the verified desktop file ID. This is an example identifier, not an application to install.

desktop_id='org.example.App.desktop'
xdg-mime default "$desktop_id" "x-scheme-handler/$scheme"
xdg-mime query default "x-scheme-handler/$scheme"

The final query should report the selected launcher. The argument is a desktop file ID, not an AppImage path or Flatpak application ID. The launcher must already be registered and declare support for the association. :chatgpt-content-reference{index="4"}

Next, replace the illustrative address below with a valid, non-sensitive link for the application:

xdg-open 'myapp://REPLACE_WITH_A_VALID_TEST_LINK'

This asks the desktop’s opening mechanism to handle the link. Custom-scheme behavior depends on its backend. Run the test in your graphical session; the tool is not intended for root use. :chatgpt-content-reference{index="5"}

6. Check Flatpak Integration

Flatpak and AppImage are different distribution formats. Flatpak manages installed applications and runtimes; an AppImage is an application file with separate desktop-integration requirements.

For Flatpak, list installed applications and their installation locations:

flatpak list --app --columns=application,name,installation

Replace APP_ID with the exact installed application ID to test startup:

flatpak run APP_ID

If duplicate installations exist, use the appropriate installation selector:

flatpak run --user APP_ID
flatpak run --system APP_ID

Run only the line matching your installation. These commands launch the app without testing protocol handling. Named custom installations require their corresponding selector. :chatgpt-content-reference{index="6"}

Check exported launchers and the desktop search path

Flatpak exports desktop files to the directories listed earlier. The distribution normally adds the export locations to the desktop’s data search path.

printf '%s\n' "$XDG_DATA_DIRS"

Check for the applicable Flatpak export directory ending in /exports/share. This reports the terminal’s environment, which may differ from an already-running browser’s environment.

If exports exist but the desktop cannot discover them, sign out and back in. If the problem persists, check your distribution’s Flatpak session integration. Changing an environment variable in one terminal does not update existing desktop processes.

Flatpak rewrites exported launcher commands for sandbox startup. Preserve these commands and their arguments. Do not replace them with a simplified launcher or edit generated exports as a permanent repair. A missing scheme declaration may require a packaging fix from the application maintainer. :chatgpt-content-reference{index="7"}

7. Check AppImage Integration

An AppImage can run successfully without being registered as a desktop URL handler. Moving or renaming its file can also leave an existing launcher pointing to an obsolete location.

1. Confirm that the trusted AppImage runs directly.
2. Check its execution permission through the file manager’s Properties dialog.
3. Keep the file in a stable location.
4. Use the application’s supported integration process, or your existing AppImage integration tool, to refresh its launcher.

AppImage desktop integration uses desktop entries; simply downloading the file does not guarantee that the desktop can use it for application links. :chatgpt-content-reference{index="8"}

Advanced: create a user launcher when necessary

Use this approach only if the application supports the scheme and accepts its URI as a command-line argument. Prefer the vendor’s launcher when available.

Create the user application directory if needed:

mkdir -p "${XDG_DATA_HOME:-$HOME/.local/share}/applications"

Using a text editor, create org.example.AppImageHandler.desktop in that directory. The following is an illustrative configuration: replace the name, absolute file path, and scheme with your verified values.

[Desktop Entry]
Type=Application
Name=Example App
Exec="/home/USERNAME/Applications/Example.AppImage" %u
Terminal=false
MimeType=x-scheme-handler/myapp;

%u passes one URL; %U passes multiple URLs when supported. Keep the field code outside the quoted executable path. Desktop launcher syntax is not ordinary shell syntax: use a real absolute path instead of expecting ~ or $HOME expansion. Preserve any additional arguments required by the application. :chatgpt-content-reference{index="9"}

If the desktop-file utilities are installed, validate the file and rebuild the user application cache:

desktop-file-validate "${XDG_DATA_HOME:-$HOME/.local/share}/applications/org.example.AppImageHandler.desktop"
update-desktop-database "${XDG_DATA_HOME:-$HOME/.local/share}/applications"

Resolve validation errors before continuing. Rebuilding this cache records supported associations; it does not select the default application. Return to Step 5 and use the new launcher’s filename. :chatgpt-content-reference{index="10"}

8. If Desktop Opening Works but the Browser Still Fails

This result narrows the problem to the browser’s handoff path, the website, or a portal-mediated choice. It does not prove that the portal is broken.

1. Completely close and reopen the browser.
2. Retry the original button and inspect any external-application prompt.
3. If the browser offers a remembered handler or site permission, review the choice for this application or site.
4. Compare with another installed browser using the same trusted link.
5. Check whether the website actually attempts the same application URI tested from the terminal.

A sandboxed browser may ask XDG Desktop Portal to open the URI. The OpenURI portal can use a default application or a previous choice, so its behavior may differ from a direct terminal test. :chatgpt-content-reference{index="11"}

If only portal-mediated opening fails, check the distribution’s portal packages and configuration for your current desktop. Portal backend selection depends on desktop configuration, including XDG_CURRENT_DESKTOP. Do not assume that installing every backend will resolve the issue. :chatgpt-content-reference{index="12"}

Avoid disabling browser security, granting unrestricted sandbox access, or resetting all application permissions as a general link-handling fix.

9. Check Conflicting Associations

If the default does not stick, inspect the relevant mimeapps.list files. The usual user configuration is ~/.config/mimeapps.list, or the equivalent under a customized XDG_CONFIG_HOME.

Desktop-specific files, such as gnome-mimeapps.list or kde-mimeapps.list, can take precedence over the generic file. Older files under ~/.local/share/applications/ may also participate in lookup. Back up a file before editing it and change only entries for the affected scheme. :chatgpt-content-reference{index="13"}

Also check for an obsolete user launcher with the same desktop file ID as the maintained launcher. A higher-priority copy can shadow the correct one. Move only a confirmed obsolete copy outside the application directory, retain it for rollback, and retest.

Verify the Complete Fix

• The selected handler is the intended installed application.
• A valid test link opens both the application and the requested resource.
• The original browser button works after any required permission prompt.
• The behavior remains correct after signing out and back in.

If only one website fails, report the failing handoff to that website or application vendor. Provide the distribution, desktop environment, browser packaging format, application version, installation format, and sanitized test results.

Undo Changes and Prevent Recurrence

To restore a previous default, replace the example filename below with the desktop file ID recorded earlier:

xdg-mime default PREVIOUS_HANDLER.desktop "x-scheme-handler/$scheme"

If there was no previous explicit default, restore the backed-up association file or remove only the entries added for this scheme. Do not delete the entire association file.

If you created a custom AppImage launcher, remove only that new file when undoing the change, restore any launcher you moved aside, and rebuild the user desktop database. Restoring a whole backup can overwrite unrelated changes made afterward, so compare the files first.

To reduce recurrence, keep AppImage paths stable, refresh their integration after replacements, and recheck protocol defaults when switching between native, Flatpak, and AppImage editions.

Frequently Asked Questions

Does changing the default web browser fix application links?

Usually, an application-specific scheme has its own handler. Changing the default browser primarily affects web links; check the scheme used by the failing button.

Can a launcher make an unsupported application understand a link?

No. A launcher can pass a URI to an application, but the application must implement the protocol and requested action.

Should I reinstall the application immediately?

First determine whether it launches directly and whether its launcher exists. Reinstallation may be appropriate for missing package files, but it will not necessarily correct a website’s store link or a browser’s remembered choice.

Sources

• AppStream: URI Handler
• XDG: xdg-mime and xdg-open
• Shared MIME-info Database Specification and MIME Application Association Lookup Order
• Desktop Entry Specification, including the Exec key
• Flatpak: Requirements and Conventions and Command Reference
• AppImage: Desktop Integration and Running AppImages
• XDG Desktop Portal: OpenURI and Portal Configuration
• Red Hat: GIO Command Reference; Arch Linux manual pages for desktop-file-validate and update-desktop-database