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 layer | What to record | Question to answer |
|---|---|---|
| Browser environment | Environment ID, browser engine version, task owner | Which browser environment is being inspected? |
| Page and storage context | Top-level site, embedded origin, cookie scope, and partition key | Which copy of the state can the current page use? |
| Platform result | Displayed identity, permissions, verification prompts, and request result | Does 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 method | Top-level site | Partition context for the example cookie |
|---|---|---|
| Use the embedded service in Portal A | https://shop-a.example | Partition corresponding to Portal A |
| Use the same service in Portal B | https://portal-b.example | Partition corresponding to Portal B |
| Open the service directly | https://auth.example | Context 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:
- 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.
- 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.
- 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.
- 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:
| Finding | Next check | Who should handle it |
|---|---|---|
| Direct access works, but the embedded path asks for verification | Top-level site, embedded origin, partition key, and browser prompts | Site or login integration owner |
| A cookie appears in the table, but the request does not include the expected state | Scope, expiration, access policies, and request details | Site technical lead |
| The request completes, but the page shows an identity that differs from what the task expects | Actual signed-in account, redirect path, and authorization records | Account owner |
| A consistent difference appears after an update | Browser engine, extensions, site version, and configuration changes | Environment 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.


