---
title: "How in-app browsers work: why links opened in Instagram or TikTok behave differently"
description: "An in-app browser is the window Instagram, TikTok or Facebook opens inside itself when you tap a link. How a web view differs from Safari or Chrome: its own cookies, the app's code on the page, Google sign-in refused, downloads and passes, and how a website can tell. Sourced to Apple, Android, Google and the RFCs."
canonical: "https://linkbreakers.com/help/article/how-in-app-browsers-work"
last-updated: 2026-11-21
---

# How in-app browsers work: why links opened in Instagram or TikTok behave differently

> An in-app browser is the window Instagram, TikTok or Facebook opens inside itself when you tap a link. How a web view differs from Safari or Chrome: its own cookies, the app's code on the page, Google sign-in refused, downloads and passes, and how a website can tell. Sourced to Apple, Android, Google and the RFCs.

![How an app opens a link: your browser, a browser tab, or a web view inside the app](/screenshots/how-in-app-browsers-work.png)

## Short answer

An **in-app browser** is the browser window an app opens inside itself when you tap a link, instead of sending you to Safari or Chrome: the Instagram browser, the TikTok browser and the Facebook webview are all in-app browsers. Research in 2022 found that Instagram, Facebook and TikTok used their own **web view**: a browser engine the app places inside its own screen, controlled by the app that opened it (the **host app**), not by you. That is why a link opened in Instagram or TikTok can behave differently:

- **It keeps its own cookies.** A cookie is the small note a website leaves so it remembers you. A web view does not share Safari's or Chrome's, so a site you are signed in to in your browser sees you there as a new visitor, signed out, with an empty cart.
- **The app can run its own code on the page.** Apple's and Android's web views let the host app run its own scripts on the page and read its cookies.
- **Some things need the app's help, or are refused.** Google refuses its sign-in inside web views, and downloads, Apple Wallet passes and the camera work only if the app built them in.

Not every app works this way. An app can also hand the link to your default browser, or open a **browser tab** it cannot control (SFSafariViewController on iPhone, Custom Tabs on Android), which behaves much more like your browser. A website can tell an in-app browser apart from the **user agent**, the line of text every browser sends with each request: in-app browsers usually add the app's name to it.

Visits through a QR code rarely end in an in-app browser. Across Linkbreakers, in the 30 days to 21 November 2026, 1.3% of visits that came through a QR code opened in an in-app browser, against 5.0% of link clicks: the camera hands the link to the browser, apps keep it.

## How an app opens a link: three ways

When you tap a link inside an app, the app decides what happens next. It has three options, and the difference between them explains everything else on this page.

### 1. It hands the link to your browser

The app asks the phone to open the link, and the phone opens it in your **default browser**, the browser your phone opens links in (Safari or Chrome unless you changed it). Apple's developer documentation puts it simply: "The system invokes the default web browser in iOS whenever the user opens an HTTP or HTTPS link."

The page then opens in your own browser, with your cookies, your saved passwords and your sign-ins. In August 2022, the researcher Felix Krause listed iPhone apps that did this, among them WhatsApp, Slack, YouTube, Gmail, Spotify and Microsoft Teams.

### 2. It opens a browser tab it does not control

The app shows the page inside itself, but the browser does the work. Google called these "in-app browser tab" patterns in 2016, naming **Chrome Custom Tabs** on Android and **SFSafariViewController** on iOS.

On iPhone, Apple describes SFSafariViewController as "a self-contained web interface inside your app", and adds: "Interactions with the web interface aren't visible to your app, and you can't access AutoFill data, browsing history, or website data." Its interface includes "a button to open the page directly in Safari". Krause's 2022 table lists Twitter, Reddit, Google Maps, Telegram, Signal and Venmo among the iPhone apps that used it.

**Cookies changed with iOS 11.** When it was introduced in 2015, Apple said: "Safari View Controller shares cookies with Safari and other website data." Apple's documentation, as archived in 2018, says: "In iOS 9 and 10, it shares cookies and other website data with Safari", and points apps that want to share sign-ins with Safari in iOS 11 and later to a different tool. Today's page says: "To share data between your app and Safari, use ASWebAuthenticationSession instead." So on a current iPhone, a browser tab inside an app does not share Safari's cookies, and a sign-in made in Safari does not carry over.

**On Android, Custom Tabs share the browser's state.** Chrome's documentation says they are "powered directly by the user's preferred browser", with a "Shared cookie jar and permissions model so users don't have to sign-in to sites they are already connected to, or re-grant permissions they have already granted."

### 3. It shows the page in its own web view

The app puts a browser engine inside its own screen and loads the page there. On iPhone this is **WKWebView**, which Apple describes as "An object that displays interactive web content, such as for an in-app browser." Apple adds that "A web view offers control over the navigation and user experience through delegate objects": the app decides what happens when you tap a link inside the page.

### What a web view (webview) is on Android

Android's **WebView** is "A View that displays web pages", and Android's own reference adds: "In most cases, we recommend using a standard web browser, like Chrome, to deliver content to the user." The developer guide is blunter: a WebView "doesn't include the features of a fully developed web browser, such as navigation controls or an address bar. All WebView does, by default, is show a web page." Any menu, address bar or share button you see is one the app built itself.

Apple's design guidelines discourage apps from turning a web view into a browser: "Avoid using a web view to build a web browser. Using a web view to let people briefly access a website without leaving the context of your app is fine, but Safari is the primary way people browse the web."

### Which apps use which

Instagram, Facebook and TikTok do not document what they use. The public evidence is research and user agents:

- **Krause, August 2022, on iPhone:** "The iOS Instagram and Facebook app render all third party links and ads within their app using a custom in-app browser." His table of 18 August 2022, "iOS Apps that have their own In-App Browser", lists TikTok, Instagram, FB Messenger, Facebook, Amazon, Snapchat and Robinhood. That post now carries his own note: "Please note that this article is outdated (August 2022)."
- **Our own data, 2026, on Android:** an Android web view writes `; wv)` into its user agent (more below). Of the devices of people who opened Linkbreakers links in the 90 days to 21 November 2026, 29 of 30 Instagram Android devices, 19 of 19 LinkedIn, 42 of 44 WeChat and 4 of 4 LINE carried it: a WebView, not a Custom Tab.
- **TikTok's own user agent** on iPhone writes `WKWebView/1`, and on Android it carries `; wv)`.

Your own browser runs the page itself, with your cookies, and no app can script it. The two kinds of in-app browser compare like this:

| | Browser tab | Web view |
|---|---|---|
| Runs the page | Safari (iPhone) or your browser (Android) | the app |
| Your cookies and sign-ins | Android: yes. iPhone since iOS 11: no | no, it keeps its own |
| The app can run code on it | no | yes |
| A button to open it in your browser | on iPhone, built in | only if the app adds one |

## What changes inside a web view

### Its own cookies: you arrive as a stranger

A web view keeps website data in its own store, inside the app. Apple's WKWebsiteDataStore is "An object that manages cookies, disk and memory caches, and other types of data for a web view." Android is explicit: "For security reasons, the system's browser app doesn't share its application data with your app."

So someone signed in to your site in Safari or Chrome, or with items in a cart there, arrives in an app's web view as a stranger. The standard for app sign-in, RFC 8252, says the same: embedded browsers "do not share the authentication state with other apps or the browser, requiring the user to log in for every authorization request".

### The app can run its own code on the page

A web view gives the host app tools a browser tab does not. On iPhone, WKUserScript is "A script that the web view injects into a webpage", and `evaluateJavaScript` "Evaluates the specified JavaScript string." The app can also set and read the page's cookies through WKHTTPCookieStore. On Android, `addJavascriptInterface` "Injects the supplied Java object into this WebView", into "all frames of the web page", and `evaluateJavascript` "Asynchronously evaluates JavaScript in the context of the currently displayed page." Chrome's own documentation names script injection as a reason an app would choose a WebView over a Custom Tab.

RFC 8252, the IETF's best practice for sign-in from apps (October 2017), states plainly what that allows: "In typical web-view-based implementations of embedded user-agents, the host application can record every keystroke entered in the login form to capture usernames and passwords, automatically submit forms to bypass user consent, and copy session cookies and use them to perform authenticated actions as the user."

A browser tab is different. Krause: "All apps that use SFSafariViewController or Default Browser are on the safe side, and there is no way for apps to inject any code onto websites".

### What Felix Krause found in 2022

In August 2022, Felix Krause showed what three apps injected into pages opened in their iPhone in-app browsers. These are his findings, from 2022, with the companies' replies:

- **Instagram and Facebook:** "The Instagram app injects their JavaScript code into every website shown, including when clicking on ads." The injected file was `connect.facebook.net/en_US/pcm.js`, and Instagram also added "a new event listener, to get details about every time the user selects any text on the website." He added: "Even though the injected script doesn't currently do this, running custom scripts on third party websites allows them to monitor all user interactions".
- **Meta's reply**, as Krause published it: pcm.js "helps aggregate events, i.e. online purchase, before those events are used for targeted advertising and measurement for the Facebook platform", and "pcm.js is required to respect a user's ATT decision" (ATT is App Tracking Transparency, Apple's prompt asking whether an app may track you). On the text selection listener, Meta said "this feature has been deprecated for some time and was already identified for removal". Meta marked his report resolved "given the items raised in your submission are intentional and not a privacy concern".
- **TikTok:** "TikTok iOS subscribes to every keystroke (text inputs) happening on third party websites rendered inside the TikTok app." TikTok's reply, as reported by Forbes and quoted by Krause: the company "confirmed those features exist in the code, but said TikTok is not using them", and "the Javascript code in question is used only for debugging, troubleshooting and performance monitoring of that experience", "like checking how quickly a page loads or whether it crashes."

Krause was careful about what this proves: "the article does not claim that any data logging or transmission is actively occurring." He has since marked his August 18 post as outdated, and noted that apps could move their scripts to a place where "their code becomes undetectable to us". So whether these apps inject scripts today cannot be read from the outside. What stays true is the mechanism: in a web view, the host app can.

### Google sign-in is refused: disallowed_useragent

**Sign in with Google** runs on OAuth, the standard that lets a site use your Google account without ever seeing your password. Google stopped allowing it in web views in stages. In 2016: "we will no longer allow OAuth requests to Google in embedded browsers known as 'web-views', such as the WebView UI element on Android and UIWebView/WKWebView on iOS", with blocking set to start on April 20, 2017. In 2021: "All embedded webviews will be blocked starting on September 30, 2021", and "All non-compliant authorization requests will display a disallowed_useragent error".

Google's 2021 post also names the case that concerns every website, not only apps: "if a messaging or news application opens links to your site in an embedded webview, the features available on your site, including Google OAuth 2.0 authorization flows, may be impacted." Google's current policy says a developer "must not direct a Google OAuth 2.0 authorization request to an embedded user-agent under the developer's control."

In plain words: a "Sign in with Google" button that works in Safari or Chrome can show a `disallowed_useragent` error inside an app's web view. This is Google's rule; this page does not cover other sign-in providers.

### Downloads, files and Apple Wallet passes need the app's code

A web view downloads a file only if the app built that part. On iPhone, Apple added a download API to WKWebView in iOS 14.5 (WKDownload, "An object that represents the download of a web resource"), which the app has to implement. On Android, the app registers a listener for "content [that] can not be handled by the rendering engine, and should be downloaded instead", and for file uploads, "The default behavior is that WebView will cancel all file requests."

Apple Wallet passes follow the same rule. Apple's Wallet Developer Guide (an archived Apple guide, updated 2018) says: "Both the Safari app and the Safari view controller can import the pass files directly into the pass library. If you want to load a file using a web view, you must detect the request, download the pass, and programmatically add the pass yourself."

### Camera and location ask the app first

A page that asks for the camera inside an app gets it only if the app passes the request on. On iPhone, WebKit says `getUserMedia`, the camera and microphone API, "is automatically exposed if the embedding application is able to natively capture either audio or video", and since iOS 15 the app decides through its own delegate whether a page may use the camera. The app also needs its own camera permission, which Apple requires "if your app uses APIs that access the device's camera."

On Android, when a page asks for the camera or microphone, the web view notifies the host app, and "If this method isn't overridden, the permission is denied." A request for location goes to the app too, which "should invoke the specified callback with the desired permission state."

### Apple Pay: a rule that changed in iOS 16

Since iOS 13, a page in a WKWebView can accept Apple Pay. At first, with a condition: "Apple Pay cannot be used alongside of script injection APIs such as WKUserScript or `evaluateJavaScript(_:completionHandler:)`", and "If these APIs are invoked before a webpage uses Apple Pay, Apple Pay will be disabled." So in iOS 13 to 15, any script the app injected switched Apple Pay off for that page.

Safari 16, released with iOS 16 in September 2022, changed it: "Added support for allowing scripts to be injected into WKWebView that have used Apple Pay (and vice versa)." Apple's note does not say under which conditions, so the only way to know whether your Apple Pay checkout works inside a given app today is to test it there.

### The referrer can be missing

The **referrer** is the address of the page you came from, which the browser may pass to the next site in a `Referer` header. HTTP's specification, RFC 9110, says that when a link "was obtained from a source that does not have its own URI (e.g., input from the user keyboard, or an entry within the user's bookmarks/favorites), the user agent MUST either exclude the Referer header field or send it with a value of 'about:blank'." It also notes that servers use it "for simple analytics", "but not all requests contain it."

A link tapped in an app's own screen (a bio, a caption, a DM) was not opened from a web page, so there is no referring page to name, and the visit can arrive with no referrer. Facebook's website does the opposite on purpose: a 2020 paper by researchers from Georgia Tech and Facebook explains that it routes outbound links through a "link shim", so that "browsers (even if legacy) will set the HTTP referrer to the intermediate endpoint". The same paper says "Facebook's mobile (i.e., Android, iOS) apps do not broadly use link shimming". What Instagram, Facebook or TikTok's in-app browsers send as a referrer today is not documented.

## How a website can tell it is opened in an in-app browser

The user agent is the most direct signal. Apple lets an app add its name to it (`applicationNameForUserAgent`, "The app name that appears in the user agent string"), and in-app browsers usually do. Here is Safari on an iPhone, then three in-app browsers, each from a real visit to a Linkbreakers link.

Safari on iPhone:

```text
Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1
```

The Instagram browser on iPhone: the same start, then `Instagram`, the app's version and details about the phone.

```text
Mozilla/5.0 (iPhone; CPU iPhone OS 26_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/23G83 Instagram 447.0.0.34.80 (iPhone14,7; iOS 26_6_1; en_GB; en-GB; scale=3.00; 1170x2532; IABMV/1; 1065993616) NW/3 Safari/604.1
```

The Facebook webview on iPhone: `FBAN/FBIOS` names the app, `FBAV` its version.

```text
Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/23F77 Safari/604.1 [FBAN/FBIOS;FBAV/564.0.0.57.71;FBBV/985438427;FBDV/iPhone17,3;FBMD/iPhone;FBSN/iOS;FBSV/26.5;FBSS/3;FBID/phone;FBLC/en_GB;FBOP/5;FBRV/991304462;IABMV/1]
```

The TikTok browser on Android: `; wv)` marks a web view, `musical_ly` and `AppName/musical_ly` name TikTok.

```text
Mozilla/5.0 (Linux; Android 15; SM-A175F Build/AP3A.240905.015.A2; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/145.0.7632.159 Mobile Safari/537.36 musical_ly_2024402030 JsSdk/1.0 NetType/WIFI Channel/googleplay AppName/musical_ly app_version/44.2.3 ByteLocale/ar ByteFullLocale/ar Region/TD AppId/1233 Spark/1.7.2 AppVersion/44.2.3 PIA/2.5.3 RevealType/Dialog BytedanceWebview/d8a21c6
```

### Android WebView and the wv marker

Google's documentation on user agent strings: "In the newer versions of WebView, you can differentiate the WebView by looking for the `wv` field". In December 2024 the Android Developers Blog confirmed: "Sites can continue to look for the wv token in the User-Agent string, unless an application has decided to override the User-Agent string." That is how an Android web view that names no app can still be recognised.

### The tokens each app writes

These are the tokens the Linkbreakers api reads to name the app, tested against user agents recorded from real visits:

| App | What its in-app browser writes |
|---|---|
| Instagram | `Instagram <version> (` |
| Threads | `Barcelona` |
| Facebook | `FBAN/` or `FB_IAB/`, with `FBAV/<version>` |
| Messenger | the Facebook tokens, with an app name containing `messenger` or `orca` |
| TikTok | `musical_ly_`, `trill_` or `AppName/musical_ly` |
| Snapchat | `Snapchat/` |
| LinkedIn | `LinkedInApp` |
| Pinterest | `Pinterest/iOS` or `Pinterest/Android` |
| X | `Twitter for iPhone/` or `TwitterAndroid` |
| WeChat | `MicroMessenger/` |
| LINE | `Line/` |
| Google app | `GSA/` |
| Any Android web view | `; wv)` |

### What is not reliable

- **iPhone has no `wv` marker.** Google's documentation describes Android only, and in our data none of the 116 Instagram, 69 Facebook, 83 LinkedIn and 83 WeChat iPhone devices of the last 90 days carried `; wv)`. On iPhone, the app's own name is the signal to look for.
- **"Safari" in the string does not mean Safari.** The Instagram and Facebook strings above both end with `Safari/604.1`.
- **An app can rewrite its user agent entirely.** Apple's `customUserAgent` lets an app "specify a custom user agent string for your web view", and Android keeps `setUserAgentString()`. Linkbreakers records an iPhone web view that names no app as a regular browser.
- **Some requests carry the app but no browser.** On Android, some Facebook and Messenger requests look like `Dalvik/2.1.0 (Linux; U; Android 12; ...) [FBAN/Orca-Android;FBAV/551.0.0.48.62;...]`: only 10 of 39 Facebook Android devices in our 90 days had `; wv)`.
- **A browser tab is drawn by the browser.** A page in SFSafariViewController or a Custom Tab is rendered by Safari or the user's browser, and we found no primary statement of the user agent it sends, so this page makes no claim on whether it can be detected.

## How to open a link from Instagram or TikTok in Safari or Chrome

Use the app's menu. In 2022, Krause's advice was: "Whenever you open a link from Instagram (or Facebook or Messenger), make sure to click the dots in the corner to open the page in Safari instead." The menu, often three dots at the top of the app's browser, has an option to open the page in your browser. Its exact wording differs between apps and versions.

If there is no such option, copy the link and paste it into Safari or Chrome. In Krause's words: "If that button isn't available, you will have to copy & paste the URL to open the link in the browser of your choice."

Changing your phone's default browser does not change this. Apple's default browser setting chooses "another app instead of the Safari app to use when opening links to webpages": it applies when an app hands a link to the phone, not to a page the app keeps in its own web view.

## QR codes vs links: which ones open in an in-app browser

On an iPhone, Apple's instructions for scanning a QR code with the Camera app are: "Hold your device so that the QR code appears, then tap the link to open the content." Tapping that link opens it the way any link handed to the system opens, in the default browser. On a Pixel, Google says: "To open it, tap the link that appears." Google's page does not name the browser that opens.

A code scanned **inside an app** is different. WeChat, LINE, Snapchat and the Google app (with Lens) all scan codes, and the page can then open in that app's browser. So: scan with your phone's camera and the page opens in your browser; scan from inside an app and it may open in that app's browser.

### What we measured across Linkbreakers

We counted every visit by a person (bots, AI agents and automated browsers excluded) to Linkbreakers QR codes and links in the 30 full days from 22 October to 20 November 2026 (UTC), and how many opened in an in-app browser. A visit counts as "through a QR code" when it came through the address the code holds, which carries `lbsrc=qrcode` (see [how a dynamic QR code works](/help/article/dynamic-vs-static-qr-codes-key-differences)), and as a link click otherwise.

**Visits that opened in an in-app browser**

- **1.3%** of visits through a QR code (229 of 18,029)
- **5.0%** of link clicks (177 of 3,574)

| How the visit arrived | Share of visits in an in-app browser |
|---|---|
| Through a QR code | 1.3 % |
| Link clicks | 5 % |

Linkbreakers production data, visits by people across all workspaces, 22 October to 20 November 2026 (30 days, UTC), queried read-only on 21 November 2026.

| How it arrived | Visits by people | In an in-app browser | Share |
|---|---|---|---|
| Through a QR code | 18,029 | 229 | 1.3% |
| Link clicks | 3,574 | 177 | 5.0% |
| All | 21,603 | 406 | 1.9% |

The visits came from 390 workspaces, the in-app ones from 45. The split held over 90 days (23 August to 20 November 2026): 548 of 49,629 QR code visits (1.1%) against 379 of 6,852 link clicks (5.5%).

Which apps, over the 30 days. QR code visits in an in-app browser: unnamed Android web views 109, the Google app 61, WeChat 44, LINE 7, Snapchat 6, Facebook 2. Link clicks: LinkedIn 114, Instagram 42, Facebook 11, unnamed Android web views 7, the Google app 3.

**What it does not show.** These are Linkbreakers customers' visits, 83% of them through QR codes, not the web at large, so they say nothing about how many people use in-app browsers in general. The numbers are small: 406 in-app visits in 30 days, and all 114 LinkedIn clicks came from one workspace. A device is counted under the browser it used most recently. A "QR code" visit inside Instagram or Facebook is probably a code's address shared in the app, not a camera scan. The robust part is the gap between the two ways in, which held in both windows.

## Detecting and routing in-app browser visitors in Linkbreakers

Every Linkbreakers QR code and link runs a workflow: the steps that happen after a scan or click. On each visit by a person, Linkbreakers reads the user agent and records the in-app browser, at the Basic and Advanced data collection levels: one of 12 named apps (Instagram, Facebook, Messenger, Threads, TikTok, Snapchat, LinkedIn, Pinterest, X, WeChat, LINE and the Google app), **Other in-app browser** for an Android web view that names no app, or none for a regular browser. It keeps the app's version and the details the app writes, such as its language and the phone model, and shows them on the visitor's device, in an analytics breakdown by app and version ("Instagram 447"), in CSV exports and in webhooks. See [what data you can collect from QR code scans](/help/article/what-data-you-can-collect-from-qr-code-scans-location-device-behavior).

The **[Device Browser condition](/workflow-steps/device-browser-condition)** routes on it. Each option is either a browser or an in-app browser, so you can send **Any in-app browser** to a [message page](/workflow-steps/message-page) that asks the visitor to open the link in Safari or Chrome, and everyone else straight to your page. A visit in an in-app browser never matches Safari or Chrome, even though it is built on the same engine. Routing works at every data collection level.

Linkbreakers does not force the link out of the app: the visitor still taps the app's menu. The setup, step by step, is in [how to know which app a click came from and route in-app browser visitors](/help/article/how-to-detect-and-route-in-app-browser-visitors).

### What that gives you

Say you run a yoga studio. Your booking link is in your Instagram bio, and your booking page signs people in with Google. Someone taps it in Instagram, taps "Sign in with Google", and can get Google's `disallowed_useragent` error instead of a booking. With the Device Browser condition first, people in Instagram's browser see a one-line page: open this link in Safari or Chrome to sign in with Google. They tap the menu, sign in where Google allows it, and book the class instead of leaving on an error page. Everyone else books as before, and your analytics show how many visitors came from Instagram's browser.

## Limits and caveats

- **The apps do not document their in-app browsers.** What Instagram, Facebook and TikTok run inside them is known from research (Krause, 2022) and from their user agents, not from the companies. What was true in 2022 may not be true today.
- **The rules move with each system version.** Apple Pay's script rule changed in iOS 16, Safari View Controller's cookies in iOS 11, and Google tightened its sign-in policy in 2017 and 2021. Test your own page inside the apps your visitors use.
- **User agent detection depends on the app.** An app that names itself is easy to recognise; one that rewrites its user agent, or an iPhone web view that names no app, looks like a regular browser.
- **Our measurement is our traffic.** The 1.3% and 5.0% come from Linkbreakers customers' visits over 30 days, with small per-app counts.

## Frequently asked questions

### What is an in-app browser?

The browser window an app such as Instagram, TikTok or Facebook opens inside itself when you tap a link, instead of sending you to Safari or Chrome. It is either a web view, a browser engine the app controls, or a browser tab the app does not control (SFSafariViewController on iPhone, Custom Tabs on Android).

### Is a webview the same as an in-app browser?

A web view (often written "webview") is the building block: the component an app uses to show a web page inside its own screen. An in-app browser is what you see when an app uses one to open a link. On phones, those are Apple's WKWebView and Android's WebView.

### Why am I not logged in when I open a link in Instagram or TikTok?

Because a web view keeps its own cookies, separate from Safari's or Chrome's. Your sign-in lives in your browser's cookies, so the app's browser does not have it. Open the page in your browser, where your sign-in is.

### Can Instagram or TikTok see what I type on a website opened in their app?

A web view lets the host app run code on the page, and RFC 8252 says such an app "can record every keystroke entered in the login form". In 2022, Felix Krause showed that TikTok's iPhone app subscribed to keystrokes on pages in its browser; TikTok said the code existed but was not used. Whether any app does so today is not documented. A page opened in your own browser, or in a browser tab like SFSafariViewController, cannot be scripted by the app.

### How do I open an Instagram link in Safari?

Use the menu of Instagram's browser, often three dots at the top, and choose the option to open the page in your browser. If there is none, copy the link and paste it into Safari or Chrome. In the TikTok browser, the Facebook webview or any other app, look for the same option in its menu, and copy the link when there is none.

### Why does Sign in with Google fail inside an app?

Google refuses its sign-in in embedded web views and shows a `disallowed_useragent` error. It announced that all embedded web views would be blocked from September 30, 2021. Google warns that a site opened in a messaging or news app's web view may be affected too.

### How can my website detect the Instagram browser?

Read the user agent. The Instagram browser writes `Instagram` followed by its version, Facebook writes `FBAN/` or `FB_IAB/`, TikTok `musical_ly`, and an Android web view `; wv)`. An app can rewrite its user agent, so treat it as a strong signal, not proof.

### Does changing my default browser stop apps from using their in-app browser?

No. The default browser setting decides where links open when an app hands them to the phone. A page the app keeps in its own web view stays there.

### Do QR codes open in an in-app browser?

Scanned with the phone's camera, a QR code's link opens in your browser. Scanned from inside an app, such as WeChat or Snapchat, it can open in that app's browser. Across Linkbreakers over 30 days, 1.3% of visits through a QR code were in an in-app browser, against 5.0% of link clicks.

## Sources

1. [Apple Developer, WKWebView](https://developer.apple.com/documentation/webkit/wkwebview)
2. [Apple Developer, SFSafariViewController](https://developer.apple.com/documentation/safariservices/sfsafariviewcontroller)
3. [Apple Developer, SFSafariViewController, as archived on 28 July 2018](https://web.archive.org/web/20180728030638/https://developer.apple.com/documentation/safariservices/sfsafariviewcontroller)
4. [Apple, WWDC15 session 504, Introducing Safari View Controller](https://developer.apple.com/videos/play/wwdc2015/504/)
5. [Apple Developer, WKWebsiteDataStore](https://developer.apple.com/documentation/webkit/wkwebsitedatastore)
6. [Apple Developer, WKHTTPCookieStore](https://developer.apple.com/documentation/webkit/wkhttpcookiestore)
7. [Apple Developer, WKUserScript](https://developer.apple.com/documentation/webkit/wkuserscript)
8. [Apple Developer, `evaluateJavaScript(_:completionHandler:)`](https://developer.apple.com/documentation/webkit/wkwebview/evaluatejavascript(_:completionhandler:))
9. [Apple Developer, customUserAgent](https://developer.apple.com/documentation/webkit/wkwebview/customuseragent)
10. [Apple Developer, applicationNameForUserAgent](https://developer.apple.com/documentation/webkit/wkwebviewconfiguration/applicationnameforuseragent)
11. [Apple Developer, WKDownload](https://developer.apple.com/documentation/webkit/wkdownload)
12. [Apple Developer, `webView(_:requestMediaCapturePermissionFor:initiatedByFrame:type:decisionHandler:)`](https://developer.apple.com/documentation/webkit/wkuidelegate/webview(_:requestmediacapturepermissionfor:initiatedbyframe:type:decisionhandler:))
13. [Apple Developer, NSCameraUsageDescription](https://developer.apple.com/documentation/bundleresources/information-property-list/nscamerausagedescription)
14. [WebKit blog, MediaRecorder API (23 November 2020), "getUserMedia in WKWebView"](https://webkit.org/blog/11353/mediarecorder-api/)
15. [WebKit blog, New WebKit Features in Safari 13, "Apple Pay in WKWebView"](https://webkit.org/blog/9674/new-webkit-features-in-safari-13/)
16. [Apple, WWDC19 session 518, What's New for Web Developers](https://developer.apple.com/videos/play/wwdc2019/518/)
17. [Apple Developer, Safari 16 Release Notes](https://developer.apple.com/documentation/safari-release-notes/safari-16-release-notes)
18. [Apple, Wallet Developer Guide (archive), Distributing Passes](https://developer.apple.com/library/archive/documentation/UserExperience/Conceptual/PassKit_PG/DistributingPasses.html)
19. [Apple, Human Interface Guidelines, Web views](https://developer.apple.com/design/human-interface-guidelines/web-views)
20. [Apple Developer, Preparing your app to be the default web browser](https://developer.apple.com/documentation/xcode/preparing-your-app-to-be-the-default-browser)
21. [Apple Support, Change your default apps for features on iPhone and iPad](https://support.apple.com/en-us/121430)
22. [Apple Support, Scan a QR code with your iPhone or iPad](https://support.apple.com/en-us/102680)
23. [Android Developers, WebView reference](https://developer.android.com/reference/android/webkit/WebView)
24. [Android Developers, Build web apps in WebView](https://developer.android.com/develop/ui/views/layout/webapps/webview)
25. [Android Developers, WebChromeClient reference](https://developer.android.com/reference/android/webkit/WebChromeClient)
26. [Chrome for Developers, Overview of Android Custom Tabs](https://developer.chrome.com/docs/android/custom-tabs)
27. [Chrome for Developers, User-Agent Strings (source, updated 9 November 2021)](https://github.com/GoogleChrome/developer.chrome.com/blob/main/site/en/docs/multidevice/user-agent/index.md)
28. [Android Developers Blog, User-Agent Reduction on Android WebView (6 December 2024)](https://android-developers.googleblog.com/2024/12/user-agent-reduction-on-android-webview.html)
29. [Google Developers Blog, Modernizing OAuth interactions in Native Apps for Better Usability and Security (22 August 2016)](https://developers.googleblog.com/modernizing-oauth-interactions-in-native-apps-for-better-usability-and-security/)
30. [Google Developers Blog, Upcoming security changes to Google's OAuth 2.0 authorization endpoint in embedded webviews (29 June 2021)](https://developers.googleblog.com/upcoming-security-changes-to-googles-oauth-20-authorization-endpoint-in-embedded-webviews/)
31. [Google for Developers, OAuth 2.0 Policies, "Use secure browsers"](https://developers.google.com/identity/protocols/oauth2/policies)
32. [IETF, RFC 8252, OAuth 2.0 for Native Apps (BCP 212, October 2017), section 8.12](https://www.rfc-editor.org/rfc/rfc8252)
33. [IETF, RFC 9110, HTTP Semantics, section 10.1.3 (Referer)](https://www.rfc-editor.org/rfc/rfc9110)
34. [Frank Li, Shim Shimmeny: Evaluating the Security and Privacy Contributions of Link Shimming in the Modern Web, USENIX Security 2020](https://www.usenix.org/system/files/sec20fall_li-frank_prepub.pdf)
35. [Felix Krause, iOS Privacy: Instagram and Facebook can track anything you do on any website in their in-app browser (10 August 2022, updated 11 and 14 August 2022)](https://krausefx.com/blog/ios-privacy-instagram-and-facebook-can-track-anything-you-do-on-any-website-in-their-in-app-browser)
36. [Felix Krause, iOS Privacy: InAppBrowser.com, see what JavaScript TikTok, Instagram and Facebook inject (18 August 2022)](https://krausefx.com/blog/announcing-inappbrowsercom-see-what-javascript-commands-get-executed-in-an-in-app-browser)
37. [Google, Pixel Phone Help, Scan QR codes with your Pixel phone](https://support.google.com/pixelphone/answer/16561572)
38. Linkbreakers api: the in-app browser parser and its user agent fixtures recorded from production visits, read 21 November 2026
39. Linkbreakers production data, read-only queries over visits by people, 22 October to 20 November 2026 and 23 August to 20 November 2026, run 21 November 2026

## Last reviewed

21 November 2026, by Laurent Schaffner: every Apple, Android, Google and IETF statement read at its source, Felix Krause's 2022 posts and the replies he published read in full, the user agents taken from visits recorded in production, the in-app shares measured on Linkbreakers traffic, and the Device Browser condition checked in the app and the api.
