How to Fix ERR_UNKNOWN_URL_SCHEME Error (Easy Solutions)

Key Takeaways

• The ERR_UNKNOWN_URL_SCHEME error is triggered when a link uses a format or scheme that your browser or app doesn’t support.
• For regular users, the error can be fixed by clearing your browser cache, disabling problematic extensions, or opening the link in a new tab.
• For developers, to prevent app crashes and silent failures, set up Android WebView to handle non-standard schemes like mailto: or intent:, etc.

If you click a link to open a web page, or a specific app, but your browser throws a net::ERR_UNKNOWN_URL_SCHEME error, then there is something wrong with the URL scheme the link is trying to use.

Whether you’re an everyday user trying to browse the internet on your phone or a developer working with a broken WebView in an Android app, this error points to one thing clearly: the browser received an instruction that it does not know how to execute.

All URLs start with a scheme such as http://https://, or mailto:. But, if a link contains an unsupported scheme or tries to open an app that is not installed on the user’s device, the browser will block it at the navigation layer.

Though this might sound like a difficult issue to fix, it is actually not. In this guide, I’ll cover the easiest ways regular internet users can fix the error in their browsers, and advanced debugging steps developers can take to resolve broken redirects.

Let’s get started.

What Is the net::ERR_UNKNOWN_URL_SCHEME Error?

You’ll see the net::ERR_UNKNOWN_URL_SCHEME error when your browser tries to open a link but is unable to understand the protocol, or ‘scheme,’ which is the part that appears at the beginning of a URL. For example: https:// or mailto:.

Think of a scheme as a set of instructions, which tells your browser what type of resource it is trying to open and how to handle it.

If your browser doesn’t have a registered rule for a specific instruction, the network request stops, and your browser throws an error screen at you.

Standard Schemes vs. Custom App Schemes

Browsers process URLs differently depending on whether the link uses a standard scheme meant to be used for the web, or a custom scheme used to launch an external application.

Let me explain the difference between both the schemes:

• Standard Schemes: These include prefixes like http:// and https://. Browsers are built to handle these without a problem, so they know exactly how to fetch the server data and display the web page.

• Custom App Schemes: These, on the other hand, are special directives that tell your device to open an app instead of loading a website. Common examples of these include whatsapp:// to launch WhatsApp, mailto: to open an email client, or intent:// for specific Android app routing.

In most cases, this error is triggered when a user clicks a custom app link, but the application is not actually installed on their phone or computer.

And because the browser can’t render a web page for a whatsapp:// link, and the native app is not there, the browser throws the ERR_UNKNOWN_URL_SCHEME error.

Prevent URL Scheme Errors with Cloudways WordPress Hosting

Cloudways managed WordPress hosting ensures stable server configurations, proper PHP handling, and reliable environments to keep your site error-free.

TRY NOW

Common Causes of the Unknown URL Scheme Error

Now that you know the two types of URL schemes, let’s look at the most common reasons why your browser might suddenly fail to recognize one and run into this error:

Missing Native Apps

For mobile users, this is the biggest culprit. When you tap a “Share on WhatsApp” button or a “Call Now” link, the website tries to use a custom scheme like whatsapp:// or tel:, but if you don’t have that specific app installed, the browser throws the error.

Broken Login Redirects (OAuth/SSO)

When you log into an app using a third-party service like Google or Facebook, your browser opens a popup window that asks to verify your credentials. Once verified, it tries to redirect you back to the app using a custom scheme.

But if that redirect link is broken or not configured properly by the developer, your browser gets stuck and throws the ERR_UNKNOWN_URL_SCHEME screen. (Also learn how to fix ERR_TOO_MANY_REDIRECTS for pages with wrong redirection configurations)

Iframe Restrictions

Developers often embed third-party widgets on their websites. These can be payment portals, customer support chats, etc. But Google Chrome actively blocks custom app links from launching from inside such embedded frames without a direct action from the user. So if a script tries to auto-launch an app from an iframe, Chrome will block it and you’ll see the error.

Malformed URLs (Typos)

Sometimes, the error could be due to a simple typo. If a developer of a website accidentally types htps:// instead of https:// or forgets the colon, the browser will treat that typo as a completely new and unrecognized custom scheme.

How to Fix ERR_UNKNOWN_URL_SCHEME (For Mobile & Desktop Users)

Since this error is pretty much a browser issue, fixing it usually means clearing out bad data or resetting a couple of settings. If you are trying to browse the web or using a mobile app and run into the error, go through the solutions covered below in sequence until it’s gone.

1. Clear Chrome Browser Data and Android App Cache

Over time, browsers accumulate routing data, cookies, and cached files to help pages load quicker. This is great for user experience. However, if this stored data becomes outdated or corrupted, it can direct the browser to the wrong path and trigger the unknown scheme error.

Since this issue happens frequently on Android phones, it is good to know how to clear the cache for your desktop browser as well as your mobile app.

For Desktop Users:

• Open Chrome and then click the three dots in the top right corner to open up Settings.
• Then go to Privacy and security, and click Delete browsing data.

• Check the boxes for Cookies and other site data as well as Cached images and files.
• Click Delete data and then try and reload the page to see if the link now works.

For Android Users:

• Open up the phone’s Settings and tap on Apps.
• Find Chrome from the list of installed applications and select it.
• Tap on Storage and cache, and Clear cache.

• Finally, force stop the app, reopen it, and try clicking the link again to see if it works now.

2. Disable Link-Rewriting Browser Extensions

Browser extensions are really useful for adding extra features, but some extensions are known to actively filter or rewrite the links you click. I’m talking about privacy extensions, ad and script blockers. These are usually the main suspects.

When an extension modifies the scheme of a URL even a little bit, your browser will not know what to do with the link. Ultimately, it will block the request.

A quick fix for this is to turn your extensions off temporarily and then test the link again in your browser.

Steps to disable extensions:

• Open the Chrome browser on your desktop.
• Type chrome://extensions/ in the address bar and hit Enter. This will open up all the extensions installed in your browser.
• Now just turn off all your active extensions using the toggle switches.

• Finally, reload the webpage and try clicking the link again.

If the link works and the error goes away, you know some extension is causing the issue. But to find out which one, turn them back on one by one until you find the one breaking the link.

3. Create a New Browser Profile

So if turning off extensions and clearing cache didn’t fix the error, this means your Chrome profile itself might be holding onto corrupted preferences, hidden settings, or conflicting sync data. And that may be what’s messing up how your browser handles certain links.

A quick fix for this is to create a new Chrome profile. A clean profile gives you a fresh start without having to uninstall and reinstall the entire browser.

Steps to create a new profile:

• Open Chrome and click on your profile icon in the top right corner.
• Click on Add Chrome profile at the bottom of the menu.

• Choose the option to stay signed out to set up a quick testing environment.

• Paste the problem link in the new profile’s address bar and check if it loads properly.

If the error is gone in the new profile, your old profile is likely corrupted. In this case, just move your bookmarks over to the new one and keep using it.

4. Open the Link in a New Tab or Window

Sometimes, the webpage you’re on might have specific restrictions built into its code. For example, if the link you’re clicking on is trying to launch a custom app from inside an embedded widget or an iframe, your browser might block it for security reasons.

A simple workaround for this is to force the link to open in a new tab or window. This trick takes the link out of the restricted environment and gives your browser a fresh place to process the custom scheme.

How to do it:

• Instead of clicking the link, right-click on it and select Open link in new tab or Open link in new window from the dropdown menu.

• If you are on a phone, hold the link until the menu pops up, and then tap Open in new tab in group or Open in new tab option.

If the app launches or the link works fine in the new tab, you know the issue was due to the specific page you were originally on.

5. Test a Non-Chromium Browser

If the error is still there, it’s time you check if your Chrome browser itself is the problem. The net::ERR_UNKNOWN_URL_SCHEME error is specific to Chromium-based browsers, which include, of course, Google Chrome, Microsoft Edge, and Brave.

The issue is sometimes triggered due to Chrome’s strict security rules or a temporary glitch. All this leads to your browser blocking a link that is otherwise perfectly fine.

To test if this is the issue in your case, copy the link and try opening it in a non-Chromium based browser like Firefox or Safari.

• If the link works in Firefox: You know the issue is with your Chrome browser.

• If the link still fails in Firefox: The issue is likely with the link itself, or you probably don’t have the app installed that is supposed to open when you click the link.

6. Reset Browser Flags

Most users don’t know, but Chrome has hidden experimental features known as “flags“. These are great for testing out new browser capabilities or even improving browsing performance.

That said, they can sometimes mess up how your browser processes complex links and custom schemes.

In case you, or a third-party optimization app, changed one of these hidden settings, it might be the reason why you are seeing the unknown scheme error.

Don’t freak out, it’s very easy to reset them back to defaults in a few clicks.

Steps to reset Chrome flags:

• Type chrome://flags into your Chrome address bar and hit Enter.

• Look for the Reset all button in the top right corner and click it.

• Then click the Relaunch button to restart your browser.

Once Chrome relaunches, click your link one more time to see if resetting the experimental features fixed the error.

7. Update Chrome to the Latest Version

If nothing has worked so far, your browser is likely outdated. Google pushes updates frequently to fix known bugs, patch security vulnerabilities, and improve how the browser processes complex URLs.

Using an older version of Chrome means you don’t have the critical bug fixes, which could be the reason your browser is struggling to process the link.

For Desktop Users:

• Open Chrome and click the three dots in the top-right corner.
• Hover on Help and click on About Google Chrome.

• Chrome will automatically check for updates and if a new version is available, it will start downloading it.

• Once the download finishes, click the Relaunch button to apply the updates and then check if the link works now.

For Android Users:

• Open the Google Play Store on your phone and tap your profile icon.
• Tap on Manage apps & device.
• Under the “Updates available” section, look for Google Chrome.
• If the Chrome app has an update, tap the Update button next to it.

After updating, open Chrome and try your link. In most cases, simply updating to the latest version is all it takes to fix the error.

Developer Fixes: Handling Schemes in Android WebView

If you’re an Android developer and your users are running into the ERR_UNKNOWN_URL_SCHEME error, the issue could be due to how your WebView is configured.
By default, Android WebView is only able to handle standard http:// and https:// URLs. So, when a user clicks a link inside your app that is supposed to trigger a custom scheme like intent:// or whatsapp://, the WebView doesn’t know what to do with it and throws the unknown scheme error.
To fix this, you’ll need to tell the WebView how to handle special links. Here are 3 simple fixes you can try as a developer to resolve the issue.

1. Intercept Intents Using shouldOverrideUrlLoading

The best solution to fix the error in my opinion is to intercept the URL right before the WebView even tries to load it. You can do this easily by overriding the shouldOverrideUrlLoading method in your WebViewClient.

Check out this simple code snippet:

webView.webViewClient = object : WebViewClient() {
override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
val url = request?.url.toString()
// Let the WebView handle standard web URLs
if (url.startsWith("http://") || url.startsWith("https://")) {
return false
}
// Intercept custom schemes and launch the corresponding native app
return try {
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
view?.context?.startActivity(intent)
true
} catch (e: Exception) {
// The intent failed (e.g., the app is not installed)
e.printStackTrace()
true
}
}
}

The logic to implement is pretty simple. If the link starts with http or https, just return false and let the WebView handle it. But if the URL uses a custom scheme, intercept it, then launch the appropriate app with an Intent, and return true. This way, the WebView doesn’t try to handle it itself.

2. Implement the Google Play Store Fallback

Intercepting the intent is a great fix that works, but in case you launch a whatsapp:// intent and the user doesn’t actually have the app installed on their phone, what happens then?

Well, the intent will fail, and your app will crash.

To avoid this, you can wrap your intent launcher in a try-catch block. If the catch triggers, take the package name from the intent and redirect the user to Google Play Store so they can download the missing app instead of seeing an error.

Here’s a simple code snippet example:

// Intercept custom schemes and handle missing apps
try {
// Parse the URL into an intent
val intent = Intent.parseUri(url, Intent.URI_INTENT_SCHEME)
view?.context?.startActivity(intent)
return true
} catch (e: ActivityNotFoundException) {
// The native app is not installed, so we catch the exception
val intent = Intent.parseUri(url, Intent.URI_INTENT_SCHEME)
val packageName = intent.`package`
if (packageName != null) {
// Redirect the user to the Google Play Store
val playStoreIntent = Intent(
Intent.ACTION_VIEW,
Uri.parse("market://details?id=$packageName")
)
view?.context?.startActivity(playStoreIntent)
}
return true
} catch (e: Exception) {
// Handle any other URL parsing errors
e.printStackTrace()
return false
}

3. Restrict the View to HTTP and HTTPS

In case your WebView is only meant for reading standard web pages, you wouldn’t want users to launch external apps in the first place. The easiest fix to ensure this is to simply block custom schemes entirely.

To do this, in your shouldOverrideUrlLoading method, check the scheme first and if it is not HTTP or HTTPS, return true to cancel the navigation.

You can also add a quick Toast message like “External links are disabled” so the user knows exactly why nothing happened.

Check out this code example below:

webView.webViewClient = object : WebViewClient() {
override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
val url = request?.url.toString()
// Allow standard web URLs to load normally
if (url.startsWith("http://") || url.startsWith("https://")) {
return false
}
// Block custom schemes and notify the user
view?.context?.let { context -
Toast.makeText(context, "External links are disabled", Toast.LENGTH_SHORT).show()
}
// Return true to cancel the navigation
return true
}
}

Experience Fewer Hosting Errors with Cloudways Autonomous

Cloudways Autonomous uses Kubernetes-based autoscaling and managed infrastructure to reduce configuration issues, handle traffic spikes automatically, and keep your site stable and responsive.

Try Today

Advanced Debugging for Broken Redirects

Sometimes, the problem may not be due to a missing app or a WebView misconfiguration. In complex web apps, those using third-party authentication or custom redirects, the ERR_UNKNOWN_URL_SCHEME error can also be hidden in the redirect chain.

If you’re a developer and encountering the error time and time again, let me walk you through a few advanced debugging techniques that can help you pinpoint the source of the problem.

1. Trace Backend Redirects and SSO Callbacks

If your users are coming across the error after trying to log in with Google, Facebook, or Apple (OAuth/SSO), your callback URL is probably misconfigured.

Let me explain this better. See, when an authentication provider verifies a user, it sends them back to your app using a redirect URI. But if that URI contains a typo, uses an unregistered custom scheme, or its protocol gets stripped by a strict server caching rule, the browser will throw the error.

How to fix this:

Open your browser’s Developer Tools, go to the Network tab and checkmark the “Preserve log” option.

Then, go through the login process again and look at the exact URL your server is trying to redirect to in the final step in the developer tools window. You should be able to spot a malformed scheme in the headers.

2. Inspect Android Manifest Intent Filters

If you created a custom scheme for your app, like myapp://login, but clicking the link in a mobile browser throws the unknown scheme error instead of opening the app, your Android Manifest is the reason why.

For Android to know that your app is supposed to handle myapp:// links, you must use an Intent Filter in your AndroidManifest.xml file.

How to fix this:

Check your manifest file and make sure your activity is set up to handle the custom scheme with <data android:scheme=”myapp” /, along with ACTION_VIEW, CATEGORY_DEFAULT, and CATEGORY_BROWSABLE.

Without these categories, mobile browsers won’t be allowed to pass the link to your app.

3. Validate URLs Before Routing

We covered this briefly earlier, but I’d like to mention it again for developers: never blindly trust user-generated URLs or dynamically built links. Always validate them first.

If your website has a database of links and a user accidentally inputs htps:// or ww., the browser will read that as an unknown custom scheme and throw the error. This can be very easily avoided by implementing sanitization.

How to fix this:

Implement a sanitization layer on the backend. So, if your app dynamically generates redirects, run the URL first through a Regex validator or an in-built URL parsing library to ensure the URL strings begin strictly with http:// or https:// before sending it to the client.

Here are some more guides to fix errors like ERR_UNKNOWN_URL_SCHEME error

• How to fix ERR_HTTP2_PROTOCOL_ERROR easily?

• How to Fix ERR_TUNNEL_CONNECTION_FAILED in Chrome?

• How to Fix ERR_BLOCKED_BY_RESPONSE Error (Detailed Guide)

Wrapping Up!

To wrap things up, the net::ERR_UNKNOWN_URL_SCHEME error can look complicated to fix, but, more often than not, the cause of the error is simple.

For regular users, it’s often just a missing app, a browser cache issue, or an extension blocking the link. In most cases, simply updating the browser or installing the missing app resolves the error.

For developers, the error is often triggered when the web views don’t automatically understand custom app links. But by handling custom schemes properly in Android WebView, providing fallback URLs, and checking redirect flows, this issue can be easily fixed before it reaches the end users.

If there is still any confusion, or I missed something, let me know in the comments below.