Text United

Webflow Localize adds secondary locales, locale subdirectories, and machine translation to a site. Every locale still needs translation, review, and syncing with each content update. A translation management system stores translation memory and approved terminology, and routes segments to human translators. Teams with glossaries, reviewers, and compliance gates need that layer connected to the site they publish.

Text United crawls a published Webflow site, pre-translates it with machine translation, and hands segments to reviewers. A snippet in the site-wide head code serves those results on published pages, and Collection content takes a separate path. Through the Webflow Data API, Webflow webhooks notify your middleware, which sends new Collection items to translation. The middleware then writes results into secondary locales, and approved sentences enter translation memory so later updates can reuse them.

Marketing managers who ship pages in several languages can use the snippet route for campaign pages. Localization managers coordinating agencies and in-house reviewers can use the project workflow to set up approval gates. Webflow agencies serving manufacturing, software, and regulated clients can run a separate Text United project for each client. Developers maintaining localized Collections of blog posts, help docs, or product entries can build the API path.

How to integrate Text United with Webflow

Text United is a translation management system with translation memory, terminology enforcement, and Automatic Post-Editing of machine translation, and it routes segments to human translators. It imports terminology from CSV files, and its REST API accepts text segments and returns translations with a status for each language.

Text United connects to Webflow in three ways, each covered below. The website translator snippet translates crawled pages and adds a language selector from one script in the site-wide head code. CSV file translation pairs Webflow's Collection export and import with Text United's CSV support, though each half is documented separately rather than as one round trip. The Webflow and Text United APIs give programmatic control over translating Collection items and writing back locales, and they need server-side development.

Add the Text United website translator snippet to Webflow head code

Text United's Webflow setup guide, last updated in May 2023, describes a crawler that scans your published pages. A JavaScript snippet then displays the translations to visitors. Use this route for a live marketing site in other languages. Text United's setup steps don't include adding Webflow locales, and the guide doesn't say how the snippet handles Collection pages. You need a Text United account and a Webflow site eligible for custom code.

Text United's guide covers only the site-wide Head code field, so install the script there rather than in page-level custom code or a Code Embed element.

To set up the integration:

1. In Text United, click Start a New Project and select Website Translation.
2. Click SCAN to crawl the published site. You can click STOP partway, test a few pages, and add others later.
3. Select the landing pages you want to translate.
4. Choose target languages, choose whether to pre-translate with machine translation, and click Continue.
5. Choose Me and my team to translate with your own people, or Professional full service to order from Text United linguists, then click CREATE A PROJECT.
6. Open the project, go to the Install code tab, and click COPY SCRIPT.
7. In Webflow, go to Site settings > Custom code > Head code, paste the script, and click Save changes. The head code field accepts up to 50,000 characters.
8. Publish the Webflow site. Custom code shows in preview but only goes live on publish.
9. Back in Text United, open the project and click PUBLISH. Translations appear on the site only after this step.

Once both sides are published, visitors and editors get four things from the snippet route.

• Translation source: Content is pre-translated by machine and corrected by your team, or translated in full by Text United as a paid service.
• Overlay editor: Text United's guide calls it "a tool for light editing and previewing your website", and it opens from the project list.
• Language selector: The script generates the selector near the end of the body tag on each page load, and only when translations are published.
• Immediate updates: New translations appear as soon as you publish them, because the default snippet fetches them from Text United servers.

That last point is a runtime dependency: every page view calls Text United unless you host the translations yourself, as described below.

Customize the language selector

The generated selector is 145px wide and sits at right: 15px, top: 15px by default. Its CSS lives in a style tag in the head. Text United's selector article covers restyling it from the same tab that holds the install code.

To restyle the selector:

1. Open the project's Install code tab and click CUSTOMIZE.
2. Adjust text size, color, border, and position with the controls.
3. For anything the controls don't expose, add your own CSS that targets the #text-united-languages ID selector, for example in Webflow's site-wide head code.
4. Reload a published page to confirm the new styling.

If a visitor drags the selector, their browser keeps the new position until they clear the cache or cookies. Check style changes in a fresh session.

Host translations on your own server

The default snippet fetches translations from Text United servers through its API. An advanced option in the self-hosting article stores the translated content on a server you control. The snippet then stops calling Text United at runtime.

To self-host the translations:

1. In the project's Install code tab, select the second code snippet.
2. Download the file from the URL in that snippet.
3. Upload it to your own server.
4. Change the URL in the snippet to your hosted file, then update the head code in Webflow and republish.
5. Repeat the download and upload after every project change, because self-hosted updates are manual.

Text United also offers an alternative snippet that packages all translations inside the JavaScript file. Its size grows with your project data, and you update the code after each project change.

Translate Collection content with CSV files

The Webflow CMS exports Collection items as CSV and imports translated CSVs into a chosen locale. Text United doesn't publish a Webflow-specific CSV guide, so treat this as an assembled workflow. Text United translates CSV files, but its CSV formatting guide treats all text in a CSV as translatable and splits unquoted text into separate segments at each comma. Together they move blog posts or product entries through human review without a server.

Test with a small Collection first. Webflow matches imported rows to existing items by the Item ID column and maps fields by header name, so headers and Item IDs must come back untranslated. Collection items are unique per locale, while the Collection and its fields are shared across locales.

To translate a Collection by CSV:

1. In Webflow, open the Localize panel > Locales > Add new locale and set up the secondary locale. Manage your site's locales covers each setting.
2. Export the Collection as CSV from the primary locale. Exports contain only the current locale view, per Localize Collection content.
3. In Text United, upload the CSV. Pick Translate file(s) for a fast pass that keeps the file structure. Pick Translate projects for roles, approval gates, translation memory, and terminology, as the approach guide explains.
4. Download the translated CSV once segments reach the status your workflow requires. The approach guide documents the download for Translate file(s); for a project, confirm the export step in your account. Compare the headers, Item IDs, and slugs against the original export.
5. Switch Webflow to the secondary locale. Import the translated CSV, target the current locale, and choose Link and update matching items, per the CSV import guide.

The project route also builds assets you keep. Approved sentences feed translation memory for later exports, and preferred terms from your terminology repository are enforced in automatic pre-translation and suggested to translators in the editor, on plans that support terminology enforcement, per Text United's terminology guide.

Build with the Webflow and Text United APIs

For Collections that change often, connect Webflow webhooks to the Text United API through middleware you host. This developer-built pattern assembles the separately documented Webflow and Text United APIs without a native connector or a Text United-authored Webflow API recipe. New or changed items go to translation automatically. Your middleware retrieves finished translations and writes them to secondary locales as staged or published items. This needs server-side development and a Text United account with API access enabled. The pattern uses collection_item_created and collection_item_changed webhooks and a PATCH write-back.

Generate a Webflow token under Site settings > Apps & integrations > API access > Generate API token. Give it cms:read, cms:write, sites:read, and sites:write. Only site administrators can create tokens, and Webflow's site token docs allow up to 5 per site.

Four sets of endpoints carry the build.

• Text United API: The Text United API at https://api.textunited.com handles project creation, progress, and translated segment retrieval.
• Webflow CMS API: Webflow's Data API reads and writes localized CMS items and publishes each locale independently.
• Webflow webhooks: Webflow webhooks notify your middleware when items are created, changed, or published.
• Webflow Pages API: The Update Page Content endpoint writes translated static page text into a secondary locale with a localeId, and it needs the pages:write scope.

The steps below cover Collection items, the most common case. Static pages follow the same pattern through the Pages API.

Send new Collection items to Text United as translation projects

A collection_item_created webhook fires when an editor adds an item. Your receiver reads the payload and fetches any fields it lacks. It then opens a Text United project with one segment per field. The API guide from February 2026 documents the project schema.

To wire the trigger:

1. Register the webhook with POST https://api.webflow.com/v2/sites/{site_id}/webhooks (scope sites:write). The body names the event and your endpoint.

{
  "triggerType": "collection_item_created",
  "url": "https://your-middleware.example.com/webflow/items"
}

2. On each delivery, verify the x-webflow-signature header, a SHA-256 HMAC of the x-webflow-timestamp value and the request body. The signing key is the webhook's own secret key, returned when you create it with a site token, or your OAuth app's client secret. Also reject stale timestamps. Webhooks created in the Webflow dashboard don't carry these headers, so register through the API.
3. Read id, collectionId, cmsLocaleId, and fieldData (name, slug) from the event payload. Fetch the rest with GET /v2/collections/{collection_id}/items/{item_id}.
4. Authenticate to Text United with Basic Auth (your company ID and API key) or a JWT. POST /authentication/token with your email and password returns AccessToken and RefreshToken, as the authentication docs describe.
5. Call POST /segments/projects with the required name, startDateUtc, endDateUtc, targetLanguages, and segments, plus customId and sourceLanguageCode. Each segment is a customId and content pair. Each target language takes a targetLanguageCode and flags serviceAutomaticTranslation, serviceTranslation, serviceProofreading, and managedProject. Language codes follow IETF BCP 47.
6. Store the project customId against the Webflow item id. The API supports lookup by both Text United ID and custom ID.

The API guide specifies application/json-patch+json as the POST content type. The API reference lists application/json for endpoints, so test which content type your account accepts.

Use the Webflow field slug as each segment's customId. The write-back step can then map translations to fields without a second lookup table.

Write translations back to secondary locales

Text United's API reference lists no completion webhook. The middleware polls GET /segments/projects/{id}/progress and retrieves segments from GET /segments/projects/custom/{customId}/segments once they reach the status you accept. It then writes translations into the matching locale with PATCH /v2/collections/{collection_id}/items/{item_id} and publishes them with POST /v2/collections/{collection_id}/items/publish. Webflow's CMS localization guide, linked above, explains the locale identifiers.

To write translations back:

1. Poll GET /segments/projects/{id}/progress, which returns per-language progress values (progress reference).
2. Call GET /segments/projects/custom/{customId}/segments. Each translation carries languageCode, content, and status. Accept translated or proofread when human review is mandatory. The API guide describes the status moving from automatic through translated and proofread as human work advances.
3. Resolve locale IDs with GET /v2/sites/{site_id}, which returns locales.secondary[].cmsLocaleId. This value differs from the locale's id, which the Pages API uses.
4. Check whether the item has a variant in the target locale. Items created through the API without cmsLocaleIds or allCmsLocales exist only in the primary locale. If the variant is missing, call Create Items with the item's id and the new locale in cmsLocaleIds first. Test on one item.
5. Call PATCH /v2/collections/{collection_id}/items/{item_id} with the locale and translated fields. Omit cmsLocaleId and you overwrite the primary locale instead.

{
  "cmsLocaleId": "<secondary cmsLocaleId>",
  "fieldData": {
    "name": "<translated title>",
    "slug": "<translated-slug>"
  }
}

6. Publish with POST /v2/collections/{collection_id}/items/publish and items: [{ "id": "<item_id>", "cmsLocaleIds": ["<secondary cmsLocaleId>"] }]. Each locale has its own publishing state.

Translated page slugs need the Localize Advanced add-on or Enterprise Localization, per Webflow's page localization guide. The Data API doesn't currently support localizing images, according to the Localization APIs guide, so send only text fields to translation.

What you can build with the Text United Webflow integration

Most builds pair Text United's review workflow with Webflow's locale subdirectories.

• Multi-language campaign launches: Store launch page copy as Collection items on a Collection template page and send it through the CSV or API route to /de and /fr locales. Hero copy and meta titles follow approved terminology, and translation memory keeps regional wording consistent across campaigns.
• Localized blog publishing: A collection_item_published or collection_item_created webhook fires when a post is published or created. Middleware opens a Text United project, and the translations land as draft items in each secondary locale. Editors review the drafts in Webflow before publishing.
• Multilingual knowledge bases: When a writer edits a help article, collection_item_changed sends it back to Text United. Translation memory reuses the approved sentences, so translators focus on the new text.
• Localized product information Collections: Specs, descriptions, and SEO fields in a product-information Collection go to translation when the team updates the primary locale. Images, numbers, and reference fields stay as they are.

Start with the snippet if you need a translated marketing site quickly, and move Collection content to the CSV or API route when each market needs its own indexed locale.