Back to blog

How to Check Cookie Isolation in a Fingerprint Browser: From Site Partitioning to Login Troubleshooting

Why might the same service show different login states when opened directly versus embedded on another website? Drawing on official Chrome and MDN resources, this article explains browser environments, storage partitioning, and platform sessions, and shows where to check cookies and how to verify results side by side.

The same service may show you as signed in when you open it directly from the address bar, but ask you to verify your identity again when it’s embedded in a panel on another website. Or a technician may find several cookies with the same name in one environment and wonder whether sessions have been mixed.

When checking cookie isolation in a fingerprint browser, keep track of three things: the current browser environment, the top-level site shown in the address bar, and the origin of the embedded service. Map these to the cookie scope, partition key, and actual request to determine which layer is causing the login discrepancy.

Source check: November 17, 2026. This article explains the mechanisms based on Chrome’s official documentation on storage partitioning, CHIPS, and DevTools, as well as MDN’s documentation on Firefox. The checklist and test plan are recommendations from this article, and all example sites are fictional. Actual behavior depends on the current browser engine, site implementation, and policies.

Record the Environment, Site Partition, and Login Result Separately

Use the following sequence to create an inspection record:

Inspection layerWhat to recordQuestion to answer
Browser environmentEnvironment ID, browser engine version, task ownerWhich browser environment is being inspected?
Page and storage contextTop-level site, embedded origin, cookie scope, and partition keyWhich copy of the state can the current page use?
Platform resultDisplayed identity, permissions, verification prompts, and request resultDoes the platform recognize the current login and action?

Use this table to locate the issue. To verify a login, check the identity and permissions actually displayed by the platform. To analyze cookies, check each one against its origin and browsing context.

Chrome’s documentation explains that Storage Partitioning divides third-party storage according to contexts such as the top-level site. This applies to APIs including Local Storage and IndexedDB. Even when the embedded resource has the same origin, changing the top-level site may put it in a different storage partition. Read Chrome’s storage partitioning documentation

Understand Partitioned Cookies Through an Example

Suppose a team has two portals, https://shop-a.example and https://portal-b.example, and both embed the service at https://auth.example. The service uses a CHIPS partitioned cookie to store a piece of state.

Chrome’s CHIPS documentation explains that cookies with the Partitioned attribute are partitioned by top-level site, and that partitioned cookies also require the Secure attribute. The partitioned cookie the service sets on Site A does not automatically become the same cookie it uses on Site B or when accessed directly. Read the official CHIPS documentation

Access methodTop-level sitePartition context for the example cookie
Use the embedded service in Portal Ahttps://shop-a.examplePartition corresponding to Portal A
Use the same service in Portal Bhttps://portal-b.examplePartition corresponding to Portal B
Open the service directlyhttps://auth.exampleContext where the service itself is the top-level site

So, having the same service domain or cookie name is not enough to prove that two cookies belong to the same state. Also check the Domain, Path, and Partition Key. This example describes behavior when partitioned cookies are used; a real site may use other login methods, so check its actual implementation.

Distinguish CHIPS From General Storage Partitioning

CHIPS concerns cookies with the Partitioned attribute. Chrome’s Storage Partitioning documentation also covers other storage and communication APIs. When troubleshooting a login issue, first identify the mechanisms the site actually uses, then choose where to inspect them.

For example, an embedded panel may rely on Local Storage to save its UI state, while another service relies on cookies to maintain a session. Check each separately. Looking only at the cookie table may not cover all the state used by the page.

Browsers also differ. MDN’s State Partitioning guide describes how Firefox partitions state by top-level site, as well as situations where access to specific storage is granted through mechanisms such as the Storage Access API. This documentation describes Firefox’s implementation; keep separate records when testing across browser engines. Read MDN’s Firefox documentation

For operations teams, the most practical approach is to record the current version and access path. Apply an environment’s observations first to tasks with the same conditions, then verify them on other versions or browser engines.

Check Storage and Requests in DevTools

In an authorized test account or a system you own, reproduce the issue once. Record when it occurred, the complete access path, and any page prompts, then open DevTools.

Chrome’s official instructions for viewing cookies are Application → Storage → Cookies. Select the relevant origin and inspect its fields. You can also check cookies associated with a request under Network → corresponding request → Cookies, and use any warnings and Issues information to help locate the problem. Read the official DevTools guide

Recording details in the following order usually makes it easier to connect what you observe with the cause:

  1. Confirm the page context. Note the top-level site in the address bar and the origin that actually handles the login or displays the content.
  2. Confirm the cookie scope. For the relevant origin, check fields such as Name, Domain, Path, expiration, Secure, SameSite, and Partition Key. The exact columns may vary by version.
  3. Confirm the request result. Find the request that triggered the issue. Check its related cookie information, browser prompts, and response, and record the cause observed at the time.
  4. Verify the business identity. When the page returns, check the account and permissions displayed by the platform to confirm whether the intended login flow completed.

For troubleshooting records, retain field names, scope, partition key, and error details. If you need to save or share cookie values, request headers, or complete network logs, follow your team’s sensitive-data handling practices. Use redacted records when describing the issue externally.

Set Up Two Comparison Checks in PurpleMark

PurpleMark’s environment groups, startup pages, and member permissions let you consolidate login verification tasks in clearly defined test environments. To set up a checking workflow, first download the PurpleMark client, then create and name test environments in the client’s environment management area. Record each environment’s ID, browser engine, and owner.

Run two rounds, changing one condition at a time:

Round 1: Compare access methods in the same environment. Keep the account and other settings fixed. In turn, access the service directly and open its embedded panel from the portal, following the paths supported by the business. Record the top-level site, embedded origin, partition key, request prompts, and final identity. If the results differ between the two paths, continue investigating the context and the site’s login flow.

Round 2: Compare the same access method across environments. Assign a different authorized test account to each of two environments. Keep the access method and inspection steps consistent, then check each environment’s expected identity. This makes it clear which account performed which task in which environment. If the same account is deliberately signed in to both environments and the same identity appears, use the operation records to interpret the result.

A startup page for each environment can help team members return to a consistent entry point. Record both the portal entry point and the destination page after login in the test plan, so the next person does not have to repeat troubleshooting because the access path changed.

Use Your Findings to Decide What to Do Next

Narrow down the issue to a description that can be handed off, then assign it to the right person:

FindingNext checkWho should handle it
Direct access works, but the embedded path asks for verificationTop-level site, embedded origin, partition key, and browser promptsSite or login integration owner
A cookie appears in the table, but the request does not include the expected stateScope, expiration, access policies, and request detailsSite technical lead
The request completes, but the page shows an identity that differs from what the task expectsActual signed-in account, redirect path, and authorization recordsAccount owner
A consistent difference appears after an updateBrowser engine, extensions, site version, and configuration changesEnvironment and business owners

A partition key or warning is a clue for locating the issue; confirm your conclusion against the complete flow. Save what you observed first, then change one variable at a time and retest in a test environment. For site integration issues, have the site’s maintainers address them using a supported authentication method.

A handoff-ready inspection result should explain which environment and access method reproduced the issue, which identity was used, what the browser recorded, what the final business result was, and who owns the next step. Connecting these details makes cookie checks useful for verifying real account workflows.