Why Shopify Still Shows "Translation Missing" After You've Translated Everything
"Translation missing" survives a full pass through Translate & Adapt because Shopify splits store content into layers that don't share one translation queue — theme strings, product/page resource content, metafields, and metaobjects each need their own pass, and one of them silently excludes any field that isn't set to public Storefront API access. Here's the layer you skipped, the exact admin path to check it, and the GraphQL query that finds what Translate & Adapt's own dashboard doesn't show you.
"Translation missing" keeps showing up after a full translation pass because Shopify splits store content into several separate translation surfaces that don't share one queue, and finishing one doesn't touch the others. If you've only worked through Translate & Adapt's product and page list, you've translated one layer out of at least four — theme strings, resource content, metafields, and metaobjects each need their own pass, and metafields specifically stay invisible to translation until you've created a metafield definition for them first.
That's the gap in almost every existing guide to this error: they treat "translate the store" as one job with one finish line. It isn't. Below is what each layer actually covers, the specific place merchants lose content without realizing it, and how to check programmatically instead of clicking through every tab hoping you didn't miss one.
What "translation missing" actually means
The placeholder appears when a theme requests a string key from the active locale's translation file and that key has no value — a fallback baked into Shopify's Liquid rendering, not a bug. For a single-language store this is rare, because everything renders from locales/en.default.json and there's nothing to be missing. It shows up once you add a second language, because a new locale file starts as a partial or empty copy of the default, and any string your theme references that isn't in it renders the placeholder instead of silently falling back to English.
That's layer one, and it's the only layer most existing "fix translation missing" guides cover: static theme strings — section labels, button text, cart copy, anything hardcoded into .liquid files or schema settings. You fix these inside Translate & Adapt's Theme content tab, one string at a time, or by editing the raw locale JSON directly through Online Store > Themes > Edit code. If that's the only place you've looked, you've only fixed the layer that's easiest to find and the smallest in practice.
The layer that actually holds your content: resource translations
Product titles, descriptions, collection copy, blog posts, pages, and store policies aren't theme strings — they're what Shopify's docs call translatable resources, and they live in a completely separate system from the theme locale files. Per Shopify's own Translate & Adapt documentation, the app covers products, collections, blog posts, policies, and pages, plus theme elements like logos, URL handles, and uploaded localized images. Crucially, the same page lists what it explicitly does not cover: collection filters, content submitted through the Shopify Forms app, manual payment method instructions, product images themselves, and tags. If your "missing" translation is a filter label, a custom form field, or a tag-driven badge, Translate & Adapt was never going to catch it — that content has to be translated some other way (a theme string, a metafield, or not at all), and no amount of re-running the auto-translate button fixes it.
The documentation also confirms something worth knowing before you assume a fix failed: after you activate automatic translations or update a single resource, "translations will take a few minutes to display on your storefront." If you save a translation and immediately reload the live page in an incognito window, you may still be looking at a caching or propagation gap, not a broken fix.
Metafields: the layer that's invisible for a reason nothing on the storefront tells you
This is the part almost nobody writes about, and it's usually where "I translated everything and it's still missing" actually comes from. Per Shopify's own documentation on managing translated content, you can translate a metafield "only if it's publicly accessible" — meaning its definition's Storefront API access must be set to Accessible in Storefront API (public_read) in Settings > Custom data > [resource] > edit definition > Access, not the default Hidden from Storefront API. Here's the trap: per Shopify's metafields documentation, "this setting doesn't affect Liquid templates — metafields are always accessible in Liquid regardless of this setting." A metafield can render perfectly on your default-language storefront through Liquid while being completely invisible to Translate & Adapt, and nothing about how the page looks tells you that's the reason.
Field type is a second, separate filter. Shopify's metafield data type reference lists single line text, multi-line text, rich text, JSON, link, and URL fields as translatable. A cluster of reference types — product, collection, page, variant, article, and metaobject references — are "market localizable" instead, which means Shopify resolves the linked object per market rather than translating text inside the field. File references and most numeric, boolean, date, and measurement types support neither. If your theme pulls a size chart or spec table out of a metafield type that isn't on the translatable list, re-running Translate & Adapt will never pick it up — the field itself has to change, not the translation workflow.
Metaobjects need the same access check plus one more step: per Shopify's documentation on metaobject capabilities, "the translatable capability allows the fields of a metaobject to be translated" — and it's opt-in per definition, not automatic. If you built a metaobject-driven content block (a features grid, a specs table, a custom FAQ list) and never turned that capability on when you created the definition, every entry is rendering in one language only, regardless of what your product and page translations look like.
Why a correct translation still doesn't show up on the storefront
Two failure modes look identical to "translation missing" but aren't a translation problem at all — they're a routing problem. If your store uses subfolder or subdomain markets (a UK visitor lands on /en-gb/, a French visitor on /fr/), a visitor who never gets routed to the correct market URL never sees the translated content, no matter how complete it is. That routing depends on your Settings > Markets configuration and, if you're relying on it, on geolocation working correctly for that visitor's network — a VPN, a corporate proxy, or an ad-blocker that strips geolocation scripts will all quietly put a shopper back on the default-language version.
The second is a caching problem, not a Markets problem: CDN or third-party page-cache layers (including some page-speed and app-embedded caching tools) can serve a stale, pre-translation snapshot of a page for longer than the "few minutes" Shopify's own documentation describes. If you've confirmed a resource is translated inside Translate & Adapt but a hard-refreshed, cache-busted URL still shows the original language, the cache — not the translation — is the thing to clear next.
How to actually find what's missing, instead of guessing
- Check theme strings first. In Translate & Adapt, filter the Theme content tab by your target language and look for empty fields — this is the fastest way to catch layer one without opening every section manually.
- Check resource coverage by content type. Work through Translate & Adapt's Products, Collections, Pages, Blog posts, and Policies tabs individually. A store with 40% of products translated and 100% of pages translated will still throw "missing" constantly on product pages, and the dashboard's overall percentage can mask that split.
- Check metafield access and type before assuming a metafield is broken. In Settings > Custom data, open the definition and confirm Storefront API access is set to "Accessible in Storefront API," not the default "Hidden" — and confirm the field type is on Shopify's translatable list. A metafield rendering fine in Liquid tells you nothing about either setting.
- Check the metaobject's "translatable" capability. Open each metaobject definition your theme depends on and confirm the translatable capability was turned on when it was created. An entry can look complete in your default language and simply not exist in any other.
- Rule out routing and caching by opening the specific market URL directly in an incognito window with any page cache or CDN cache purged, rather than trusting the language switcher in a session that may already have a locale cookie set.
The developer check: query translation coverage instead of clicking through it
For a catalog too large to eyeball tab by tab, Shopify's Admin GraphQL translatableResources query returns exactly what content exists for a resource type and what's translatable about it, which you can diff against your actual translations per locale:
query {
translatableResources(first: 50, resourceType: PRODUCT) {
edges {
node {
resourceId
translatableContent {
key
value
locale
}
}
}
}
}Pair that with a per-resource translatableResource(resourceId: ...) { translations(locale: "fr") { key value } } call and you can script a real coverage report — every product ID, every field key, and whether a translation value exists for your target locale — instead of relying on Translate & Adapt's dashboard percentage, which counts a resource as "translated" even when only some of its fields have a value in that language.
Who should skip this entirely
If your store sells in one language and one market, none of this applies — "translation missing" on a single-locale store almost always means a theme update introduced a new string that was never added to en.default.json, which is a one-line fix, not a translation architecture problem. This is also not worth building custom tooling for if you're only missing a handful of strings on one or two pages; work through the checklist above by hand first, and reach for the GraphQL query only once manual review can't keep up with your catalog size.
Multi-market storefronts with a real product catalog are where this compounds — the difference between "translated" and "actually showing translated" tends to live in exactly the metafield and metaobject gap above, and it's the kind of setup problem worth catching before a launch rather than after a UK or Canadian customer reports it. It sits next to the broader Markets configuration decisions we cover in our piece on Shopify's Managed Markets duties settings and in our guide to fixing DDU/DDP checkout setup for US orders, and it pairs directly with the indexing side of the same problem in our hreflang and canonical architecture guide for Shopify Markets.
If you're auditing a multi-language catalog and want the metafield and metaobject coverage gaps found before customers hit them, this is the kind of Markets and localization work we do — get in touch and we'll tell you plainly how much of your catalog is actually translated versus how much just looks that way in the dashboard.