per gli sviluppatori

La localizzazione come fase della pipeline.

Avvolgi una stringa in _(), riempi ogni lingua con un comando e modifica qualsiasi traduzione in tempo reale nella tua app in esecuzione: file .po end-to-end, scritti direttamente nel tuo repository. Oppure gestisci il tutto da solo con una vera API HTTP.

Ottieni una chiave APIEsplora gli strumenti
strumenti per sviluppatori e build

Strumenti di build per JavaScript e TypeScript.

Quattro pacchetti npm portano Echo Lingua da una stringa marcata a una traduzione distribuita, senza lasciare la tua base di codice: il runtime @echo-lingua/i18n, l'estrazione e compilazione con @echo-lingua/i18n-cli, il riempimento di ogni locale con @echo-lingua/sdk e la modifica dal vivo nel browser con @echo-lingua/inline-editor. Lo stesso @echo-lingua/i18n-cli gestisce anche PHP e Laravel; vedi strumenti di build per ogni piattaforma di seguito.

@echo-lingua/i18n

Avvolgi le stringhe in _(); il i18n-cli estrae un .po per locale e compila un runtime minuscolo.

Estrazione e compilazione →

@echo-lingua/sdk

Riempi ogni lingua tramite l'API — dalla CLI o da un client tipizzato.

Traduci →

@echo-lingua/inline-editor

Una barra degli strumenti per sviluppatori per modificare le traduzioni nell'app in esecuzione.

Modifica nel browser →
estrazione e compilazione

Avvolgi una stringa. Distribuisci un runtime compatto.

Avvolgi il testo dell'interfaccia utente in _() dal runtime @echo-lingua/i18n; lo strumento @echo-lingua/i18n-cli scansiona la tua sorgente, idrata un .po per locale e compila quelli tradotti in un runtime compatto con segnaposti, plurali e rich text. Aggiungi un contesto, flag o una nota al modello direttamente nel punto di chiamata. Il runtime è opzionale e solo JS; la CLI è la metà agnostica rispetto al progetto.

@echo-lingua/i18n su npm@echo-lingua/i18n-cli su npm
marca le stringhe, aggiungi flag quando ne hai bisogno
import { _, EL } from '@echo-lingua/i18n';

_('Save changes');
_('Hello {name}', { name });
_('You have {count} item', 'You have {count} items', { count });

// La coda delle opzioni: flag, un msgctxt e una nota per il modello.
_('Order', {}, { context: 'verb' });
_('Save', {}, { flags: [EL.CONTEXT_UI_LABEL] });
_('There is a file', 'There are {count} files', { count }, {
  flags: [EL.QUALITY_PRO, EL.CONTEXT_LEGAL],
  comment: 'Shown under the section title',
});
estrazione → compilazione
# Il runtime per la tua app, la toolchain per la tua build
npm i @echo-lingua/i18n
npm i -D @echo-lingua/i18n-cli

# Scansiona il codice, idrata un .po per lingua
npx echo-lingua-i18n extract

# Compila i cataloghi tradotti nel runtime
npx echo-lingua-i18n compile
oltre javascript

Strumenti di build per ogni piattaforma.

L'estrattore e compilatore, @echo-lingua/i18n-cli, è agnostico rispetto al progetto. Scansiona JavaScript, TypeScript e PHP (inclusi i template .phtml), idrata gli stessi file .po e li compila in qualsiasi cosa il tuo runtime legga nativamente: il catalogo JS, un .mo binario per PHP gettext(), o JSON piatto per Laravel __(). Non c'è alcun runtime Echo Lingua da adottare al di fuori di JS; mantieni il tuo. Qualsiasi altro stack gettext (Python, Go, C) guida la stessa piattaforma tramite l'API HTTP qui sotto.

@echo-lingua/i18n-cli su npm
marca le stringhe in PHP o .phtml
<?php
// Marca le stringhe con le funzioni gettext / Laravel che già utilizzi
_('Account settings');
ngettext('one invoice', '{count} invoices', $n);
pgettext('nav', 'Home');
__('Welcome back');   // chiave-stringa Laravel
compila target nativi
// i18n.config.mjs — una configurazione per l'intera toolchain
export default {
  locales: ['de', 'fr'],
  include: ['src/**/*.{php,phtml}'],
  compileTargets: ['mo'],   // o 'laravel' (JSON piatto), o 'js'
};

# Scrive un .mo nativo per locale per PHP gettext()
npx echo-lingua-i18n sync
riempi ogni lingua

Traduci dalla CLI o dal tuo codice.

Il client API e la CLI di traduzione. echo-lingua translate legge la tua configurazione, riempie il .po di ogni lingua tramite l'API e li riscrive. Oppure chiama il client tipizzato dal tuo codice: crea un job, attendi, scarica l'output strutturato come il repository.

@echo-lingua/sdk su npm
la translate CLI
# Riempi il .po di ogni lingua tramite l'API, in loco
npm i @echo-lingua/sdk

# Legge la configurazione, scrive le traduzioni
npx echo-lingua translate
o il client tipizzato
import { EchoLingua } from '@echo-lingua/sdk';

const el = new EchoLingua({ apiKey: process.env.ECHO_LINGUA_KEY });

// Crea un job, attendi il completamento, scarica il file zip strutturato come il repository.
const job = await el.createJob({
  sourceLanguage: 'en',
  contextMode: 'ui-label',
  quality: 'standard',
  inputs: [{ filename: 'de/messages.po', targetLanguage: 'de', content }],
});
const done = await el.waitForJob(job.id, { onProgress: (j) => log(j.status) });
const zip = await el.downloadJob(done.id);
modifica nel browser

Modifica le traduzioni nell'app in esecuzione.

Una barra degli strumenti dedicata agli sviluppatori viene aggiunta alla tua app. Tieni premuto Alt e fai clic su qualsiasi stringa tradotta per modificarne la traduzione in tempo reale, correggere la sorgente inglese, aggiungere un contesto o flag, oppure lasciare che l'AI corregga, accorci o ritraduca. Gestisci le forme plurali, sovrascrivi l'inglese visualizzato ed esegui l'intero ciclo estrazione → traduzione → compilazione: ogni modifica viene scritta direttamente nel tuo repository.

@echo-lingua/inline-editor su npm
aggiungi il plugin Vite (solo dev)
// vite.config.ts — dev only
import { echoLinguaBabel, echoLinguaInlineEditor } from '@echo-lingua/inline-editor';

export default defineConfig(({ command }) => ({
  plugins: [
    react(command === 'serve' ? { babel: { plugins: [echoLinguaBabel()] } } : {}),
    echoLinguaInlineEditor(),
  ],
}));

@echo-lingua/inline-editor

L'editor nel browser. Si abbina a @echo-lingua/i18n: una trasformazione Babel mappa ogni clic alla chiamata _() esatta e un server di sviluppo legge e scrive i tuoi file .po e la sorgente. Non viene mai distribuito in produzione.

l'http api

Oppure configuralo tu stesso.

Non usi JavaScript o stai automatizzando da un altro stack? Ogni funzionalità descritta sopra è una semplice chiamata HTTP: una chiave con ambito, una richiesta POST, un webhook firmato al termine. Gestisce qualsiasi progetto gettext, in qualsiasi linguaggio.

Stima, poi crea

Prova gratuitamente il costo, quindi invia il job tramite POST.

Guida rapida →

Webhook firmati

Consegna firmata HMAC nel momento in cui un job viene completato.

Webhook →

Riferimento completo

Ogni endpoint, ambito e payload.

Riferimento →
guida rapida

Stima il costo, quindi crea il job.

Prova prima dimensione e costo con /v1/jobs/estimate — non viene addebitato nulla — quindi crea l'esecuzione con lo stesso corpo. Ogni voce inputs è un file .po con il proprio targetLanguage; sourceLanguage e contextMode sono obbligatori, quality è draft, standard o pro.

POST /v1/jobs/estimate
curl -X POST https://api.echo-lingua.com/v1/jobs/estimate \
  -H "Authorization: Bearer $ECHO_LINGUA_KEY" \
  -H "Content-Type: application/json" \
  -d @job.json   # same body as the create call — nothing is charged
200 · dimensione + costo, nessun addebito effettuato
{
  "entries": 550,
  "chunks": 10,
  "words": 7400,
  "chargedMicros": 2386500,
  "creditRequiredMicros": 2505825
}
POST /v1/jobs
curl -X POST https://api.echo-lingua.com/v1/jobs \
  -H "Authorization: Bearer $ECHO_LINGUA_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sourceLanguage": "en",
    "contextMode": "ui-label",
    "quality": "standard",
    "inputs": [
      { "filename": "de/messages.po", "targetLanguage": "de", "content": "…" },
      { "filename": "ar/messages.po", "targetLanguage": "ar", "content": "…" }
    ]
  }'
201 · il lavoro creato
{
  "id": "job_8f2c41",
  "status": "QUEUED",
  "sourceLanguage": "en",
  "contextMode": "ui-label",
  "quality": "standard",
  "createdAt": 1726669120000
}
autenticazione e chiavi con ambito

Un token bearer. Gli ambiti che gli assegni.

Crea chiavi nell'app; ognuna viene mostrata once, ha una data di scadenza ed è revocabile. L'utilizzo è attribuito per chiave. Esegui l'autenticazione con un singolo header:

ogni richiesta
Authorization: Bearer elk_live_2b7f…
# elk_-prefixed. Mostrato una sola volta alla creazione, salvalo in un segreto.

translate:write

Crea lavori, riprova gli elementi falliti, annulla le esecuzioni.

jobs:read

Leggi lo stato e i conteggi dei lavori, elenca i lavori, scarica l'output.

webhook

Invio firmato, niente polling.

Registra un endpoint per job.completed e job.failed. Ogni invio è firmato HMAC-SHA256 sul corpo raw; verificalo prima di considerarlo attendibile. I tentativi utilizzano un backoff esponenziale limitato.

invio · intestazioni + corpo
POST https://your-app.example/hooks/echo-lingua
X-EchoLingua-Signature: 9f86d0818… (HMAC-SHA256 esadecimale del corpo grezzo)
X-EchoLingua-Timestamp: 1726669123456
X-EchoLingua-Delivery: whd_3f9c8a

{
  "id": "whd_3f9c8a",
  "type": "job.completed",
  "createdAt": 1726669123456,
  "data": {
    "jobId": "job_8f2c41",
    "status": "COMPLETE",
    "downloadUrl": "/v1/jobs/job_8f2c41/download"
  }
}
verify.ts, sul corpo raw
import { createHmac, timingSafeEqual } from 'node:crypto';

// Verifica sul corpo della richiesta GREZZO, prima del parsing JSON.
export function verify(rawBody, signature, secret) {
  const expected = createHmac('sha256', secret).update(rawBody).digest('hex');
  const a = Buffer.from(signature);
  const b = Buffer.from(expected);
  return a.length === b.length && timingSafeEqual(a, b);
}
nella tua pipeline

Traduci al rilascio, apri la PR.

Avvia un lavoro dalla CI, lascia che il webhook firmato ti avvisi al completamento, quindi scarica l'output strutturato come repository e apri una pull request, senza passare dal browser.

.github/workflows/translate.yml
name: Translate on release
on:
  release:
    types: [published]
jobs:
  translate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Kick off a translation job
        run: |
          curl -sS -X POST https://api.echo-lingua.com/v1/jobs \
            -H "Authorization: Bearer ${{ secrets.ECHO_LINGUA_KEY }}" \
            -H "Content-Type: application/json" \
            -d @job.json
      # Un webhook `job.completed` firmato apre la PR con i cataloghi tradotti.
riferimento

Gli endpoint che userai davvero.

POST/v1/jobstranslate:writeCrea un lavoro di traduzione.
POST/v1/jobs/estimatetranslate:writeSimulazione di dimensionamento + costi, nessun lavoro creato.
POST/v1/jobs/plantranslate:writeSimulazione di classificazione per voce.
GET/v1/jobsjobs:readElenca i tuoi lavori.
GET/v1/jobs/{id}jobs:readRecupera lo stato e il conteggio di un lavoro.
GET/v1/jobs/{id}/downloadjobs:readScarica lo zip di output (strutturato come un repository).
GET/v1/jobs/{id}/reviewjobs:readElementi contrassegnati per la revisione.
POST/v1/jobs/{id}/retrytranslate:writeEsegui nuovamente solo gli elementi non riusciti.
POST/v1/jobs/{id}/canceltranslate:writeAnnulla un lavoro in esecuzione.
POST/v1/translate/texttranslate:writeTraduci un blocco di testo in linea, senza creare un lavoro.
POST/v1/translate/codetranslate:writeTraduci i valori letterali delle stringhe in uno snippet di codice.
POST/v1/translate/estimatetranslate:writeCalcola il prezzo di una traduzione sincrona, gratis.
POST/v1/templatestranslate:writeGenera modelli PO vuoti per lingua.
GET/v1/usagejobs:readUtilizzo, costi e limiti del periodo corrente.

Gli endpoint sopra sono quelli che utilizzerai per primi. Visualizza tutti gli endpoint nella documentazione →

Rilascia qualsiasi lingua direttamente dalla tua pipeline.

Crea una chiave con ambito, invia un lavoro tramite POST e configura il webhook. Il costo fisso del primo mese è offerto da noi.

Ottieni una chiave API