Best Translation API
for Ruby and Rails

Ruby developers rarely need a heavy client library for a single POST request. Here is the same translation, "Hello world" into Dutch, written three ways.

Google Translate (google-cloud-translate gem):

require "google/cloud/translate/v2"

translate = Google::Cloud::Translate::V2.new(
  project_id: "your-gcp-project",
  credentials: "config/service-account.json"
)

translation = translate.translate("Hello world", to: "nl")
puts translation.text
# => "Hallo wereld"

DeepL (deepl-rb, community gem):

require "deepl"

DeepL.configure { |config| config.auth_key = ENV.fetch("DEEPL_AUTH_KEY") }

translation = DeepL.translate("Hello world", nil, "NL")
puts translation.text

Langbly (standard library, no gem):

require "net/http"
require "json"
require "uri"

uri = URI("https://api.langbly.com/language/translate/v2")

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{ENV.fetch('LANGBLY_API_KEY')}"
request["Content-Type"]  = "application/json"
request.body = JSON.generate(q: "Hello world", target: "nl")

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

payload = JSON.parse(response.body)
puts payload.dig("data", "translations", 0, "translatedText")
# => "Hallo wereld"

The response body is the familiar Google Translate v2 envelope:

{"data":{"translations":[{"translatedText":"Hallo wereld","detectedSourceLanguage":"en"}]}}

Two things worth calling out. First, there is no official Langbly gem. Official SDKs exist for Python, JavaScript/TypeScript, and PHP, and Ruby is covered by plain HTTP because the API is small enough that a gem would only get in the way. Second, Langbly is a drop-in replacement for the Google Translate v2 API. Request shape, field names, and response shape are the same, so any Google v2 style code you already have keeps working once you point it at https://api.langbly.com/language/translate/v2 and swap the auth header for Authorization: Bearer YOUR_API_KEY.

Optional body fields: source to skip detection, and format, which is either "text" or "html". Use "html" when you are translating rich text and want tags left intact.

In a Rails app you want one place that knows about the API, reads the key from credentials, handles 429s, and returns a plain String. A small PORO does the job. Faraday is already in most Rails dependency trees through other gems, but Net::HTTP works just as well if you would rather not add one.

# app/services/translator.rb
class Translator
  ENDPOINT = "https://api.langbly.com/language/translate/v2".freeze

  class Error < StandardError; end
  class RateLimited < Error; end

  def initialize(api_key: nil)
    @api_key = api_key ||
      Rails.application.credentials.dig(:langbly, :api_key) ||
      ENV.fetch("LANGBLY_API_KEY")
  end

  # text can be a String or an Array of Strings.
  # Returns a String or an Array, matching what you passed in.
  def call(text, target:, source: nil, format: "text")
    body = { q: text, target: target, format: format }
    body[:source] = source if source

    response = connection.post(ENDPOINT, body)

    case response.status
    when 200
      extract(response.body, text)
    when 429
      raise RateLimited, "Rate limited, retry after #{response.headers['retry-after']}s"
    else
      raise Error, "Translation failed (#{response.status}): #{response.body}"
    end
  end

  private

  def connection
    @connection ||= Faraday.new do |f|
      f.request :json
      f.response :json
      f.options.timeout = 20
      f.options.open_timeout = 5
      f.headers["Authorization"] = "Bearer #{@api_key}"
    end
  end

  def extract(body, original)
    texts = Array(body.dig("data", "translations")).map { |t| t["translatedText"] }
    original.is_a?(Array) ? texts : texts.first
  end
end

Store the key with rails credentials:edit:

langbly:
  api_key: your_api_key_here

Then call it from anywhere:

Translator.new.call("Hello world", target: "nl")
# => "Hallo wereld"

Translator.new.call(["Hello", "Goodbye"], target: "de")
# => ["Hallo", "Auf Wiedersehen"]

User facing translation should never block a request. Push it into ActiveJob and let the queue absorb rate limits:

# app/jobs/translate_post_job.rb
class TranslatePostJob < ApplicationJob
  queue_as :translations

  retry_on Translator::RateLimited, wait: :polynomially_longer, attempts: 5
  discard_on ActiveRecord::RecordNotFound

  def perform(post_id, locale)
    post = Post.find(post_id)

    translated = Translator.new.call(post.body, target: locale, format: "html")

    translation = post.translations.find_or_initialize_by(locale: locale)
    translation.update!(body: translated, source_checksum: Digest::SHA256.hexdigest(post.body))
  end
end

Storing a checksum of the source text means you can skip re-translating rows that have not changed, which is the single biggest lever on your bill once a content catalogue gets large.

Compare that setup to Google. There you need a Google Cloud project, an enabled API, a service account, a downloaded JSON key, and a way to get that file onto every dyno or container without committing it. On Heroku or a container platform that alone is an afternoon. A bearer token in Rails credentials is one line.

Most Rails apps carry a config/locales/en.yml that has grown for years. Translating it by hand is miserable, and it goes stale the moment someone adds a key. A rake task that walks the YAML tree and writes sibling locale files solves it in one command.

# lib/tasks/i18n.rake
namespace :i18n do
  desc "Translate config/locales/en.yml into other locales: rake 'i18n:translate[nl,de,fr]'"
  task :translate, [:locales] => :environment do |_task, args|
    translator = Translator.new
    source = YAML.load_file(Rails.root.join("config/locales/en.yml")).fetch("en")

    walk = lambda do |node, locale|
      case node
      when Hash   then node.transform_values { |value| walk.call(value, locale) }
      when Array  then node.map { |value| walk.call(value, locale) }
      when String then translator.call(node, target: locale)
      else node
      end
    end

    locales = args[:locales].to_s.split(",").map(&:strip).reject(&:empty?)
    abort "Usage: rake 'i18n:translate[nl,de,fr]'" if locales.empty?

    locales.each do |locale|
      path = Rails.root.join("config/locales/#{locale}.yml")
      File.write(path, { locale => walk.call(source, locale) }.to_yaml(line_width: -1))
      puts "Wrote #{path}"
    end
  end
end

Run it with rake 'i18n:translate[nl,de,fr]' and commit the diff like any other change. Two practical notes. Keep line_width: -1 so Psych does not wrap long strings into a format that is painful to review. And do a spot check on keys that contain %{name} interpolation or pluralization subtrees before you ship, because those are where any translation service is most likely to surprise you.

If your locale file is big, batch it. Passing an array of strings in a single q field is far cheaper in wall clock time than one request per key, and the service object above already accepts an array.

Volume is where the price difference stops being academic. Google and Langbly both include the first 500,000 characters each month. At 5M total characters, their current standard text totals are $90 and $22.50; at 100M they are $1,990 and $497.50. DeepL requires its live Growth subscription and overage for a fair comparison.

• Best Translation API for Python
• Best Translation API for JavaScript & Node.js
• Google Translate API vs Langbly
• Langbly quickstart guide
• Try Langbly. 500K characters/month included