Running your practice
Crowdin Translation: How Translators and Agencies Run Projects Inside Crowdin
Crowdin translation is a cloud TMS where agencies host source files, pre-translate with MT, route post-edit to translators, and sync completed strings back to
Agencies producing multilingual software builds run Crowdin as the project environment where source files land from GitHub, machine translation fills the first pass, translators post-edit inside the online editor, and completed strings sync back to the client's repository. The economics, workflow gates, and connector cadence below sit inside the broader How App Localization Works and What Clients Are Buying decision.
Services
What is Crowdin translation and how do agencies actually use it?
Crowdin translation is the end-to-end production workflow inside Crowdin, a cloud-based localization and translation management platform where agencies host source files, pre-translate with machine translation, route post-edit work to translators, run QA gates, and sync completed strings back to the client's repository. The platform is cloud-hosted, meaning no local installation is required — every workflow step, translator seat, and integration runs through a browser or API connection. The agency sits between the client's developers and the translator pool, owning the configuration of workflow steps, target locales, QA rules, and third-party connectors from a single project dashboard.
How it works
How does the Crowdin translation workflow move a string from source to delivery?
1
How are source files uploaded and parsed into translatable strings?
Source files reach Crowdin through three distinct ingestion paths. First, a developer or PM can upload files directly through the web interface — the simplest path for one-off projects or initial project setup. Second, the Crowdin CLI enables scripted push-and-pull from a developer workstation or CI server; the CLI is a TypeScript-based command-line client for the Crowdin API that automates source file updates, making it the standard tool for teams with non-standard repository layouts or private CI environments. Third, native integrations with GitHub, GitLab, and Bitbucket watch a configured source branch and pull new strings into the project automatically on every merge. Once a file arrives by any path, the parser extracts translatable units, locks placeholders from edit, and makes the resulting string list available to the pre-translate engine within minutes.
2
How is context added so translators do not translate blind?
Context is the single largest driver of translation quality inside Crowdin, and the platform delivers it through four channels that attach directly to individual string keys. Inline developer notes embedded in source files — such as JSON _comment keys — travel with the string through every workflow step and appear in the editor panel automatically. Screenshots uploaded against specific keys give translators a visual anchor for UI strings where word length and register depend entirely on where the string appears on screen. The Crowdin In-Context tool renders a live web preview on a staging URL, letting translators edit strings inside the actual product interface rather than in an abstract list. Glossaries carry terminology decisions forward across projects and flag term violations in the QA pass. Together these four mechanisms mean a well-configured Crowdin project reduces translator queries by a measurable margin and shrinks review defect rates on terminology and register.
- Inline developer notes in source files (e.g., JSON
_commentkeys). - Screenshots uploaded against specific keys, visible in the editor panel.
- The Crowdin In-Context tool for live web previews on staging URLs.
- Glossaries and translation memory that carry prior decisions forward.
3
How does pre-translation with machine translation and translation memory work?
Pre-translation is a two-engine sequence, not a single MT call. The translation memory runs first: it fills exact matches (100% identical source strings from prior projects) and fuzzy matches (strings that are similar but not identical) before any MT engine is invoked. The translation memory's role is to reduce raw translation work before MT runs, pulling the per-word cost mix toward review rather than first-pass translation on repeat releases — an important lever on programs where a large share of each release is modified rather than new content. After TM fills what it can, the configured MT engine handles the remainder. Crowdin's marketplace exposes multiple production MT options configurable per project and per language pair:
- DeepL (strong on EU language pairs)
- Google Translate (broadest language coverage)
- Microsoft Translator (enterprise volume contracts)
- OpenAI (prompt-tunable output, higher per-character cost)
Each engine is billed per character by the engine provider, separately from the Crowdin platform subscription. Agencies configure the engine per language pair — DeepL for German, French, and Spanish; a broader engine for less-resourced locales — so the MT quality floor is calibrated to each market rather than averaged across all of them.
4
How do translators and reviewers work inside the Crowdin editor?
Translators work string-by-string inside the Crowdin online editor with TM suggestions, glossary hits, MT candidates, and context panels simultaneously on screen. The editor is the primary production surface: hotkeys move between segments, comments on a string route source-bug reports back to the client developer, and the TM panel ranks match quality so the translator can accept a high-confidence fuzzy match or override it. Reviewers approve or reject each segment in sequence, and every action is logged — who translated what, which MT suggestion was accepted, when approval occurred. That audit trail is what certified lanes rely on when they need a named-translator attestation, and it is what the agency submits when a client requests a workflow compliance report.
5
How does completed translation sync back to the client's codebase?
Completed translations push back to the repository through push-on-publish webhook sync, where Crowdin commits translated JSON, XLIFF, or PO files to a designated translation branch and the client's CI pipeline merges them into the build. For teams that cannot accept automatic commits, the Crowdin CLI provides the manual pull alternative inside existing CI jobs. Mobile applications have a third delivery path: over-the-air content delivery lets a mobile app fetch translation updates from the Crowdin CDN without shipping a new app release, which is the mechanism agencies use when a client needs a hotfix to a UI string in a live mobile product without triggering a full app store review cycle.
Which integrations do agencies wire into Crowdin for continuous localization?
Agencies wire four integration categories into Crowdin: version control systems (GitHub, GitLab, Bitbucket), developer tooling (Crowdin CLI, CI pipeline scripts, webhooks and API), content platforms (Shopify, Contentful, WordPress), and MT engines plus human translation vendors from the Crowdin marketplace. The connector choice is not cosmetic — it determines sync cadence, operational overhead, and how quickly new source strings reach the translator queue after a developer commits code. A misconfigured integration means translators work on stale source while developers ship new strings untranslated; a well-configured one makes localization effectively invisible to the engineering team.
| Integration | Sync model | Agency fit |
|---|---|---|
| GitHub / GitLab / Bitbucket | Push-on-publish webhook | Standard repo layout, open-source and mid-market SaaS |
| Crowdin CLI in CI | Scripted push/pull | Monorepo, private CI, non-standard file layout |
| Shopify connector | Push-on-publish webhook (Products, Articles); separate theme JSON pull | E-commerce clients |
| Contentful / WordPress | Scheduled polling or webhook | CMS-driven content programs |
| Marketplace MT engines | API call per segment | Pre-translate stage, billed separately per character |
| Human vendor marketplace | Order placed per project or language pair | Overflow capacity, specialist language pairs |
What sync cadence does the GitHub integration run?
The Crowdin GitHub integration is a push-on-publish webhook sync: a merge to the configured source branch triggers Crowdin to pull newly added or modified strings into the translator queue automatically, without any PM action. Completed translations then commit back from Crowdin to a designated translation branch, ready for the client's CI pipeline to merge. This model means localization runs in parallel with development rather than as a sequential phase after code freeze — a shift that compresses time-to-market on release cycles. The push-on-publish pattern is the standard for repositories with a conventional layout; it requires no scripting once the integration is configured and the webhook is registered.
The Crowdin CLI is the right tool when the client's repository structure or CI environment makes the native git integration impractical. It is a TypeScript-based command-line client for the Crowdin API that installs alongside existing build tooling, reads a crowdin.yml configuration file, and exposes push and pull commands that fit naturally inside GitHub Actions, GitLab CI, or any other pipeline runner. Using the CLI, a team can automate the process of updating source files in their Crowdin project, run targeted pulls for specific language pairs, and integrate localization steps into existing build gates without granting Crowdin direct repository write access. Monorepos, private CI environments, and projects with non-standard file layouts — where a single repository contains multiple apps each with their own locale directories — are the primary cases where the CLI replaces the webhook integration rather than supplementing it.
How does the vendor marketplace extend agency capacity?
Beyond MT engines, the Crowdin marketplace includes a vendor network from which agencies can order professional human translation directly from within the platform. This is the procurement path for language pairs where the agency's in-house roster is thin, for overflow volume on a deadline-compressed program, or for specialist domains — legal, medical, financial — where subject-matter expertise matters more than throughput. Orders placed through the marketplace feed into the same Crowdin project workflow, meaning vendor-produced segments go through the same QA and review gates as in-house translator output. The marketplace vendor model also gives agencies a fallback when community translation quality on Tier 3 locales falls below the LQA threshold, allowing a professional pass on flagged segments without moving the entire locale out of the crowdsourced lane.
How do QA, review, and LQA gates work in a Crowdin project?
Three gates sit between Crowdin pre-translation and client delivery: built-in automated QA checking every segment for machine-detectable errors, human review at $0.04–$0.08 per source word covering every segment for meaning and fluency, and sampled LQA at $40–$90 per 1,000 words scoring output against an MQM-style scorecard aligned to ISO 17100. Each gate is designed to catch a distinct defect class — automation handles what rules can define, human review handles what requires linguistic judgment, and LQA provides the auditable quality score that enterprise clients and regulated industries require before accepting a delivery. Running all three is standard practice on Tier 1 locales; Tier 2 lanes commonly drop the LQA sample and run automated QA plus human review only.
| Gate | Coverage | Cost | Catches |
|---|---|---|---|
| Built-in automated QA | 100% of segments | Included in subscription | Machine-detectable defects: placeholders, tags, length, spelling, forbidden terms |
| Human review | 100% of segments | $0.04–$0.08 per source word | Meaning, fluency, register, terminology, locale convention |
| LQA (sampled) | Statistical sample per locale | $40–$90 per 1,000 words translated | Scored defects against ISO 17100 typology; pass/fail threshold agreed with client |
What does built-in automated QA catch inside Crowdin?
Crowdin's built-in QA engine runs automatically against every segment as it moves through the workflow, without translator or PM action. It is a rules-based layer that catches six classes of machine-detectable defects that would otherwise reach human review and waste reviewer time on mechanical errors:
- Missing or extra placeholders (e.g.,
{username},%s,{{count}}) — catches cases where the translator dropped or duplicated a runtime variable - Broken HTML or tag mismatches — flags any target string where opening and closing tags do not balance
- Inconsistent translations across identical source strings — surfaces cases where the same English string has two different target translations in the same project
- Length overflow versus source — catches translations that exceed UI character or pixel limits, preventing layout breaks
- Forbidden glossary terms — flags target strings that use a term the project glossary has marked as prohibited
- Spelling against a locale dictionary — catches gross spelling errors before they reach review
Automated QA is a blocking gate in a correctly configured Crowdin workflow: segments with open QA errors are not available for review approval until the translator resolves or explicitly overrides the flag with a documented reason.
How does the LQA scorecard aligned to ISO 17100 run against Crowdin output?
LQA is a sampled audit, not a segment-by-segment review. The LQA auditor pulls a statistically representative sample of completed Crowdin output per locale — typically after human review has already approved the full file — and scores each defect against an MQM-style typology that covers accuracy, fluency, terminology, locale convention, and style. The scorecard is aligned to ISO 17100, the international standard for translation service quality, which is the framework enterprise procurement teams and regulated-industry clients reference when they specify quality requirements in a service-level agreement. The project passes LQA only when the weighted defect score falls below the threshold negotiated with the client; a failing score triggers a targeted revision cycle on the flagged segments before delivery is released. At $40–$90 per 1,000 words translated, LQA is the most expensive quality gate per word, which is why agencies apply it selectively to Tier 1 locales where reputational and revenue risk justifies the spend.
Pricing
How much does a Crowdin translation project cost the agency to run?
A Crowdin project's agency cost stacks four line items: Crowdin platform subscription per seat and source-word tier, translation at $0.10–$0.25 per source word, review at $0.04–$0.08 per word, and LQA at $40–$90 per 1,000 words — with project management holding at 10–15% of project value. The platform fee is fixed; the human-work layer scales with volume.
| Line item | Unit | US rate |
|---|---|---|
| Platform subscription | Per month, by seats and source-word tier | Fixed by plan |
| Translation (post-edit) | Per source word | $0.10–$0.25 |
| Review | Per source word | $0.04–$0.08 |
| LQA | Per 1,000 words translated | $40–$90 |
| Project management | % of project value | 10–15% |
What does a 5-locale, 50,000-word Crowdin program budget to?
A mid-size program covering 5 languages and 50,000 words through Crowdin budgets at $25,000–$75,000 end to end, with AI pre-translate shifting the mix toward review and LQA rather than raw translation and TM leverage pulling the lower bound down on repeat releases. The worked example matches the production pattern we document on Localization Solution: What Translators and Agencies Assemble to Run Multi-Lane Work: agency wires Crowdin to the client's GitHub repo, pre-translates with DeepL, routes post-edit to in-country translators in memoQ, and runs LQA at $40–$90 per 1,000 words.
When does Crowdin's crowdsourced community model fit the project?
Crowdin's crowdsourced community model fits Tier 3 long-tail locales and open-source-adjacent products at near-zero per-word cost; the agency retains paid review and LQA on Tier 1 and Tier 2 locales where paywall and onboarding revenue sits. The split keeps cost down without exposing conversion lanes to unvetted output. Tier allocation:
- Tier 1 (en, es, fr, de, ja) — paid translator + review + LQA.
- Tier 2 (pt-BR, it, nl, ko, zh) — paid translator + review; sampled LQA.
- Tier 3 (long-tail) — community translators; agency spot-reviews.
Where does Crowdin fit alongside the agency's desktop CAT tools and certified lanes?
Crowdin hosts the project, workflow automation, and continuous repository sync; desktop CAT tools handle certified document work, named-translator attestation, and offline high-stakes content — the agency exports XLIFF or bilingual files from Crowdin into the desktop environment for those lanes and reimports completed files when the work is done. The two environments are complementary, not competitive. Crowdin is optimized for continuous, high-volume software localization where git sync, MT pre-translation, and a marketplace of engines deliver speed and scale. Desktop CAT environments are optimized for document-centric, attestation-required work where offline file control, named-translator audit trails, and court-admissible certification matter more than throughput.
The hybrid split is a deliberate architectural decision, not a workaround. An agency running both environments routes work by lane type: continuous software strings stay inside Crowdin, where the push-on-publish webhook keeps the translator queue current with every developer commit. Certified document translations — court filings, registry documents, notarized contracts — move through the desktop CAT workflow, where the named-translator attestation and offline file custody chain are preserved. Marketing collateral under NDA often takes the same desktop path because the client holds the translation memory and requires the agency to work on a locally managed workbench rather than a cloud project. Open-source and community Tier 3 locales sit at the opposite end of the spectrum: Crowdin's crowdsourced translation model handles them at near-zero per-word cost, with the agency retaining review and LQA authority before delivery.
| Lane | Tool | Why |
|---|---|---|
| Continuous software strings | Crowdin | Git sync, MT marketplace, built-in QA, online editor |
| Certified document (court, registry) | Desktop CAT workbench | Named-translator attestation, offline file control, court-admissible chain of custody |
| Open-source / Tier 3 community | Crowdin crowdsourced model | Near-zero per-word cost; agency retains review and LQA on output |
| Marketing collateral under NDA | Desktop CAT workbench | Client-held TM, offline workbench, no cloud file transfer |
The XLIFF format is the standard interchange bridge between the two environments. Because Crowdin parses and exports XLIFF natively, a segment that originates in a Crowdin project can be exported as a standard bilingual file, worked on in any desktop CAT tool that accepts XLIFF, and reimported into Crowdin without loss of segment alignment or match metadata. This round-trip capability means the agency does not have to choose one environment for an entire client program — it can route individual file types or document classes to whichever tool is appropriate while keeping the project's TM and glossary centralized in Crowdin.
What limits of Crowdin translation should agencies plan around?
Four Crowdin limits surface consistently in production programs: in-context preview coverage is bounded to web and a subset of mobile frameworks, certified-document attestation sits entirely outside the platform, enterprise SSO and advanced audit features gate on the Crowdin Enterprise tier, and marketplace MT engines carry per-character costs that bill separately from the base subscription. None of these limits disqualifies Crowdin as a production environment, but each requires a deliberate plan before the program scales.
- In-context preview limits — The Crowdin In-Context tool works well for web applications rendered on a staging URL, but native mobile and desktop builds cannot serve a live preview to the editor. Screenshots uploaded against specific string keys are the standard compensating control: they give translators a visual reference for UI strings without requiring a live environment. Agencies running iOS and Android programs should build a screenshot-capture step into the developer workflow from the start of the project, not as an afterthought after the first round of context-related translation errors.
- Certified-document lanes — Crowdin does not produce a named-translator attestation or a court-admissible certification document. Document translation requiring a certified translator signature, notarization, or sworn declaration must route through a desktop CAT workbench where the named-translator audit trail and offline file custody chain can be maintained. Agencies that handle both software localization and certified document work for the same client need a clearly documented handoff protocol between the two environments.
- Enterprise-tier feature gates — Single sign-on (SSO), granular audit logs, advanced multi-step workflow configurations, and higher seat and word-volume limits are features of the Crowdin Enterprise tier, not the standard subscription. Agencies managing programs for enterprise clients — especially those with security and compliance requirements — should validate feature availability against the correct tier before quoting. Discovering that a required audit log or SSO integration is gated mid-program creates renegotiation friction.
- MT engine billing — DeepL, Google Translate, Microsoft Translator, and OpenAI are each billed per character by the respective engine provider, entirely separately from the Crowdin platform subscription. On a mid-size program covering five locales and 50,000 words, MT pre-translation costs are a meaningful line item in the project budget — programs of that scale typically run
Four Crowdin limits bite in production: in-context preview only covers web and a subset of mobile frameworks, certified-document attestation sits outside the platform, enterprise SSO and audit features gate on the Crowdin Enterprise tier, and marketplace MT engines bill separately from the base subscription. Agencies plan around each:
- In-context limits — screenshots fill the gap for native mobile and desktop builds.
- Certified lanes — route document work to memoQ or Trados Studio with named-translator attestation.
- Enterprise features — Crowdin Enterprise unlocks SSO, audit logs, advanced workflow steps, and higher seat and word limits.
- MT billing — budget DeepL, Google, Microsoft, or OpenAI per-character fees separately from Crowdin seats.
5,000–$75,000 end to end, and MT fees should be itemized rather than absorbed into an undifferentiated platform cost line. Agencies should model per-language-pair MT spend at the proposal stage using each engine's published per-character rate applied to estimated word volume.
Support availability is one area where Crowdin's cloud-hosted model is genuinely strong: platform support is available around the clock, which matters when a translator in a non-US time zone encounters a blocking technical issue on a deadline-critical file. That said, support response time and escalation paths are tier-dependent, so enterprise program managers should confirm SLA terms before the program kicks off.
Four questions recur from translators and agency PMs evaluating Crowdin as a production environment: cost, free tier, alternatives, and how it compares to running localization without a TMS.
Frequently asked questions
How much does Crowdin cost?
Crowdin's pricing starts at around $50/month for the Basic plan and scales up to $200+/month for the Pro plan, with enterprise pricing available on request. Costs vary based on the number of managers, projects, and integrations needed. For translation agencies running multiple client projects simultaneously, the team-based plans are most relevant. A free trial is available, and Crowdin also offers a separate open-source program at no cost for qualifying projects.
Is Crowdin free?
Crowdin is not free for most professional and agency use cases, though it does offer a limited free tier and a dedicated free plan for open-source projects. The free tier typically caps the number of projects and managers, making it insufficient for agencies managing multiple clients or certified translation workflows. Paid plans start at roughly $50/month. Teams that need features like translation memory, QA checks, and workflow automation — all common in certified translation production — will generally require a paid subscription.
What is Crowdin?
Crowdin is a cloud-based localization and translation management platform (TMS) designed to help teams organize, automate, and collaborate on translation projects at scale. It supports translation memory, glossaries, QA checks, machine translation integrations, and role-based workflows covering managers, translators, and proofreaders. Agencies and in-house localization teams use it to manage large volumes of multilingual content. While it is widely used for software and app localization, translation agencies also deploy it for document-based projects.
What is Crowdin translation?
Crowdin translation refers to the end-to-end process of managing and producing translations inside the Crowdin platform. Translators work directly in Crowdin's browser-based editor, which surfaces translation memory matches, glossary terms, and machine translation suggestions in real time. Project managers assign tasks, set deadlines, and track progress through dashboards. For agencies producing certified translations, Crowdin can handle the collaborative drafting and review stages, though certification and legal attestation steps typically occur outside the platform.
Related
- Define Localization: What the Term Means in Professional Translation
- Define Transcreation: What It Means Inside a Translator's Workflow
- E-commerce Localization: What Translators and Agencies Actually Deliver
- Expo Localization: What Translators and Agencies Need to Know About expo-localization
- Go i18n: How Translators Handle Golang Localization Handoffs
- How Shopify Localization Works and What It Means for Your Agency