google-text-to-speech - spanish - text to speech sitepal

Google Translate TTS API bloqueado

Question

Google implementó un captcha para impedir que las personas accedan a la API de traducción de TTS https://translate.google.com/translate_tts?ie=UTF-8&q=test&tl=zh-TW . Lo estaba usando en mi aplicación móvil. Ahora, no está devolviendo nada. ¿Cómo me muevo por el captcha?

Answer 1

Agregue el calificador ''& client = tw-ob'' al final de su consulta. https://translate.google.com/translate_tts?ie=UTF-8&q=test&tl=zh-TW&client=tw-ob

Esta respuesta ya no funciona consistentemente. Google bloqueará temporalmente su dirección IP si abusa de esto demasiado.

Answer 2

Primero, para evitar el captcha, debe establecer un agente de usuario adecuado como:
"Mozilla / 5.0 (X11; Ubuntu; Linux x86_64; rv: 46.0) Gecko / 20100101 Firefox / 46.0"

Luego, para no ser bloqueado, debe proporcionar un token adecuado ("tk" obtener el parámetro) para cada solicitud individual.
En la web puede encontrar diferentes tipos de scripts que intentan calcular el token después de una gran cantidad de ingeniería inversa ... pero cada vez que la gran G cambia el algoritmo, se queda atascado nuevamente, por lo que es mucho más fácil recuperar su token. observando en profundidad solicitudes similares para traducir la página (con su texto en la url).
Puede leer el tiempo de token por grepping "tk =" de la salida de este código simple con phantomjs:

"use strict";
var page = require(''webpage'').create();
var system = require(''system'');
var args = system.args;
if (args.length != 2) { console.log("usage: "+args[0]+" text");  phantom.exit(1); }
page.onConsoleMessage = function(msg) {     console.log(msg); };
page.onResourceRequested = function(request) {   console.log(''Request '' + JSON.stringify(request, undefined, 4)); };
page.open("https://translate.google.it/?hl=it&tab=wT#fr/it/"+args[1],     function(status) {
if (status === "success")    {             phantom.exit(0);           } 
else {      phantom.exit(1);    }
});

así que al final puedes hablar con algo como:
wget -U "Mozilla / 5.0 (X11; Ubuntu; Linux x86_64; rv: 46.0) Gecko / 20100101 Firefox / 46.0" " http://translate.google.com/translate_tts?ie=UTF-8&tl=it&tk=52269.458629&q=ciao&client=t "-O ciao.mp3
(El token probablemente esté basado en el tiempo, por lo que este enlace puede no funcionar mañana)

Answer 3

También puedes probar este formato:

1. pase q = formato urlencode de su idioma (en JavaScript puede usar la función encodeURI () y PHP tiene la función rawurlencode ())

2. pase tl = nombre corto del idioma (supongamos que bangla = bn)

Ahora prueba esto:

https://translate.google.com.vn/translate_tts?ie=UTF-8&q=%E0%A6%A2%E0%A6%BE%E0%A6%95%E0%A6%BE+&tl=bn&client=tw-ob

Answer 4

hay 3 temas principales:

1. debe incluir "cliente" en su cadena de consulta (cliente = t parece funcionar).
2. (En caso de que esté intentando recuperarlo utilizando AJAX), el remitente de la solicitud HTTP debe ser https://translate.google.com/
3. El campo "tk" cambia para cada consulta, y debe rellenarse con un hash coincidente: tk = hash (q, TKK), donde q es el texto a TTSed, y TKK es una var en el ámbito global cuando se carga. .google.com: (escribe ''window.TKK'' en la consola). vea la función hash en la parte inferior de esta respuesta (calcHash).

para resumir:

function generateGoogleTTSLink(q, tl, tkk) {
    var tk = calcHash(q, tkk);
    return `https://translate.google.com/translate_tts?ie=UTF-8&total=1&idx=0&client=t&ttsspeed=1&tl=${tl}&tk=${tk}&q=${q}&textlen=${q.length}`;
}

generateGoogleTTSLink(''ciao'', ''it'', ''410353.1336369826'');
// see definition of "calcHash" in the bottom of this comment.

=> para obtener un TKK, puede abrir el sitio web de Google Translate y luego escribir "TKK" en la consola de herramientas del desarrollador (por ejemplo: "410353.1336369826").

TENGA EN CUENTA que el valor TKK cambia cada hora y, por lo tanto, los TKK antiguos pueden bloquearse en algún momento, y puede que sea necesario actualizarlos (aunque hasta ahora parece que las claves antiguas pueden funcionar por MUCHO TIEMPO).

Si desea actualizar TKK periódicamente, puede automatizarse con bastante facilidad, pero no si está ejecutando su código desde el navegador.

Puede encontrar una implementación completa de NodeJS aquí: https://github.com/guyrotem/google-translate-server . expone una API TTS mínima (consulta, idioma), y se implementa en un servidor Heroku gratuito, por lo que puede probarlo en línea si lo desea.

function shiftLeftOrRightThenSumOrXor(num, opArray) {
 return opArray.reduce((acc, opString) => {
  var op1 = opString[1]; // ''+'' | ''-'' ~ SUM | XOR
  var op2 = opString[0]; // ''+'' | ''^'' ~ SLL | SRL
  var xd = opString[2]; // [0-9a-f]

  var shiftAmount = hexCharAsNumber(xd);
  var mask = (op1 == ''+'') ? acc >>> shiftAmount : acc << shiftAmount;
  return (op2 == ''+'') ? (acc + mask & 0xffffffff) : (acc ^ mask);
 }, num);
}

function hexCharAsNumber(xd) {
 return (xd >= ''a'') ? xd.charCodeAt(0) - 87 : Number(xd);
}

function transformQuery(query) {
 for (var e = [], f = 0, g = 0; g < query.length; g++) {
   var l = query.charCodeAt(g);
   if (l < 128) {
    e[f++] = l;     // 0{l[6-0]}
   } else if (l < 2048) {
    e[f++] = l >> 6 | 0xC0;  // 110{l[10-6]}
    e[f++] = l & 0x3F | 0x80; // 10{l[5-0]}
   } else if (0xD800 == (l & 0xFC00) && g + 1 < query.length && 0xDC00 == (query.charCodeAt(g + 1) & 0xFC00)) {
    // that''s pretty rare... (avoid ovf?)
    l = (1 << 16) + ((l & 0x03FF) << 10) + (query.charCodeAt(++g) & 0x03FF);
    e[f++] = l >> 18 | 0xF0;  // 111100{l[9-8*]}
    e[f++] = l >> 12 & 0x3F | 0x80; // 10{l[7*-2]}
    e[f++] = l & 0x3F | 0x80;  // 10{(l+1)[5-0]}
   } else {
  e[f++] = l >> 12 | 0xE0;  // 1110{l[15-12]}
  e[f++] = l >> 6 & 0x3F | 0x80; // 10{l[11-6]}
  e[f++] = l & 0x3F | 0x80;  // 10{l[5-0]}
   }
 }
 return e;
}

function normalizeHash(encondindRound2) {
 if (encondindRound2 < 0) {
  encondindRound2 = (encondindRound2 & 0x7fffffff) + 0x80000000;
 }
 return encondindRound2 % 1E6;
}

function calcHash(query, windowTkk) {
 // STEP 1: spread the the query char codes on a byte-array, 1-3 bytes per char
 var bytesArray = transformQuery(query);

 // STEP 2: starting with TKK index, add the array from last step one-by-one, and do 2 rounds of shift+add/xor
 var d = windowTkk.split(''.'');
 var tkkIndex = Number(d[0]) || 0;
 var tkkKey = Number(d[1]) || 0;

 var encondingRound1 = bytesArray.reduce((acc, current) => {
  acc += current;
  return shiftLeftOrRightThenSumOrXor(acc, [''+-a'', ''^+6''])
 }, tkkIndex);

 // STEP 3: apply 3 rounds of shift+add/xor and XOR with they TKK key
 var encondingRound2 = shiftLeftOrRightThenSumOrXor(encondingRound1, [''+-3'', ''^+b'', ''+-f'']) ^ tkkKey;

 // STEP 4: Normalize to 2s complement & format
 var normalizedResult = normalizeHash(encondingRound2);

 return normalizedResult.toString() + "." + (normalizedResult ^ tkkIndex)
}

// usage example:
var tk = calcHash(''hola'', ''409837.2120040981'');
console.log(''tk='' + tk);
 // OUTPUT: ''tk=70528.480109''