Translate

1. Home
2. Translate /

---

Translate

Translates some Text to any Language

POST /api/ai/translate

https://api.cookie-api.com/api/ai/translate

Authentication Learn how to get your API Key and use it in your requests!

Parameters

URL Parameters

Parameter	Type	Required	Description
text	string	Yes	The text that should be translated
language	string	Yes	The language the text should be translated to
source_language	string	No	For more accurate translations, specify the source language of the text

Request examples

cURL

curl --location --request POST 'https://api.cookie-api.com/api/translate?language=german&text=Hello%20how%20are%20you%3F' \
--header 'Authorization: API_Key'

Python

import requests

url = 'https://api.cookie-api.com/api/translate'
headers = {
    'Authorization': 'API_Key'
}
params = {
    'language': 'german',
    'text': 'Hello how are you?'
}

response = requests.post(url, headers=headers, params=params)
print(response.json())

JavaScript

const fetch = require('node-fetch');

const url = 'https://api.cookie-api.com/api/translate';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const params = new URLSearchParams({
    language: 'german',
    text: 'Hello how are you?'
});

fetch(`${url}?${params}`, {
    method: 'POST',
    headers: headers
})
.then(res => res.json())
.then(data => console.log(data))
.catch(err => console.error(err));

Go

package main

import (
    "bytes"
    "fmt"
    "log"
    "net/http"
    "net/url"
)

func main() {
    apiUrl := "https://api.cookie-api.com/api/translate"
    params := url.Values{}
    params.Add("language", "german")
    params.Add("text", "Hello how are you?")

    req, err := http.NewRequest("POST", apiUrl+"?"+params.Encode(), nil)
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("Authorization", "API_Key")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    var res map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
        log.Fatal(err)
    }

    fmt.Println(res)
}

Node.js

const https = require('https');

const params = new URLSearchParams({
    language: 'german',
    text: 'Hello how are you?'
});

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/translate?' + params.toString(),
    method: 'POST',
    headers: {
        'Authorization': 'API_Key',
        'Content-Type': 'application/json'
    }
};

const req = https.request(options, res => {
    let body = '';

    res.on('data', chunk => {
        body += chunk;
    });

    res.on('end', () => {
        console.log(JSON.parse(body));
    });
});

req.on('error', error => {
    console.error(error);
});

req.end();

Ruby

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse('https://api.cookie-api.com/api/translate')

params = {
  language: 'german',
  text: 'Hello how are you?'
}

uri.query = URI.encode_www_form(params)

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'API_Key'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.body

Rust

use reqwest::blocking::Client;
use reqwest::header::{HeaderMap, CONTENT_TYPE};
use std::collections::HashMap;

fn main() {
    let url = "https://api.cookie-api.com/api/translate";
    let client = Client::new();

    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());
    headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());

    let mut params = HashMap::new();
    params.insert("language", "german");
    params.insert("text", "Hello how are you?");

    let res = client
        .post(url)
        .headers(headers)
        .form(&params)
        .send()
        .unwrap();

    println!("{}", res.text().unwrap());
}

Responses

200

{
    "response": "Hallo, wie geht es Ihnen?",
    "success": true
}