Getting started

Ownlate keeps the strings of your product in one place: developers push the source file, translators work on it in a web editor, reviewers approve, and the approved result goes back to the code — as a file, over the API, or over the air.

This page walks the whole path once. Every step links to the page that covers it in depth.

1. Sign in and create a workspace

1. Open platform.ownlate.com and sign in.

2. Create a workspace. It needs a name and a billing currency — the currency decides which payment providers you will be offered later and cannot be changed afterwards.

3. Everything else — projects, members, glossary, translation memory, integrations, billing — belongs to that workspace and is invisible from any other one.

A new workspace starts on the free plan. See Plans and billing for what each plan allows.

2. Invite your team

Go to Workspace → Members and invite people by email address. An invite is a one-time link that expires; the person who accepts it joins at the level you picked.

Level	What it can do
owner	Everything, including billing and deleting the workspace
admin	Everything except deleting the workspace
translator	Read the workspace, write translations, add segments
viewer	Read only

Levels are shorthand for a set of permission codes, and the set is editable. See Members and access.

3. Create a project

A project is one product, or one part of one. It holds files, segments, releases, tasks and integrations.

Creating it asks for:

• Name and an optional description.
• Source language — the language your developers write strings in.
• Target languages — you can add more at any time.
• Visibility — private, or public so that anyone can read its progress and translations without signing in.

4. Upload a file

Open the project’s Files tab and upload the source file. Ownlate detects the format from the extension and creates one segment per translatable string.

Format	Extensions
JSON	.json
Flutter ARB	.arb
YAML	.yaml, .yml
gettext	.po
Android resources	.xml
Apple strings	.strings, .stringsdict
XLIFF	.xliff, .xlf
CSV	.csv
Markdown	.md, .mdx

Nested JSON and YAML keys are flattened with dots, so {"home": {"title": "Hi"}} becomes the key home.title. Files live in folders inside the project, and the folder path is part of the file’s identity.

The same upload, done from your machine or your pipeline instead of the browser:

CLI

npm install -g @ownlate/cli
ownlate login
ownlate init
ownlate push

Git

Commit an ownlate.yml to the repository and connect a GitHub or GitLab integration — Ownlate reads that file and pulls the sources itself on every sync.

project_id: 00000000-0000-0000-0000-000000000000

files:
  - source: locales/en.json
    translation: locales/{lang}.json

REST

curl -X POST \
  "https://api.ownlate.com/v1/workspaces/$WORKSPACE_ID/translation-files/upload" \
  -H "Authorization: Bearer $OWNLATE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"projectId":"...","name":"en.json","path":"locales","content":"{\"home.title\":\"Hi\"}"}'

5. Translate

Open a target language to enter the editor. For every segment it shows the source text, any context the developer attached, matches from the translation memory, highlighted glossary terms and live QA checks.

A translation moves through statuses:

untranslated → draft → needs_review → reviewed → approved
                            ↑              ↓
                       in_progress ←── rejected

Saving keeps a draft; submitting sends it for review; a reviewer marks it reviewed and an approver approves it. Every approved translation is written to the workspace translation memory, so the next similar string comes pre-filled. See The translation workflow.

6. Speed it up

Rather than starting from an empty file, run Pre-translate on a language. It walks the untranslated segments and fills them from the sources you pick, in the order you pick them:

• Translation memory — an exact match is applied and approved outright; a fuzzy match above your threshold is left as a draft.
• Machine translation — OpenAI, Anthropic, DeepL, Google, Azure or Mistral through your own key, or the built-in engine if your plan includes it. The result lands in needs_review.

See Translation memory and AI translation.

7. Ship the result

Way	Good for
Export from the Files tab	One file, or every language as a ZIP
ownlate pull	Writing translated files back into the repository
Pull request	Letting Ownlate open the PR against your repo itself
Release + OTA	Apps that fetch translations at runtime instead of shipping them

Exports contain approved translations only, unless you ask for a fallback to the source language.

Where to go next

• Core concepts — the objects Ownlate is built from, and how they relate.
• The translation workflow — statuses, review, tasks and suggestions.
• CLI — the commands your pipeline will run.
• REST API — everything the browser can do, your code can do too.