---
title: "Why am I getting en-us content? Locale fallback explained"
url: "https://developers.contentstack.com/guides/why-am-i-getting-en-us-content-locale-fallback-explained"
type: "guide"
level: "intermediate"
intent: "fix"
outcome: "You can tell why a request for one locale returns content from another, read the response to find out which case you are in, and fix it in the stack or in your query."
prerequisites:
  - "A stack with a master language and at least one other language"
  - "A delivery token and environment for the stack"
  - "Basic knowledge of the Content Delivery API or the TypeScript Delivery SDK"
tags:
  - "i18n"
  - "api"
authors:
  - "Tim Benniks"
published: "2026-12-10T09:00:00.000Z"
updated: "2026-11-15T10:56:30.328Z"
---

# Why am I getting en-us content? Locale fallback explained

- **Authors:** Tim Benniks
- **Published:** 2026-12-10T09:00:00.000Z
- **Updated:** 2026-11-15T10:56:30.328Z
- **Level:** Intermediate
- **Intent:** Fix
- **Tags:** i18n, api

---

You request locale=de-de, the response is a 200, and the text is English. Or your German page shows a German title with an English image caption and English author bio. Nothing errors, and nothing tells you which part came from where.

This hits every multi-language site at some point, whatever the framework: Next.js with i18n routing, Nuxt, Astro, or a static build that loops over locales. The cause is almost never a bug. It is one of a handful of localization rules doing exactly what they are designed to do.

## What you'll learn

- How fallback languages, localized and unlocalized entries relate


- Why publishing an unlocalized entry serves fallback content under the new locale


- What include_fallback and GraphQL fallback_locale change, and what they do not


- How to read a response to see which locale the content came from


- How locale codes, non-localizable fields, references and variants add to the confusion



## Symptoms

What you see

Likely cause

locale=de-de returns master language text with a 200

The entry was published in de-de without being localized

A German page mixes German and English fields

Non-localizable fields, or English referenced entries

Entries appear in de-de only when you add include_fallback=true

They are not published in de-de. Fallback fills the gap

GraphQL with fallback_locale: false still returns English

Same as the first row. The content is published in that locale

422 with error_code: 141 for a locale

The locale code does not exist in the stack, or the token cannot read it

GraphQL INVALID_LOCALE: "The queried locale 'en-uk' is invalid."

The locale code does not exist in the stack

A personalized variant shows base content in one language only

The variant has no content for that locale

## Why it happens

Contentstack concept: Every stack has one master language, set when the stack is created. Every other language has a fallback language. An entry exists in the master language and can have a localized version per language. Until you localize it, the entry in that language is unlocalized and inherits its content from the fallback language.

Inheritance follows the chain. If de-at falls back to de-de, and the entry has no de-de content, it inherits from the master. The chain is short on purpose: a non-master language can fall back to another language, and a language that is already a fallback can only fall back to the master. So the longest chain looks like de-at → de-de → en-us.

The part that surprises most developers is publishing. When an editor publishes an unlocalized entry in de-de, Contentstack publishes the latest content from its fallback language under de-de. The Content Delivery API (CDA) now has a real de-de document for that entry, and it holds English text. Your request for de-de returns it, with or without fallback flags.

If you come from i18n libraries, this is closer to "copy the default translation into the bundle at build time" than to "fall back at runtime when a key is missing".

There is a second, separate mechanism at delivery time. When an entry is not published in the requested locale at all, the CDA leaves it out of the response. With include_fallback=true, it returns the version published in the fallback language instead. That fallback version must itself be published.

flowchart TD  A[Request locale=de-de] --> B{Entry published in de-de?}  B -- Yes --> C{Localized in de-de?}  C -- Yes --> D[German content]  C -- No --> E[Fallback content, published under de-de]  B -- No --> F{include_fallback=true?}  F -- No --> G[Entry left out, or 422 for a single entry]  F -- Yes --> H[Version published in the fallback language]## Fix it

### Find out which case you are in

Fetch the entry and look at two fields: the entry's locale and publish_details.

```bash
curl -sG "https://cdn.contentstack.io/v3/content_types/product/entries/$ENTRY_UID" \
  -H "api_key: $CONTENTSTACK_API_KEY" \
  -H "access_token: $CONTENTSTACK_DELIVERY_TOKEN" \
  --data-urlencode "environment=production" \
  --data-urlencode "locale=de-de" \
  | jq '.entry | {title, locale, publish_details}'
```

locale tells you which language the content belongs to. publish_details.locale tells you which locale it was published in. An unlocalized entry published in de-de typically shows locale: "en-us" with publish_details.locale: "de-de". A localized entry shows de-de in both.

In GraphQL, ask for the same data through system:

```graphql
query {
  product(uid: "blt0123456789abcdef", locale: "de-de") {
    title
    system {
      locale
      publish_details {
        locale
      }
    }
  }
}
```

### The entry was published without being localized

This is the most common case, and the fix is editorial. Open the entry, switch to de-de, localize it, translate the fields, and publish it in de-de again. From then on, de-de has its own content and stops inheriting.

If the English content should not be live in German at all, unpublish the entry from de-de until the translation is ready. A request for de-de then leaves it out, unless you ask for fallback.

To find all of them, compare locale against the requested locale across a listing:

```typescript
import contentstack from "@contentstack/delivery-sdk";

const stack = contentstack.stack({
  apiKey: process.env.CONTENTSTACK_API_KEY!,
  deliveryToken: process.env.CONTENTSTACK_DELIVERY_TOKEN!,
  environment: process.env.CONTENTSTACK_ENVIRONMENT!,
});

const requested = "de-de";

const { entries = [] } = await stack
  .contentType("product")
  .entry()
  .locale(requested)
  .only(["title", "locale"])
  .find<{ uid: string; title: string; locale: string }>();

const notTranslated = entries.filter((e) => e.locale !== requested);
console.table(notTranslated.map(({ uid, title, locale }) => ({ uid, title, locale })));
```

Run it for each locale before a release. It turns "some pages look English" into a list of entry UIDs an editor can work through.

### You asked for fallback

If your code sets include_fallback=true, English content for missing translations is the expected result. With the SDK:

```typescript
const result = await stack
  .contentType("product")
  .entry()
  .locale("de-de")
  .includeFallback()
  .find();
```

In GraphQL, the equivalent is the fallback_locale argument:

```graphql
query {
  all_product(locale: "de-de", fallback_locale: true) {
    items {
      title
      system {
        locale
      }
    }
  }
}
```

Decide per page whether fallback is what you want. A product listing usually wants every product, in German where it exists and in the fallback language where it does not. A legal page usually wants German or nothing. Keep fallback off where a mix of languages would be wrong, and handle the missing entry in code.

Turning fallback off does not hide entries that were published unlocalized in de-de. Those are real de-de documents. That is why fallback_locale: false can still return English.

### The locale code is wrong

Stack locale codes are lowercase, like en-us, de-de and fr-ca. Frameworks often use de-DE. Do not pass the framework value straight through. Map it:

```typescript
const toStackLocale = (routeLocale: string) => routeLocale.toLowerCase();

const entries = await stack
  .contentType("page")
  .entry()
  .locale(toStackLocale(params.locale))
  .find();
```

A locale that is not in the stack returns 422 with error_code: 141 on the CDA and INVALID_LOCALE in GraphQL. If your routes use codes that differ from the stack's, such as de for de-de, keep an explicit map instead of string manipulation. The [multi-language Next.js guide](/guides/building-a-multi-language-website-using-contentstack-and-next-js-i18n) shows the full routing setup.

### Non-localizable fields always show the master value

A field marked non-localizable is edited in the master language only. Its value is copied to every localized version, and in localized entries it is read-only. An English image caption on a German page often comes from this setting.

When an editor changes that field in the master language, the localized versions update automatically and get a new version number. Published localized versions do not change until they are published again, so publish the affected locales after a change to a non-localizable field.

If the field needs per-language values, make it localizable in the content type. Group, modular block and global field instances that an editor adds in a localized entry are an exception: those instances can be edited there.

### Referenced entries have their own locales

A German page can reference an author entry that only exists in English. Each referenced entry is localized and published on its own. Resolving the reference returns whatever that entry has in the requested locale, which can be an unlocalized English copy published under de-de. Run the check above on referenced content types too. If a reference disappears instead, see [Nested references come back empty](/guides/nested-references-empty-or-error-141).

### Personalized variants

Entry variants are stored per locale. If a variant has no content in the requested locale, you get the base entry for that locale. [Personalize variant returns the base entry or null](/guides/personalize-variant-returns-base-entry-or-null) covers that case in depth.

## Check that it worked

- Rerun the curl request. locale and publish_details.locale should both match the locale you requested.


- Rerun the listing script. notTranslated should be empty, or only contain entries you chose to leave in the fallback language.


- If your site caches pages, purge or revalidate the affected locale paths. Each locale is cached separately, so republishing de-de does not refresh en-us pages and the other way around.



## Prevent it

- Add the listing check to CI or a scheduled job per locale, and fail or warn when a page-level content type has unlocalized entries in a non-master locale.


- Agree on a rule with editors: publish in a new locale only after localizing, or use a workflow stage for translation before publish.


- Decide where fallback is allowed and set include_fallback per query, not globally.


- Keep fields that are truly shared, like SKUs and dates, non-localizable. Make every field a reader sees localizable.


- Normalize locale codes in one function and use it in routing, data fetching and cache keys.



## Key takeaways

- An unlocalized entry inherits content from its fallback language. Publishing it in a locale publishes that inherited content under the locale.


- include_fallback=true and fallback_locale: true only matter when an entry is not published in the requested locale.


- Compare locale with publish_details.locale to see whether content was translated or inherited.


- Fallback chains are one level deep for non-master languages: de-at → de-de → en-us is as long as it gets.


- Stack locale codes are lowercase. Map framework codes before you query.


- Non-localizable fields always carry the master value. Republish localized entries after you change one.



## Next steps

- Follow the [multi-language Next.js guide](/guides/building-a-multi-language-website-using-contentstack-and-next-js-i18n) to wire locales into routing.


- If localized pages stay stale after publishing, read [Published, but my site still shows old content](/guides/published-but-my-site-still-shows-old-content).


- Check [Contentstack limits on one page](/guides/contentstack-limits-on-one-page) for language and fallback limits.





---

## Do this with AI

Install the cms-localization skill from [Contentstack agent skills](https://github.com/contentstack/contentstack-agent-skills) and connect the Localization Gap Finder profile in MCP Profile Hub. Then ask your agent:

> List the product entries that are published to production in de-de but not localized in de-de, so they serve fallback content, and sort them by last update so I know which to translate first.

New to this? [Set up your AI workbench](/guides/set-up-your-ai-workbench-for-contentstack) first.




---

## Frequently asked questions

### Why does the API return English text when I request de-de?

Usually the entry was published in de-de without being localized, so the English content from its fallback language was published under de-de. The API returns it like any other de-de entry.

### What does include_fallback do?

When an entry is not published in the requested locale, include_fallback=true returns the version published in its fallback language instead of leaving it out.

### How deep can a fallback chain go?

One level for non-master languages. A language can fall back to another language, and that language can only fall back to the master language.

### Are locale codes case-sensitive?

Treat them as such. Stack locale codes are lowercase, like de-de, so map de-DE from your framework to de-de before you call the API.

### Why does a non-localizable field show the master value in every locale?

That is what non-localizable means. The field is edited only in the master language and its value is copied to every localized version.

