batches

Approve the plan and translate

Spends credits: the plan's measured word count at the chosen quality (standard: 1 word = 1 credit; lite: a third, rounded up) is reserved and settled at completion. Returns the initial progress with estimated_seconds_remaining — poll the translation with GET from here.

POST/v1/batches/{batch_id}/approve

Request

curl --request POST \
  --url 'https://api.ai-glot.com/v1/batches/<batch_id>/approve' \
  --header 'Authorization: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '{
  "quality": "standard",
  "custom_instructions": "<string>"
}'

import json
import requests

url = "https://api.ai-glot.com/v1/batches/<batch_id>/approve"
headers = {
  "Authorization": "<api-key>",
  "Content-Type": "application/json"
}
payload = json.loads("{\"quality\":\"standard\",\"custom_instructions\":\"<string>\"}")

response = requests.request("POST", url, headers=headers, json=payload)
print(response.json())

const response = await fetch("https://api.ai-glot.com/v1/batches/<batch_id>/approve", {
  method: "POST",
  headers: {
    "Authorization": "<api-key>",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "quality": "standard",
    "custom_instructions": "<string>"
  }),
});

const data = await response.json();
console.log(data);

<?php
$client = curl_init();

curl_setopt($client, CURLOPT_URL, "https://api.ai-glot.com/v1/batches/<batch_id>/approve");
curl_setopt($client, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($client, CURLOPT_HTTPHEADER, [
    "Authorization: <api-key>",
    "Content-Type: application/json",
]);
curl_setopt($client, CURLOPT_POSTFIELDS, "{\"quality\":\"standard\",\"custom_instructions\":\"<string>\"}");
curl_setopt($client, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($client);
curl_close($client);
echo $response;

package main

import (
  "bytes"
  "fmt"
  "io"
  "net/http"
)

func main() {
  req, _ := http.NewRequest("POST", "https://api.ai-glot.com/v1/batches/<batch_id>/approve", bytes.NewBuffer([]byte("{\"quality\":\"standard\",\"custom_instructions\":\"<string>\"}")))
  req.Header.Set("Authorization", "<api-key>")
  req.Header.Set("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  data, _ := io.ReadAll(res.Body)
  fmt.Println(string(data))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

var request = HttpRequest.newBuilder(URI.create("https://api.ai-glot.com/v1/batches/<batch_id>/approve"))
    .header("Authorization", "<api-key>")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"quality\":\"standard\",\"custom_instructions\":\"<string>\"}"))
    .build();

var response = HttpClient.newHttpClient().send(
    request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

require 'net/http'
require 'json'

uri = URI("https://api.ai-glot.com/v1/batches/<batch_id>/approve")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "<api-key>"
request["Content-Type"] = "application/json"
request.body = "{\"quality\":\"standard\",\"custom_instructions\":\"<string>\"}"

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

puts response.body

application/json

{
  "data": {
    "id": "<string>",
    "status": "<string>",
    "credits_charged": 123,
    "word_count": 123,
    "progress": {
      "percent": 123.45,
      "estimated_seconds_remaining": 123
    }
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

{
  "error": {
    "type": "<string>",
    "code": "<string>",
    "message": "<string>",
    "param": "<string>",
    "docs_url": "<string>"
  },
  "request_id": "<string>"
}

Requires batches:create. This is the call that spends credits. Everything before it (creating, planning, refining) is free.

What it costs

The plan’s measured word count is reserved at the quality you choose, then settled against actual consumption when the translation completes.

Quality	Cost	Availability
`standard`	1 credit per word	Every plan
`lite`	A third of the words, rounded up	Paid plans

Because the count is measured from the file rather than estimated, the reservation is the number you saw in the plan response. If the balance cannot cover it, the call fails with insufficient_credits and nothing is reserved.

Then poll

The response returns the initial progress, including estimated_seconds_remaining. From there, poll GET /v1/batches/{batch_id} rather than calling approve again. A second approval on a running translation fails with batch_not_awaiting_approval.

custom_instructions applies guidance to this batch only, on top of any workspace glossary. It does not change the plan, so it cannot change what gets translated, only how.

Response

application/json

Approve the plan and start translating

dataobjectrequired

Show child attributes

idstringrequired

statusstringrequired

credits_chargedintegerrequired

word_countintegerrequired

progressobjectrequired

request_idstringrequired

curl --request POST \ --url 'https://api.ai-glot.com/v1/batches/<batch_id>/approve' \ --header 'Authorization: <api-key>' \ --header 'Content-Type: application/json' \ --data '{ "quality": "standard", "custom_instructions": "<string>" }'

{ "data": { "id": "<string>", "status": "<string>", "credits_charged": 123, "word_count": 123, "progress": { "percent": 123.45, "estimated_seconds_remaining": 123 } }, "request_id": "<string>" }

Approve the plan and translate

What it costs

Then poll

Response

Use these docs with your AI tools

Query these docs via MCP

Query these docs over HTTP

Read these docs as Markdown