Headless CMS + PolyLingo

Fler språk för headless CMS.

Polylang gav WordPress-sajter ett komplett flerspråkigt arbetsflöde. PolyLingo tar det arbetsflödet till Sanity, Contentful, Webflow, Framer och alla andra headless CMS — via ett REST API som integreras på en eftermiddag.

Sanity
exempel på full integration
Contentful
exempel på full integration
Webflow
exempel på full integration
36
mål språk

Flerspråkighet i headless CMS är ett olöst problem.

Sanity har internationaliseringsplugin. Contentful har lokaler. Men ingen av dem översätter ditt innehåll — de lagrar det bara på flera språk. Att fylla dessa språkplatser är fortfarande en manuell process. Exportera det engelska innehållet, kör det genom ett översättningsverktyg som förstör din rich text- eller JSON-struktur, rätta till resultatet, importera tillbaka, upprepa för varje språk. För ett aktivt innehållsteam som publicerar regelbundet skalar inte detta arbetsflöde. Det finns inte heller för de flesta mindre lösningar, vilket innebär att innehållet aldrig blir översatt alls.

Headless CMS-arkitekturen separerar innehållshantering från innehållsleverans. Detta är bra för flexibilitet. Men det skapar en lucka: CMS lagrar språkvarianter, men inget fyller dessa språkvarianter med översatt innehåll. Du måste bygga det lagret själv.

De flesta team hamnar i en av två situationer: de översätter innehåll manuellt genom att kopiera det till DeepL och klistra tillbaka det (långsamt, felbenäget, skalar inte), eller så skriver de en anpassad integration med ett översättnings-API som de måste underhålla på obestämd tid. Ingen av dessa är ett bra svar. PolyLingo är ett rent tredje alternativ.

PolyLingo är översättningslagret som ditt CMS saknar.

PolyLingo integreras direkt med ditt CMS publiceringsarbetsflöde. Ställ in en webhook som aktiveras när innehåll publiceras, skicka innehållet till PolyLingo, ta emot översatta versioner för varje språk, skriv tillbaka dem till ditt CMS. För Sanity är detta några rader i en serveråtgärd. För Contentful är det en webhook-hanterare. För anpassade lösningar är det ett HTTP-anrop. Översättningsmodellen förstår ditt innehållsformat — Markdown, HTML, JSON, rich text — och bevarar strukturen genomgående.

Mönstret är konsekvent över alla CMS: hämta innehåll på ditt källspråk, anropa PolyLingo API med alla målspråk, skriv tillbaka det översatta innehållet till CMS via dess hanterings-API. Detta körs som ett byggtidsskript, en CI-jobb eller en webhook-hanterare — vad som passar ditt arbetsflöde.

PolyLingo hanterar Markdown, HTML och vanlig text, så det fungerar med vilket format ditt CMS än använder för rikt innehåll. Strukturerade fält (rubriker, brödtext, utdrag) kan översättas individuellt för att ge dig detaljerad kontroll över vilka fält som översätts.

🟠

Sanity + PolyLingo

Sanitys Document Internationalization-plugin skapar länkade dokumentvarianter per lokal. Skriptet nedan hämtar de engelska basdokumenten och skapar automatiskt översatta varianter för varje målspråk.

Fungerar med dokumentnivåns i18n-mönster (ett dokument per lokal) samt fältnivåns mönster (alla lokaler i ett dokument). För fältnivåmönstret, loopa över fälten istället för dokumenten.

scripts/translate-sanity.mjs
// scripts/translate-sanity.mjs
// Fetches published posts and translates each to all target languages

import { createClient } from '@sanity/client'

const sanity = createClient({
  projectId: process.env.SANITY_PROJECT_ID,
  dataset: 'production',
  token: process.env.SANITY_TOKEN,
  apiVersion: '2024-01-01',
  useCdn: false,
})

const posts = await sanity.fetch(`*[_type == "post" && __i18n_lang == "en"]`)

for (const post of posts) {
  const response = await fetch('https://api.usepolylingo.com/v1/translate', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.POLYLINGO_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      content: post.body_markdown,
      format: 'markdown',
      targets: ['es', 'fr', 'de', 'ja', 'zh'],
    }),
  })

  const { translations } = await response.json()

  for (const [lang, content] of Object.entries(translations)) {
    await sanity.create({
      _type: 'post',
      __i18n_lang: lang,
      __i18n_base: { _type: 'reference', _ref: post._id },
      title: translations[lang + '_title'] || post.title,
      slug: { current: `${post.slug.current}-${lang}` },
      body_markdown: content,
    })
  }
}
🔵

Contentful + PolyLingo

Contentful lagrar lokalvarianter som fält på samma post. Skriptet nedan använder Contentful Management API för att hämta engelska poster, översätta dem och skriva det översatta innehållet direkt till de lokal-specifika fälten — ingen manuell kopiering krävs.

Contentful använder BCP 47-lokalkoder (t.ex. es-ES istället för es). Mappa PolyLingos ISO 639-1-koder till din Contentful-lokalinställning därefter.

scripts/translate-contentful.mjs
// scripts/translate-contentful.mjs
// Translates Contentful entries to all target locales

import contentful from 'contentful-management'

const client = contentful.createClient({
  accessToken: process.env.CONTENTFUL_MANAGEMENT_TOKEN,
})

const space = await client.getSpace(process.env.CONTENTFUL_SPACE_ID)
const env = await space.getEnvironment('master')
const entries = await env.getEntries({ content_type: 'blogPost', locale: 'en-US' })

for (const entry of entries.items) {
  const enBody = entry.fields.body['en-US']

  const response = await fetch('https://api.usepolylingo.com/v1/translate', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.POLYLINGO_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      content: enBody,
      format: 'markdown',
      targets: ['es-ES', 'fr-FR', 'de-DE'],
    }),
  })

  const { translations } = await response.json()

  for (const [locale, content] of Object.entries(translations)) {
    entry.fields.body[locale] = content
  }

  await entry.update()
  await entry.publish()
}
🌀

Webflow + PolyLingo

Webflows Localization API (tillgängligt på CMS- och Business-planer) stödjer lokal-specifikt fältinnehåll. Skriptet nedan hämtar CMS-samlingselement, översätter HTML-brödtextfältet och skriver tillbaka översättningar till varje lokalvariant via Webflow v2 API.

Webflow lagrar rich text-fält som HTML. PolyLingos HTML-översättning bevarar all Webflow-genererad markup — anpassade klasser, attribut och inbäddade element — orörd.

scripts/translate-webflow.mjs
// scripts/translate-webflow.mjs
// Webflow Localization API + PolyLingo

const headers = {
  'Authorization': `Bearer ${process.env.WEBFLOW_API_TOKEN}`,
  'accept-version': '2.0.0',
  'Content-Type': 'application/json',
}

// Fetch English CMS items
const itemsRes = await fetch(
  `https://api.webflow.com/v2/collections/${process.env.WEBFLOW_COLLECTION_ID}/items`,
  { headers }
)
const { items } = await itemsRes.json()

for (const item of items) {
  const response = await fetch('https://api.usepolylingo.com/v1/translate', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.POLYLINGO_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      content: item.fieldData['body-html'],
      format: 'html',
      targets: ['es', 'fr', 'de'],
    }),
  })

  const { translations } = await response.json()

  // Write translated content back to Webflow locale fields
  for (const [lang, content] of Object.entries(translations)) {
    await fetch(
      `https://api.webflow.com/v2/collections/${process.env.WEBFLOW_COLLECTION_ID}/items/${item.id}/locales/${lang}`,
      { method: 'PATCH', headers, body: JSON.stringify({ fieldData: { 'body-html': content } }) }
    )
  }
}

Vad PolyLingo ger headless CMS-användare

  • Sanity — översätt vid publicering via webhook, skriv tillbaka till dokumentlokaler
  • Contentful — översätt poster automatiskt när den engelska lokalen uppdateras
  • Webflow — översätt CMS-samlingselement via API:et
  • Vilket headless CMS som helst med ett API — integrationsmönstret är detsamma
  • Rich text, Markdown och HTML bevaras korrekt
  • Alla 36 språk i en förfrågan — inga anrop per språk
  • Fungerar med vilket CMS som helst som har ett hanterings-API
  • Innehåll kan översättas om vid varje publicering — ingen manuell synkronisering

Standardarbetsflödet för flerspråkigt CMS

1

Skriv innehåll på ditt källspråk

Skapa och publicera innehåll på engelska (eller vilket språk som är ditt källspråk). Ditt CMS lagrar detta som den auktoritativa versionen. Du behöver inte ändra ditt redaktionella arbetsflöde alls.

2

Starta översättningsskriptet

Kör skriptet manuellt, schemalagt eller via en webhook som triggas av publiceringshändelser i ditt CMS. Skriptet anropar PolyLingo en gång per dokument med alla målspråk, och skriver sedan tillbaka alla översättningar till ditt CMS i ett svep.

3

Distribuera — översatt innehåll är live

Din frontend läser lokal-specifikt innehåll från CMS som vanligt. Inga ändringar i din frontend-kod krävs. Det översatta innehållet visas på rätt språk för varje lokal väg.

Vem detta är byggt för

✍️

Innehållsteam på Sanity eller Contentful

Dina redaktörer publicerar på engelska. Översatt innehåll visas automatiskt i alla lokaler utan att redaktionsteamet behöver använda översättningsverktyg.

🏢

Byråer som bygger flerspråkiga sajter

Varje kundsajt du bygger behöver flerspråkigt stöd. PolyLingo ger dig en återanvändbar, fakturerbar integration som fungerar med vilket headless CMS som helst i din stack.

🌍

E-handel med lokaliserat produktinnehåll

Produktbeskrivningar, kategorisidor och blogginnehåll — allt översätts automatiskt vid publicering. Kombinera med lokal-specifik prissättning för att leverera en helt lokaliserad shoppingupplevelse.

Vanliga frågor om flerspråkighet i headless CMS

Fungerar PolyLingo med CMS som inte finns listade här?

Ja. Alla CMS med ett hanterings-API kan integreras med samma mönster — hämta innehåll, anropa PolyLingo, skriv tillbaka. Prismic, Storyblok, DatoCMS, Strapi, Ghost och Directus har alla hanterings-API:er och fungerar med detta tillvägagångssätt. Integrationsexemplen för Sanity, Contentful och Webflow ovan illustrerar mönstret.

Kan jag översätta rich text med inbäddade bilder och länkar?

Ja. HTML-översättningen bevarar alla inbäddade element inklusive bilder (src- och alt-attribut hanteras korrekt), länkar (href bevaras, länktext översätts) och iframes. Det enda undantaget är innehåll som uttryckligen markerats som icke-översättningsbart — kodblock, till exempel, översätts aldrig.

Hur hanterar jag innehåll som inte ska översättas?

För strukturerat innehåll med icke-översättningsbara fält (slugs, datum, tekniska identifierare), skicka bara de fält du vill översätta. För rich text med blandade översättningsbara och icke-översättningsbara sektioner, använd HTML-formatet — PolyLingo översätter textinnehållet samtidigt som kodblock och andra strukturerade element bevaras automatiskt.

Vad händer om mitt CMS har nästlade innehållstyper?

För djupt nästlat innehåll (dokument med referenser till andra dokument), översätt varje dokumenttyp oberoende. Detta undviker cirkulära referenser och ger dig tydlig kontroll över vilket innehåll som översätts. Referenser mellan dokument hanteras av CMS — PolyLingo berör bara fältinnehållet, inte dokumentrelationerna.

Hur håller jag översättningar synkade när källinnehållet ändras?

Det rekommenderade mönstret är att trigga översättningsskriptet vid varje publiceringshändelse via en CMS-webhook. Detta säkerställer att översatt innehåll uppdateras när källan ändras. För mindre frekventa innehållsuppdateringar fungerar det lika bra att köra skriptet på nattschema eller före varje produktionsdistribution.

Finns det ett sätt att markera översättningar som "behöver granskning" istället för att publicera automatiskt?

Det beror på ditt CMS. Contentful och Sanity stödjer båda utkaststillstånd — du kan skriva översatt innehåll som utkast istället för publicerat, vilket möjliggör manuell granskning innan varje lokal går live. Skriptexemplen ovan använder publicera/skapa direkt; ändra sista steget för att skapa utkast istället för en granskningsarbetsflöde.

Lägg till flerspråkighet i ditt headless CMS idag.

Gratisnivå. 100 000 tokens per månad. Inget kreditkort krävs.

Börja översätta gratis

Gratisnivå — 100 000 tokens per månad. Fungerar med vilket CMS som helst.

Fler språk för headless CMS — Sanity, Contentful och mer — PolyLingo | PolyLingo