Lokalise + GitHub
Automate Localization Workflows Between Lokalise and GitHub
Keep your translation files and code repositories in sync — no manual exports, no pull request bottlenecks, no back-and-forth.
Why integrate Lokalise and GitHub?
Lokalise and GitHub each do one thing well. Developers store and version their codebase — including locale files — in GitHub. Translators and localization managers work inside Lokalise to manage translations across languages. The problem is the gap between them: someone has to manually export files, commit them, and keep both systems current. With tray.ai, that gap closes. You can automate the entire localization pipeline so your engineering and translation teams always work from the same source of truth.
Automate & integrate Lokalise & GitHub
Use case
Push New Source Strings from GitHub to Lokalise Automatically
When a developer merges a pull request to a main branch that contains changes to locale files, tray.ai detects the change in GitHub and uploads the updated source strings to Lokalise. Translators are notified immediately so they can start working without waiting for a manual handoff. The translation queue stays populated continuously, with no developer effort required.
Use case
Pull Completed Translations Back to GitHub as a Pull Request
Once translations are marked complete in Lokalise for all target languages, tray.ai exports the translation files and opens a pull request in the appropriate GitHub repository and branch. Engineers can review and merge the PR on their own schedule, keeping localized content flowing into the codebase without bottlenecks. The full localization cycle closes programmatically.
Use case
Trigger Localization Tasks When GitHub Issues Are Labeled
When a GitHub issue is labeled with a localization-related tag — such as 'needs-translation' or 'l10n' — tray.ai can automatically create a corresponding task or comment in Lokalise, linking the two systems. Product managers can flag localization needs directly in their issue tracker without switching tools. Localization managers see the request in Lokalise with full context pulled from the GitHub issue.
Use case
Sync Lokalise Translation Status to GitHub Commit Statuses
tray.ai can write translation completion status from Lokalise back to GitHub as commit statuses or check runs, giving developers real-time visibility into whether translations are ready to ship. Localization becomes a first-class check in your CI/CD pipeline, blocking or allowing releases based on actual translation progress. Teams can gate releases on localization completeness without manual status checks.
Use case
Automatically Create Lokalise Keys from New GitHub Commits
When a developer pushes a commit that introduces new translation keys parsed from locale files, tray.ai can automatically create those keys in Lokalise with the correct file format, platform target, and initial source text. Developers don't have to manually set up keys inside Lokalise, and every new string is immediately ready for translation. Tags and metadata can be applied based on the GitHub branch or repository context.
Use case
Notify GitHub Teams When Translations Hit Quality Milestones
When Lokalise reports that a project has reached a defined translation completeness threshold — say, 100% translated and reviewed for all target locales — tray.ai can post a comment on the relevant GitHub pull request or issue to notify the engineering team. Release planning conversations stay grounded in real localization data without anyone logging into Lokalise to check progress. Teams can coordinate shipping decisions without a status update meeting.
Use case
Archive or Tag Lokalise Keys When GitHub Branches Are Deleted
When a GitHub branch is deleted — typically after a pull request is merged or closed — tray.ai can automatically archive or tag the associated Lokalise keys created for that branch's feature work. Orphaned keys don't pile up in your Lokalise project over time, keeping your translation workspace clean and accurate. Localization managers can distinguish active keys from deprecated ones without manual audits.
Get started with Lokalise & GitHub integration today
Lokalise & GitHub Challenges
What challenges are there when working with Lokalise & GitHub and how will using Tray.ai help?
Challenge
Keeping Locale Files in Sync Across Two Different Platforms
Locale files live in GitHub but translations happen in Lokalise, so the two systems fall out of sync whenever changes in one aren't reflected in the other. Teams relying on manual exports and commits regularly find translators working from outdated source strings, or engineers shipping code with stale translations.
How Tray.ai Can Help:
tray.ai listens for real-time events from both GitHub and Lokalise via webhooks, then pushes changes in either direction the moment they occur. Both platforms stay current without manual intervention.
Challenge
Managing Multiple Repositories and Lokalise Projects at Scale
Large engineering organizations often have multiple GitHub repositories — each representing a product, platform, or microservice — with corresponding Lokalise projects. Manually routing locale files between the right repos and the right projects is error-prone and time-consuming.
How Tray.ai Can Help:
tray.ai's workflow logic lets you route data dynamically based on repository name, branch, file path, or custom metadata. A single integration can handle multiple repo-to-project mappings with conditional logic, so files always land in the correct Lokalise project regardless of where they originate.
Challenge
Handling Different File Formats Between Repositories
Different repositories may use different locale file formats — one service might use JSON, another YAML, and a mobile app XLIFF or Android XML. Syncing these formats reliably between GitHub and Lokalise requires format-specific parsing and export configuration that's hard to maintain manually.
How Tray.ai Can Help:
tray.ai supports flexible data transformation steps between GitHub and Lokalise API calls, letting you specify the correct file format for each project or repository in the workflow configuration. Format-specific parameters are passed cleanly to the Lokalise Files API so translations are always imported and exported in the expected format.
Challenge
Avoiding Duplicate Keys and Translation Overwrites
When locale files are pushed to Lokalise from GitHub without deduplication logic, it's easy to overwrite existing translations or create duplicate keys — especially when multiple branches are active simultaneously and all feeding into the same Lokalise project. Translators end up confused, and completed translation work can disappear.
How Tray.ai Can Help:
tray.ai workflows can be configured to use Lokalise's 'insert and replace' or 'insert only' import strategies depending on the context, and can apply branch-specific tags to keys to isolate work from parallel development streams. Logic gates in tray.ai prevent overwrites by checking key existence before creating or updating records in Lokalise.
Challenge
Giving Non-Technical Teams Visibility Into Repository-Driven Localization
Localization managers and translators typically don't have GitHub access and can't easily track which features are in progress, which strings are newly added, or when a release branch is ready for translation. That information gap pushes localization into a reactive mode instead of a planned one.
How Tray.ai Can Help:
tray.ai can extract context from GitHub events — pull request titles, branch names, issue descriptions — and surface that information directly inside Lokalise as comments, task descriptions, or key tags. Localization teams get the context they need in their own tool, without requiring GitHub access or developer involvement.
Start using our pre-built Lokalise & GitHub templates today
Start from scratch or use one of our pre-built Lokalise & GitHub templates to quickly solve your most common use cases.
Lokalise & GitHub Templates
Find pre-built Lokalise & GitHub solutions for common use cases
Template
Sync GitHub Locale File Changes to Lokalise on Merge
Automatically detects changes to locale files in a GitHub repository when a pull request is merged, parses the updated source strings, and uploads them to the corresponding Lokalise project. Supports common formats including JSON, YAML, PO, and XLIFF.
Steps:
- GitHub trigger fires when a pull request is merged into the main branch
- tray.ai fetches changed locale files from the merged commit using the GitHub API
- Files are uploaded to the specified Lokalise project using the Lokalise Files API
Connectors Used: GitHub, Lokalise
Template
Push Completed Lokalise Translations to GitHub as a Pull Request
When all target language translations are marked complete in a Lokalise project, this template exports the translation files and automatically opens a pull request against the configured GitHub repository and branch, ready for engineering review.
Steps:
- Lokalise webhook fires when a project reaches 100% translation completion
- tray.ai exports all translated locale files via the Lokalise Files API
- A new branch is created in GitHub and a pull request is opened with the exported files committed
Connectors Used: Lokalise, GitHub
Template
Create Lokalise Keys from New Strings Detected in GitHub Commits
Monitors GitHub commits for additions or changes to locale source files and automatically creates corresponding keys in Lokalise with source text, platform tags, and file format metadata derived from the repository structure.
Steps:
- GitHub webhook triggers on new commits pushed to a watched branch
- tray.ai parses the diff to identify new or modified translation keys
- New keys are bulk-created in Lokalise with source values and tags mapped from the GitHub branch name and file path
Connectors Used: GitHub, Lokalise
Template
Post Lokalise Translation Progress to GitHub Pull Request Comments
Polls or receives webhook data from Lokalise on translation progress and writes the current completion percentage for each target language as a comment on the corresponding GitHub pull request, keeping engineers informed without leaving GitHub.
Steps:
- Lokalise webhook fires on translation progress updates within a project
- tray.ai retrieves language-level completion statistics from the Lokalise Statistics API
- A formatted comment summarizing translation progress per locale is posted to the linked GitHub pull request
Connectors Used: Lokalise, GitHub
Template
Archive Lokalise Keys When a GitHub Branch Is Deleted
Listens for branch deletion events in GitHub and automatically archives or applies a deprecation tag to the associated Lokalise keys created during that branch's lifecycle, preventing orphaned keys from cluttering the Lokalise workspace.
Steps:
- GitHub webhook fires when a branch is deleted from the repository
- tray.ai queries Lokalise for all keys tagged with the deleted branch name
- Matched keys are archived or tagged as deprecated via the Lokalise Keys API
Connectors Used: GitHub, Lokalise
Template
Create GitHub Issues for Untranslated Strings Detected in Lokalise
Periodically queries Lokalise for keys that are missing translations in one or more target languages and automatically creates GitHub issues assigned to the appropriate team, so untranslated strings are tracked and resolved before release.
Steps:
- tray.ai runs on a scheduled trigger and queries Lokalise for keys with missing translations
- Results are filtered by language, project, and age to prioritize urgent gaps
- A GitHub issue is created for each identified gap with key name, missing locales, and Lokalise project link
Connectors Used: Lokalise, GitHub