- Safari’s Intelligent Tracking Prevention (ITP) deletes cookies created in JavaScript, and all other script-writable storage, after 7 days without user interaction with the site. It is not a blanket “all cookies die after 7 days” rule.
- Two other limits sit on top: persistent JavaScript-set cookies are capped at 24 hours when the visitor arrived from a domain ITP classifies as tracking and the landing URL has a query string or fragment, and cookies set in HTTP responses are capped at 7 days when the request is third-party CNAME or IP cloaked.
- Ordinary first-party cookies set in an HTTP response by your own server are not subject to the JavaScript rules. That is why setting analytics and ad cookies server-side helps, but it is a mitigation, not a cure.
- Third-party cookies are blocked in Safari with no exceptions. Chrome, as of the Google page checked in October 2026, still leaves third-party cookie choice with the user.
- For a WordPress site the practical effects are returning visitors who look new, and click and browser IDs (_ga, _fbp, _gcl_aw) that disappear before a late conversion. Measure your own Safari share before deciding how much effort this deserves.
“Safari deletes cookies after seven days” is half true, which is the most dangerous kind of true. The rule exists, it does hit WordPress analytics, and it is regularly applied to the wrong things: server-set cookies, login sessions, even ad platform tracking that never relied on a browser cookie. This post goes through what WebKit actually documents, what that means for the cookies your site and ad tags create, where server-side cookie setting helps and where it does not, and how to check all of it in Safari yourself. It is part of our privacy and browsers series; the hub is Consent Mode v2 on WordPress.
What ITP actually deletes
ITP is Safari’s tracking-prevention system. WebKit documents its current behaviour on its tracking prevention page. The sentence most people mean is this one:
“ITP deletes all cookies created in JavaScript and all other script-writeable storage after 7 days of no user interaction with the website.”
Three details matter.
-
“Created in JavaScript” is the scope. A cookie written by
document.cookieis in scope. WebKit lists other script-writeable storage as well: IndexedDB, LocalStorage, media keys, SessionStorage and Service Worker registrations and cache. - The clock is about interaction, not creation. When the rule was introduced, WebKit described it as deleting script-writable storage “after seven days of Safari use without user interaction”. The counter counts days Safari was used, and interaction with the site (a click or tap on the page) restarts the count. A visitor who comes back every few days and taps around keeps their JavaScript-set cookies; one who returns after two weeks away does not.
-
It grew in steps. ITP 2.1 (February 2019) capped persistent
document.cookiecookies to seven days. ITP 2.3 (September 2019) extended deletion to non-cookie script-writeable data. The March 2020 release (iOS and iPadOS 13.4, Safari 13.1) added full third-party cookie blocking and the broader script-writable-storage rule.
Home-screen web apps are the one case WebKit calls out as separate: “Web applications added to the home screen are not part of Safari and thus have their own counter.”
The 24-hour cap for link-decorated navigations
The second rule targets link decoration: adding an identifier to a URL’s query string or fragment, the way ?fbclid=... or ?gclid=... rides along on a click. ITP 2.2 (April 2019) capped document.cookie cookies to one day when both conditions held: a domain classified with cross-site tracking capabilities navigated the user to the page, and the final URL has a query string and/or fragment identifier. WebKit’s current page puts it this way: ITP “detects such link decoration and caps the expiry of cookies created in JavaScript on the landing webpage to 24 hours.”
Notice the conditions. A visitor arriving with a plain URL, or from a domain ITP has not classified, does not trigger it. ITP’s classification of domains is WebKit’s own and you cannot look it up, which is why this rule is hard to reproduce on demand. ITP 2.3 also downgrades document.referrer to the referrer’s eTLD+1 in the same situation, so a landing page can lose the full referring URL as well.
JavaScript-set versus server-set cookies
This is the distinction that decides most real-world outcomes. A cookie reaches the browser in one of two ways:
- A script runs in the page and writes it (
document.cookie = "..."). Browser tags typically do this for the cookies they manage; Meta describes the Pixel as saving the_fbpidentifier itself. - Your server sends a
Set-Cookieheader in an HTTP response, and the browser stores it.
// JavaScript-set: in ITP's 7-day / 24-hour scope
document.cookie = "_example=abc; max-age=63072000; path=/";
// Server-set: header on the HTTP response
Set-Cookie: _example=abc; Max-Age=63072000; Path=/; Secure; SameSite=Lax
WebKit’s ITP 2.1 post is explicit that cookies set in HTTP responses and flagged HttpOnly remain unaffected by that cap because script cannot read them. WebKit’s current page describes its default cookie policy as blocking third parties from setting new cookies, and names two situations that matter for you:
- Domains classified as engaged in bounce tracking “may have their cookies rewritten to SameSite=strict.” That is aimed at tracker domains, not your WordPress site.
- CNAME and IP cloaking, covered next.
CNAME and IP cloaking caps
Some tracking vendors asked customers to point a subdomain of their own site (say metrics.example.com) at the vendor with a DNS CNAME record, so the vendor’s cookies would look first-party. WebKit’s November 2020 post on this says ITP caps the expiry of cookies set in third-party CNAME-cloaked HTTP responses to 7 days. Its definition of cloaking is “a first-party subresource that resolves through a CNAME that differs from the first-party domain and differs from the top frame host’s CNAME, if one exists.” The current tracking prevention page adds that ITP “detects third-party CNAME cloaking and third-party IP address cloaking requests and caps the expiry of any cookies set in the HTTP response to 7 days.”
Two consequences. First, a subdomain that stays on your own infrastructure is not what the rule describes; WebKit’s post notes that first-party subdomains resolving to the same registrable domain receive no cap. Second, the cap cuts into the “put a vendor’s tracking server on a subdomain” approach, so a server-side setup is worth checking for which of the two it really is. I did not find a WebKit description of exactly how IP matching is judged, so treat anything more specific than the sentence above as unverified.
What is not affected
Quoting WebKit carefully, because the common summaries overreach:
- Cookies set in HTTP responses by your own first-party host are outside the JavaScript rules and the cloaking cap (unless the cloaking conditions above apply). WebKit does not publish a long-lifetime guarantee for them; its default policy is aimed at third-party cookies.
- Login and session cookies that your server sets in HTTP responses are not caught by the script-writable rule (WebKit’s ITP 2.1 post says HTTP-response cookies were unaffected by that cap).
- Anything else a visitor keeps interacting with. Interaction restarts the 7-day count for script-writable storage.
- Safari’s behaviour on your server. ITP is a browser policy. It does not stop your server from receiving requests or your order system from recording purchases.
Also worth knowing: WebKit’s page says all website data is deleted for classified domains that have not received user interaction as first-party in the last 30 days of browser use. That applies to the tracker domains, not to your site.
Where other browsers stand
ITP’s 7-day script-storage rule is specific to Safari. For the others, what I can state is limited to what primary sources say:
- Firefox: per MDN, Firefox enables Total Cookie Protection when Enhanced Tracking Protection is on, as it is by default, giving third-party cookies “a separate cookie jar per site”. Mozilla’s announcement describes it as a separate jar per website. MDN’s state partitioning guide says first-party cookies are not affected by storage partitioning. I found no equivalent of ITP’s lifetime cap for first-party cookies in those sources.
- Chrome: MDN says Chrome does not block third-party cookies by default, only in Incognito or when the user turns blocking on. Google’s October 17, 2025 update says Chrome will “maintain our current approach to offering users third-party cookie choice”, and that it is retiring a list of Privacy Sandbox technologies for low adoption. Google’s cookie overview page for developers adds that third-party cookies “may be blocked by browser restrictions, user settings, developer flags, or enterprise policy”. In short, per Google’s own post, third-party cookies remain a user choice in Chrome rather than being removed.
- Brave: MDN says it “blocks tracking cookies by default”. I could not verify anything about first-party cookie lifetimes in Brave, so I leave it out.
For the cross-browser picture of lost data, including ad blockers, see how much data ad blockers cost a WordPress site.
What this does to WordPress analytics and ads
I will not put a percentage on it. How much a given site is affected depends on how many visitors use Safari, how often they return, and how your tags are set up. The mechanisms, though, are clear.
Returning visitors look new
A browser tag identifies a returning visitor by an ID stored in a cookie. Google documents the _ga cookie with a two-year expiration in its ads cookie reference. If Safari deletes that JavaScript-set cookie after 7 days without interaction, the next visit gets a new ID. The visitor is counted as a new user in a tool that relies on that cookie. The effect is inflated new-visitor counts and fewer returning visitors, concentrated in Safari and in audiences that return less often than weekly (a monthly newsletter reader, a customer on a long buying cycle).
Attribution loses its early clicks
Ad platforms stitch a click to a later conversion with IDs stored in the browser. The documented lifetimes are long: Meta’s guidance for _fbc is a 90-day expiration (fbp and fbc parameters), and Google lists _gcl_au, _gcl_aw and _gcl_dc at 90 days. In Safari, if the click sets the cookie from JavaScript on a decorated landing URL from a classified domain, the cap can be 24 hours; and if the visitor does not come back and interact within 7 days, the cookie is gone before a purchase on day 10. The conversion then arrives without the click ID or browser ID, which weakens matching and can leave the purchase credited as direct or unattributed. Meta’s documentation notes you can rebuild _fbc from the fbclid in the URL if the cookie is absent, but only if you captured it at the time of the visit.
What the server still sees
Your order system does not run in the browser, so every real WooCommerce order still exists. What disappears is the identifier that ties an order to an earlier click. This is the same gap described in why your WordPress analytics data is missing and in WooCommerce server-side tracking, where we save fbp, fbc, GA client ID and click IDs on the order at checkout.
Why server-side cookie setting helps, and where it does not
If your server sets the cookie in a Set-Cookie response header, the JavaScript-specific ITP rules do not apply to it, which can extend how long an ID lasts in Safari. For a WordPress site this usually means a plugin or the server code setting the _fbp-style or first-party visitor ID, or capturing click IDs from the URL into a server-set cookie. We explain the wider trade-offs in client-side vs server-side tracking in WordPress.
The honest limits:
- The host matters. A cookie set by your own server on your own domain is the good case. A cookie set by a vendor’s server reached through a CNAME to a different host falls under the 7-day cloaking cap.
-
It does not rescue the click that never reached you. If the visitor arrives on a cached page where no code captures
fbclidorgclidfrom the URL, there is nothing to store. Page caching (WP Rocket, LiteSpeed, a CDN) can serve a page without running your PHP at all, so a server-set cookie must be set where the request is actually processed. -
Browser-side scripts can’t read HttpOnly cookies. If your ad pixel in the page needs to read its own ID from
document.cookie, an HttpOnly cookie hides it. Non-HttpOnly server-set cookies can be read, and the tag may still re-write them from JavaScript, at which point the JavaScript rules apply again. - Users can still clear cookies, and Safari has other protections. Server-set is not “permanent”.
- Consent still applies. Setting a tracking cookie from the server is still setting a tracking cookie. See does server-side tracking bypass consent?
- Server-side event forwarding does not bring cookies back. Forwarding events from the server to GA4 or Meta sends whatever identifiers you hold. If the identifier is gone, the event arrives with less to match on.
Check it yourself in Safari’s Web Inspector
You do not need a vendor’s word for any of this. On a Mac:
- Safari, Settings, Advanced, tick “Show features for web developers”. A Develop menu appears.
- Visit your site, then Develop, Show Web Inspector, and open the Storage tab. Look under Cookies for your domain.
- For each analytics and ad cookie (
_ga,_ga_*,_fbp,_fbc,_gcl_aw), note the Expires value and whether it is flagged HttpOnly. - In the Network tab, reload and click the document request. If the cookie appears in the response’s
Set-Cookieheaders, it is server-set. If it only shows up in Storage with no header, a script wrote it. - In the Console, run
document.cookie. It lists the cookies a script can read; HttpOnly cookies are absent from it. - Come back after a few days of normal Safari use without touching the site and compare the cookie list. I describe this procedure but did not test it against a specific Safari version, so read your own output, not mine.
One thing this test cannot do reliably is trigger the 24-hour link-decoration rule, because it depends on a referring domain WebKit classifies. If you see an unusually short Expires only on visits from certain ad clicks, that is consistent with the rule, but it is a hypothesis, not proof.
How to measure the impact on your own traffic
- Find your Safari share. In your analytics, look at browsers and operating systems. Check iOS and macOS separately, since phone and desktop audiences often differ. In Traculo’s website analytics this is the browsers, devices and operating systems breakdown.
- Compare new and returning behaviour by browser. If your tool reports new versus returning visitors, split it by browser. A much lower returning share in Safari than in Chrome or Firefox, for the same audience, is the symptom. It is not proof of cookie loss on its own: different browsers attract different audiences.
- Look at visits per visitor. Roughly one visit per visitor in Safari against more than that elsewhere points the same way.
- Compare conversions to orders. Take the orders in WooCommerce or your form system and the conversions each platform reports, and split by browser where you can. Large gaps concentrated in Safari are where server-side identifier capture pays off.
- Re-measure after any change. Change one thing, wait a full ITP window (at least 7 days), then look again.
If Safari is a small share of your audience, the business case for a rebuild is weak. If it is a third of your mobile traffic and you run paid campaigns with long buying cycles, it is worth an afternoon.
Frequently asked questions
Does Safari delete all cookies after 7 days?
No. WebKit says ITP deletes cookies created in JavaScript, and other script-writable storage, after 7 days without user interaction with the site. Cookies set by your server in HTTP responses are outside that rule.
Are WordPress login cookies affected?
Not by the JavaScript rule if your server sets them in HTTP responses.
Is Chrome still phasing out third-party cookies?
As of October 2026, the Google post I could verify (October 17, 2025) says Chrome will maintain its current approach of offering users third-party cookie choice. Check Google’s Privacy Sandbox pages for any later change.
Does server-side tracking fix ITP?
It helps where a first-party server sets the cookie, because the JavaScript-specific rules no longer apply to that cookie. It does not fix CNAME-cloaked setups, cached pages that never run your code, missing consent or cleared cookies.
Can I see the exact share of data lost in Safari?
No source gives a reliable figure, and it varies per site. Use the measurement steps above on your own data.
Related reading
- Consent Mode v2 on WordPress: the four signals
- Does server-side tracking bypass consent?
- How much data do ad blockers cost a WordPress site?
- Meta CAPI deduplication, event_id explained
- GCLID, GBRAID and WBRAID explained
- WooCommerce server-side tracking
- Why is your WordPress analytics data missing?
- Client-side vs server-side tracking in WordPress
To see how much of your traffic is Safari, start with the browser and device breakdowns in Traculo’s website analytics. It is free for up to 2,000 events a month, so you can check your own numbers before changing any tracking.