Manage your App Store Connect content directly in BetterLocale Store, using the same structure you already know from App Store Connect. The tab bar lets you quickly jump between sections like App Information, App, App Privacy, Game Center, In-App Purchases, Subscriptions, and a custom page.

In each section, you’ll find the fields exactly as Apple expects them. Every field is clearly labeled and includes a short hint, so you immediately know what belongs there and how the text will be used later. This covers not only name, subtitle, promotional text, description, keywords, and “What’s New,” but also many other details that matter for publishing and maintaining releases, such as support and marketing URLs, market-specific notes, and content related to in-app purchases and subscriptions.

BetterLocale Store helps you catch common mistakes before you upload anything. For every text field, you can see the maximum allowed length. If you exceed it, the field is flagged instantly so you can shorten or rewrite right away, instead of getting blocked later in App Store Connect or during release prep. This saves a lot of time, especially when you’re managing multiple languages, because you fix issues while you write, not at the very end.

On the custom page, you can also collect your own frequently used texts and notes: Apple review templates, recurring standard copy, links, checklists, release notes, or internal reminders. Everything stays in one place, so you don’t have to hunt for these building blocks every time.

Once all texts are filled in, you can have translations generated automatically right inside BetterLocale Store. The app uses the AI provider you choose. Currently, it supports OpenAI, DeepL, Gemini, Claude, and Perplexity.

To use this, you’ll need your own account with the respective provider. There you obtain an API token, which enables access to the API and is also used for billing. You enter this token in BetterLocale Store under Settings. It is stored only locally on your Mac and is not shared with us. Before running your first translation, you should use the connection test. This lets you verify the token, endpoint, and network access immediately, without having to start a full translation run.

Costs vary widely depending on the provider, the model you choose, and the amount of text. Many providers charge per “units” (for example, tokens or characters). With ChatGPT and OpenAI, the model typically works like this:

– Your text is broken into tokens (a single word can be split into multiple tokens depending on length and special characters).
– Input (your text plus any context) and output (the generated translation) are billed separately.

So you pay for what you send and for what you receive. If you want predictable costs, it usually helps to translate only the fields that are missing or have changed, and to keep your context prompts short and specific.

Create an AI API Key and add it to the app

To use automatic translation and the AI chat in the app, you need an API key from an AI provider.
Think of it as a personal access code: the provider uses it to recognize that the request is coming from you, and bills usage through your account.

The app currently supports: OpenAI, Claude, DeepL, Gemini, and PerplexityAI.

Setup is very similar across all providers.

What you should know first
• API key = access code: You enter it in the app so it can send requests to the provider on your behalf.
• Costs are billed to you: The app sends the requests, but billing happens directly through your provider account.
• Billing is often required: Many providers only allow API requests after you add a payment method. Without billing, you’ll often get errors or be stuck in very small free limits.

Quick start: 5 steps to get set up

1. Create an account or sign in

Go to your provider’s website and sign in (or create a new account).

2. Create an API key

Look for a section like API, Developer, Dashboard, or API Keys and create a new key there.

3. Copy the key and store it safely

Copy the key immediately and store it somewhere safe, ideally in a password manager.

Important: many providers show the key in full only once.

4. Enable billing/payment

Add a payment method or enable billing. Otherwise, API requests often won’t work at all or will be heavily limited.

5. Paste the key into the app

Open the app → Settings → AI Providers → select a provider → paste the API key → Save

After that, you can start translations and use the integrated AI chat.

Provider setup (with direct links)

OpenAI (ChatGPT / OpenAI API)

1. Open the OpenAI dashboard:
https://platform.openai.com/
2. Create an API key:
https://platform.openai.com/settings/organization/api-keys
3. Set up billing/payment method:
https://platform.openai.com/settings/organization/billing/payment-methods

Tip: You often see the key in full only once. After that, it may be shown only partially.

Claude (Anthropic)

1. Open the Claude Console:
https://platform.claude.com/
2. In the console, go to Account Settings and create the API key there.
3. Enable billing in the console so you can use the API.

Note: This used to be handled partly via console.anthropic.com; it’s now being migrated/redirected to platform.claude.com.

Gemini (Google)

1. Open Google AI Studio (API Keys):
https://aistudio.google.com/app/apikey
2. If you don’t have a project yet: AI Studio often creates a default project automatically. Otherwise, select/import a Google Cloud project.
3. Create the API key and copy it.

Gemini API key documentation:
https://ai.google.dev/gemini-api/docs/api-key

PerplexityAI

1. Open Account/Settings:
https://www.perplexity.ai/account
2. In Settings, open the </> API tab and generate a key (“Generate API Key”).
3. Alternatively (depending on the UI), use the API portal:
https://www.perplexity.ai/account/api

Optional: API Groups are useful if you want to keep keys separate (for example, “Dev” and “Prod”).

DeepL

1. Open DeepL and sign in:
https://www.deepl.com/
2. Open Account → API Keys & Limits.
3. Click Create key, enter a name, confirm, and copy the key.

DeepL help article:
https://support.deepl.com/hc/en-us/articles/360020695820-API-key-for-DeepL-API

Notes on costs and privacy

• Using AI APIs is usually paid and billed directly through your provider account, typically based on text volume (tokens).
• The app sends only the content you select (for example, the text you want to translate) plus your instruction to the provider.
• Your API key is stored locally on your Mac in the Keychain and is not shared with third parties.

Security

Treat your API key like a password:
• Don’t share it and don’t commit it to public repositories.
• If you think the key is compromised, disable it in the provider dashboard and create a new one.
• If you use multiple devices or projects, it’s best to create a separate key per device/project so you can revoke access selectively without breaking everything.

BetterLocale Store gives you two clean ways to translate your App Store Connect text. In both cases, the goal is the same: you don’t “blindly” translate. You provide clear context so tone, audience, and intent match, and you spend less time polishing afterward.

1) Generate a template and translate externally

With this option, BetterLocale Store builds a translation template from the fields you select. Along with the actual text, the template includes context such as the field type (Name, Subtitle, Description, What’s New), the desired tone, and the intended audience. That matters because App Store copy doesn’t behave like regular prose. A subtitle needs to be short and precise, a description can explain and structure, and “What’s New” should be clear and user-focused.

You then copy the template into any external tool you like, such as ChatGPT, Gemini, or DeepL. After you get the translation, you paste the result back into BetterLocale Store. The app recognizes the structure, assigns each translation to the correct language and field automatically, and applies the new text to your project. You can immediately review what changed and fine-tune individual fields without having to hunt everything down again. The key benefit here is maximum flexibility: you can use any tool, even without an API integration, and you keep full control over the prompt and the output.

2) Translate directly in the app (via API)

If you want to move faster, you can run translations directly inside BetterLocale Store. You can still provide context such as tone, audience, and optional notes so the result fits your app. The app sends only the required content to the provider you choose and writes the translations back into the correct fields automatically. Supported providers include OpenAI, DeepL, Gemini, Claude, and Perplexity. To use this, you store an API key for the respective service.

One important note: BetterLocale Store does not calculate translation costs for you. Billing happens exclusively through your provider, based on their pricing model. It’s also useful that you can control what gets translated: everything, or only entries that are new, changed, or still empty. That saves time and money, because you’re not re-translating full texts when only a single sentence changed.

Bottom line: the template approach is ideal if you want freedom to use any external tool or like to fine-tune prompts yourself. The API approach is ideal if you want to translate directly in the app, work consistently, and automatically avoid unnecessary repeats.

For manual translation, the workflow is intentionally very similar to API translation, just without fetching results directly inside the app. You use the same translation dialog and can optionally provide context, such as tone, target audience, or notes like “UI text, keep it short” or “technical but friendly.” You also choose whether to translate all entries or only empty fields. That’s useful if you already have partial translations and simply want to fill gaps without overwriting existing text.

When you start, BetterLocale Code generates a clean translation instruction and automatically copies it to your clipboard. The instruction includes the selected languages and the relevant key-value pairs in the expected format, so an external tool can work with minimal ambiguity. You then open ChatGPT, DeepL, Gemini, or any other translation tool, paste the instruction, and generate the translations.

The expected output is again a list in the format „Key“ = „Value“; exactly what BetterLocale Code can import. You copy the full output and paste it back into BetterLocale Code. The app reliably matches lines by key, writes the new values into the correct language files, and updates the affected entries in your project right away. This keeps the workflow predictable and transparent even without an API, because you see every step and can fine-tune the result when needed.

If something is off during import, for example missing quotation marks, swapped separators, duplicate keys, an invalid line structure, or extra explanatory text added by the external tool, BetterLocale Code doesn’t fail silently. It highlights the affected entries and shows specific error details, so you can quickly fix the output or run the translation again without accidentally introducing wrong values into your project. The process is a bit more hands-on, but ideal if you don’t want a direct API integration, prefer working across different tools, or want to review translations yourself before importing.

With automatic translation, you can control the scope very flexibly. If you trigger translation from your default language, the app uses it as the source and translates all selected target languages in a single run. This is ideal when you want to fully complete a set of fields or an entire project in one go. Alternatively, you can switch to a specific language view and run translation for that language only. This workflow also works well if you want to launch with two or three core languages first and add additional languages gradually over time.

When you start, a dialog opens where you can optionally provide context. This is often what makes the difference with AI translations: you can specify whether the tone should be formal, casual, or technical, define the target audience (developers, end users, professional readers), and ensure certain terms remain consistent. You can also choose to translate only fields that are currently empty. That’s especially useful if you’ve already refined some texts manually, or if you add new languages later and want to fill gaps without overwriting existing copy.

Once you confirm the dialog, the app starts the translation process. It works field by field and logs what happens. If errors occur, they aren’t simply dismissed. They’re collected and shown at the end in a clear, detailed summary. That way you can immediately tell whether there was a network issue, a provider rejected a request, or specific fields couldn’t be processed for other reasons.

You can rerun the process at any time. A common pattern is to translate everything as a first pass, refine a few texts in the default language later, and then run translation again, this time only for missing or still-empty entries. This keeps the workflow controlled and lets you iterate without having to redo everything each time.

Once you’re done polishing and translating in BetterLocale Store, the final step is intentionally “classic”: you manually transfer the finished text into App Store Connect. In practice, that means going language by language, opening the relevant sections in App Store Connect (App Information, Version Information, and optionally In-App Purchases, depending on what you manage), and entering the content field by field. It may feel a bit old-school at first, but it comes with a major benefit: you keep full control of the final state inside App Store Connect at all times, and you can immediately see what’s actually planned to go live, including Apple’s versioning, submission, and review UI.

The real value happens before that. BetterLocale Store surfaces the usual pitfalls while you’re writing, where they’re cheapest to fix. Many App Store fields have strict limits and “invisible” rules: subtitles and promotional text can exceed the limit quickly, keywords must fit into a tight character cap and vary widely by language, and descriptions often pick up duplicates, special characters, or formatting that later looks messy. When the app flags these issues as you work, you can shape your text from the start so it fits App Store Connect without rework. That saves the annoying loop where you only discover at paste-time that Apple truncates something or the field simply won’t accept it.

It also makes the handoff calmer. Because you maintain everything centrally and clearly structured per language, you’re no longer copy-pasting from five different sources. No Excel fragments, no scattered notes, no “latest version” buried in a chat or an old ticket. For each language, the final text lives in one place. That dramatically reduces common mistakes: mixed-up language variants, broken line breaks, accidentally using outdated promotional text, or keywords with the wrong separators. If you ship to many countries or release updates frequently, this becomes a real quality lever. Releases stay predictable, and you’re less likely to be scrambling right before submission.

In the end, manual entry in App Store Connect is no longer the moment where you discover problems. It’s simply the last step to bring already reviewed, finalized content into Apple’s system.

BetterLocale Store makes it easy to send feedback directly from within the app, without having to gather details first. When you choose the Feedback command, the app opens your default email client and automatically creates a new message with a prefilled subject line. You can start writing right away, whether it’s a quick question, a feature request, or a bug report.

The benefit is that it removes the usual back-and-forth. You don’t have to look up which app version you’re on, where the issue occurred, or what you were doing at the time. Just describe what happened in a few sentences and send the email. If you want, you can add extra details such as steps to reproduce, what you expected, and what happened instead. That way your feedback reaches us quickly and clearly, and we can respond more precisely, avoid follow-up questions, and reproduce issues faster.

Important: BetterLocale Store does not send emails in the background. It simply opens your email app and prepares a draft. You stay in full control of what gets sent and when you send it.

When you change a text in the default language, it’s effectively a new source string. Existing translations may still be “formally correct,” but semantically wrong, because they refer to an older wording or the nuance no longer matches. That’s why it can be better to discard translations in other languages and regenerate them, rather than silently keeping outdated values. BetterLocale Store detects these changes and automatically alerts you, so you don’t accidentally ship stale translations in a release.

You can also trigger this step manually at any time: select the entry in the default language and choose “Delete translations for all languages.” After that, the fields in other languages are empty or clearly marked as missing, and you immediately see what needs to be retranslated. This is especially useful when revising copy, updating legal notices, polishing marketing phrasing, or changing the tone of voice. In those cases, keeping “old” translations usually isn’t what you want, because they may no longer match the current meaning and style.

On the other hand, some content is intentionally identical across all languages. Typical examples include URLs, product names, brand names, and sometimes short technical terms or fixed spellings. For that, use “Apply default value to all languages.” BetterLocale Store copies the default-language value into every other language without you having to touch each one individually. This keeps everything consistent, saves time, and prevents an accidental mismatch, like a different link or a slightly altered spelling.

Once translations are available, you can quickly spot-check quality with a small sample. Select an entry and start “Edit Translations.” A dialog opens that clearly shows three pieces of information side by side (or in separate sections): the translation in your selected target language, the original text in your base language, and a back-translation into the base language. The back-translation isn’t a “second proof of truth,” but it’s extremely useful for catching meaning drift, missing context, the wrong tone, or overlooked details (for example negations, verb tenses, domain terms) without requiring you to be fluent in the target language.

In the same dialog, you can intervene immediately if needed. You can correct translations, refine phrasing, enforce consistent terminology, and verify that placeholders, variables, and special formatting were carried over correctly. Especially for App Store text or UI strings, it’s also worth a quick check of length and readability: Does the style match the rest of the product? Is the message clear? And does the translation stay faithful to the original without sounding unnatural? When you make changes, you see the result right away in the context of that entry and can iterate until it feels right.

This gives you a reliable sense of translation quality with minimal effort, and lets you fix critical spots quickly before you finalize or publish the text.

BetterLocale Store also includes an integrated AI chat that feels familiar if you’ve used ChatGPT: you type naturally, get responses in a running thread, can ask follow-up questions, have text rewritten, or request multiple variations. This is especially handy for App Store Connect content. For example, you can generate a subtitle in a specific tone, sanity-check keywords, review a translation for naturalness, or ask why a phrasing sounds off in a target language. Technically, this isn’t a separate “chat channel” it uses the same connected AI APIs as the translation features. That means the same model and provider settings you selected in the app apply here as well.

Billing always happens with the respective provider and depends on the model and actual usage. With OpenAI, for example, usage is billed in tokens, separately for input and output. As a rough reference, OpenAI lists the following rates for GPT-4.1 (per 1M tokens): $2.00 for input, $0.50 for cached input, and $8.00 for output. “Cached input” applies when part of your prompt can be reused from a prompt cache, which can reduce input costs and often happens automatically.