Using Cookie Editor to Test Website Preferences Like a QA Pro
How testers use Cookie Editor properly: set up states a UI cannot reach, check expiry behaviour, and record results so a bug can be reproduced.
For testers and developers, Cookie Editor's real value is reaching states the website's own interface cannot produce: a preference set to a value the UI never offers, a consent choice half-recorded, a cookie about to expire. Used with a bit of discipline, backups, one change at a time, written notes, it turns “it forgot my settings once” into a reproducible bug report. This workflow assumes you are testing a site you own or are authorised to test.
Set up a clean test rig
- Use a dedicated browser profile for testing, so test cookies never mix with your daily sign-ins, and install Cookie Editor only there if you prefer.
- Create a test account and a test page whose preferences you can change freely (theme, language, region are ideal).
- Export the site's cookies before a test session and name the file with the date and starting state, that export is your reset button.
- Keep a simple log: cookie name, starting value, change made, expected result, actual result. Five columns save hours later.
Four tests worth running on any preference system
- Boundary values, Set the preference cookie to values the UI cannot produce (an unsupported language code, an empty value, a very long string). The site should fall back gracefully to a default, not break or show raw errors.
- Expiry behaviour, Edit a persistent cookie's expiry to a minute in the future, wait, and reload. The site should treat the preference as gone and re-ask or reset cleanly. Then test a session cookie by restarting the browser.
- Consent states, Set the consent cookie to accepted, rejected and missing in turn, reloading between each. Banners, analytics and embedded content should match the recorded choice every time.
- Profile and scope differences, Check the same preference in a second profile and on a subdomain if the site has one. Domain and path scope bugs (see Cookie Fields Explained) hide exactly here.
Test like the site is hostile to your edits
Remember that the site may rewrite cookies on every load from server-side state, if your edit keeps reverting, you have found a fact about the architecture, not a failed test; the edits-not-saving guide explains how to prove which side rewrote it. Record that behaviour in the bug report with the before/after field comparison; it is exactly the evidence a developer needs.
Keep the testing safe and in scope
Only test sites you own or have permission to test, and only with accounts created for testing. Never use a cookie editor to replay someone else's session cookie or to reach an account that is not yours, that is session hijacking, not testing, and the line is explained in Never Share Your Sign-In Cookies. Within your own test environment, though, cookie manipulation is a legitimate, everyday QA technique.
A worked test session, start to finish
Suppose the task is: 'Check the new consent banner behaves for a returning visitor.' A tester using Cookie Editor properly might run it like this. Start from a clean state by deleting the site's cookies, load the page, accept the banner, and record the consent cookie's name, value and expiry from the panel. Reload: no banner, as expected. Now edit only the expiry into the past and reload: the banner returns, proving the site reads the cookie rather than remembering the choice server-side. Finally, change the value to the 'rejected' state the developers specified and reload: the banner stays away but the optional features stay off. Four checks, each changing one variable, each recorded. That is a test session a developer can reproduce from the notes alone.
Recording results so bugs can be reproduced
| Field | Example entry | Why it matters |
|---|---|---|
| State before | consent = accepted, expiry +6 months | Proves the starting point |
| Change made | Expiry edited to yesterday | One variable, named exactly |
| Expected | Banner shown again on reload | Written before reloading, not after |
| Observed | Banner shown; analytics cookie absent | What actually happened, plainly |
| Verdict | Pass | Tied to the expectation, not a feeling |
The discipline in that table, writing the expectation before the reload, is what separates testing from clicking around. Cookie states are invisible by nature, so the log is the only evidence a session happened the way you remember it. Keep logs with the same care as the states themselves, though: a log that includes a live session value has the same problem as an export left in a downloads folder. Names, states and expiries belong in logs; secret values never do.
States worth having in your toolkit
- First visit: no cookies at all, the baseline every flow should survive.
- Consented and rejected: both consent values, checked separately, because sites test the happy path and forget the other.
- Aged states: a preference whose expiry is minutes away, to watch the renewal or reset happen.
- Wrong-scope states: the same name at two paths, to confirm the page reads the one you think it does.
- Signed-out with preferences: the state most real users are actually in, and the one least often tested.
Frequently Asked Questions
How is this different from using DevTools?
DevTools can do the same jobs, and developers often prefer it. Cookie Editor's advantage is speed and focus: one panel, no console, and easy import/export of whole states, handy for testers who are not living in DevTools all day.
Can I automate these tests?
For regression suites, yes, browser automation frameworks can set cookies directly before a page loads. Cookie Editor remains the better tool for exploratory testing and for demonstrating a state to a human.
What should a bug report include?
The cookie's name, domain and path; the value before and after; the exact steps; what you expected and what happened; browser and extension versions. Never include a real session value, recreate the bug on a test account.


