Flask API Tutorials

How to Create a Translation App (Google Translate API with Python & Flask)

Today we’re going to take a look at how you can use RapidAPI to get started on a project fast. With very little time invested up front, there is the potential to add a real wow factor to your latest text-based project. In particular, we’re going to look at setting up a text translation microservice that we can use to build in text translation into any app.

First, let’s take stock of what we’ll need for our text translation microservice:

  1. A Free RapidAPI Account
  2. A clean virtual environment — we’ll use Pipenv
  3. Flask (the Python web framework)

With just the above, we can have this thing running like a top in no time.

Connect to the Google Translate API

Google Translate API Overview

The Google TranslateAPI on RapidAPI is easy to navigate. There are only two endpoints exposed, and both take HTTP POST requests. This makes it an easy API to use, even for beginners.

API Endpoints:

  • Detect:
    • Request Type: POST
    • Params (1):
      • :: Param Type: String
      • :: Param Value: Text from which language will be detected.
  • Translate:
    • Request Type: POST
    • Required Params (2):
      • :: Param Type: String
      • :: Param Value: Text to be translated.
      • :: Param Type: String
      • :: Param Value: Target Language.

The inherent simplicity that comes with having only the two endpoints we need (and nothing more) is helpful for this tutorial.

Related: Google Translate API Alternatives

Now, let’s create a root directory for our new project. From the terminal, simply run:
`mkdir translation-service`

Then, to enter that directory, run:
‘cd translation-service`

Finally, create and name the one file we will need to write:
`touch translation_service.py`

Now, let’s get our environment set up. Install Pipenv if you don’t already have it.
Then run: `pipenv --three` to create a Python3 vm, and `pipenv shell` to enter it.

NOTE: you are now in a Python3 virtual environment of the same name as the directory you were in when you ran the command.

Finally, let’s install Flask. Run: `pip install Flask`

And we’re off to the races! Let’s take a look at some code!

from flask import Flask, request
import requests
 
app = Flask(__name__)
 
DETECT_BASE_URL = 'https://google-translate1.p.rapidapi.com/language/translate/v2/detect'
TRANSLATE_BASE_URL = 'https://google-translate1.p.rapidapi.com/language/translate/v2'
HEADERS = {
   'x-rapidapi-host': "google-translate1.p.rapidapi.com",
   'x-rapidapi-key': "YOUR-VERY-OWN-RAPID-API-KEY-GOES-HERE",
   'content-type': "application/x-www-form-urlencoded"
   }

This is really where the power of this app comes in. By isolating all logic that has to do with interacting with the Google Translate API in this app, we free ourselves to interact with it in any other application (or extension of this application) we create. This process is easy because we’re already signed in, so to speak — we have our password and the rest of our particulars secure and ready to get us access at a moment’s notice.

When it isn’t being called upon, this service will just listen and wait for another server to contact it.

 
@app.route('/')
def health_check():
   return 'Translation Service is up.'
 

It’s handy to give yourself a quick heads up that things are good. We’re returning a message to what is generally referred to as the “index view” or “page”, which is denoted by the route ’/’, because it is generally the first to load.

 
@app.route('/detect', methods=['POST'])
def detect():
   # parse args
   text = request.form.get('text')
 
   # url encode text
   long_list_of_words = text.split(' ')
   url_encoded_text = f"q={'%20'.join(long_list_of_words)}"
 
   payload = url_encoded_text
 
   # make the request
   r = requests.post(DETECT_BASE_URL, data=payload, headers=HEADERS)
  
   return r.json()

Above, we’ve defined our second route. This one has additional logic. First, we parse our args from the global `request` object that is available in the body of our functions with route decorators once we import it (as we did above). Depending on your use case, you may choose to pass your request as JSON, rather than form data. If so, simply replace `form` with `json`, as so:

` text  =  request.json.get(‘text’)`

It worth noting that we have to do a bit of text formatting here. Again, this is a nice reason to build this as a microservice. We only have to do this once, and then it’s done any time we want to use the Google Translate API.

Now, let’s create our translate route in much the same way. In this case, though, we have a second mandatory parameter. We’ll just pull it from the request like we did with the text.

 
@app.route('/translate', methods=['POST'])
def translate():
   # parse args
   text = request.form.get('text')
   target = request.form.get('target')
 
   # url encode text
   long_list_of_words = text.split(' ')
   url_encoded_text = f"q={'%20'.join(long_list_of_words)}&target={target}"
 
   payload = url_encoded_text
 
   r = requests.post(TRANSLATE_BASE_URL, data=payload, headers=HEADERS)
  
   return r.json()
 
 
if __name__ == '__main__':
   app.run(debug=True)

Connect to the Google Translate API

The Finished Application:

To run this locally, copy the code below, and paste it into a file called translation_service.py inside of your virtual env. Your file tree looks like this:

To start the server, simply run: `python translation_service.py`

If all has gone well, you’ll see something very much like the above. Note the virtual environment — denoted by the parens to the far left of the cursor’s line. And within that env, you have a brand new Flask app running in debug mode, which means that it will restart the server every time it detects changes to the code, which is infinitely more convenient than manually restarting every time. Take my word for it.

You will then have a server listening at `http://127.0.0.1:5000` for three different routes:

  1. ‘/’ — our health check
    1. Basically, go to the address above in your browser. If you see some text, everything is working. Pro tip: we didn’t define the route method explicitly, but it defaults to a GET request, which is what the browser sends by default. Default win.
  2. ‘/detect’the, ahem, detect route
    1. This guy will be waiting for a POST request that contains the parameter `text`, a string to be detected.
    2. Ex: {“text”: “Words that you want the thing to do stuff with”}
  3. ‘/translate’yep
    1. This one will be waiting for a POST request that contains both `text`, a string to be translated AND `target`, also a string, and the abbreviation for the target language. For example, ‘es’ is the abbreviation for the target language Spanish.
    2. Ex: {“text”: “You guessed it. The words…”, “target”: “es”}

translation_service.py

from flask import Flask, request
import requests
 
app = Flask(__name__)
 
DETECT_BASE_URL = 'https://google-translate1.p.rapidapi.com/language/translate/v2/detect'
TRANSLATE_BASE_URL = 'https://google-translate1.p.rapidapi.com/language/translate/v2'
HEADERS = {
   'x-rapidapi-host': "google-translate1.p.rapidapi.com",
   'x-rapidapi-key': "YOUR-VERY-OWN-RAPID-API-KEY-GOES-HERE",
   'content-type': "application/x-www-form-urlencoded"
   }
 
@app.route('/')
def health_check():
   return 'Translation Service is up.'
 
@app.route('/detect', methods=['POST'])
def detect():
   # parse args
   text = request.form.get('text')
 
   # url encode text
   long_list_of_words = text.split(' ')
   url_encoded_text = f"q={'%20'.join(long_list_of_words)}"
 
   payload = url_encoded_text
 
   # make the request
   r = requests.post(DETECT_BASE_URL, data=payload, headers=HEADERS)
  
   return r.json()
 
 
@app.route('/translate', methods=['POST'])
def translate():
   # parse args
   text = request.form.get('text')
   target = request.form.get('target')
 
   # url encode text
   long_list_of_words = text.split(' ')
   url_encoded_text = f"q={'%20'.join(long_list_of_words)}&target={target}"
    payload = url_encoded_text
 
   r = requests.post(TRANSLATE_BASE_URL, data=payload, headers=HEADERS)
  
   return r.json()
 
 
if __name__ == '__main__':
   app.run(debug=True)

Connect to the Google Translate API

TL;DR

We set up our environment with Pipev, because it saves us any dependency-related frustration. It’s a real drag when your code won’t run, but it has nothing to do with the code you’ve written.

This is useful, because it securely houses our credentials, and it keeps the logic that only this thing needs out of the way. And it was all made possible by RapidAPI, Google Translate, and Flask.

Related: Google Translate API Tutorial with JavaScript

Related Resources

5/5 - (1 vote)
Share
Published by

Recent Posts

Rapid Enterprise API Hub Levels Up Custom Branding, Monetization, and Management in February Release

The RapidAPI team is excited to announce the February 2024 update (version 2024.2) for the…

2 days ago

Supercharge Your Enterprise Hub with January’s Release: Search Insights, Login Flexibility, and More!

This January's release brings exciting features and improvements designed to empower you and your developers.…

2 months ago

Enhanced Functionality and Improved User Experience with the Rapid API Enterprise Hub November 2023 Release

Rapid API is committed to providing its users with the best possible experience, and the…

4 months ago

The Power of Supporting Multiple API Gateways in an API Marketplace Platform

In today's fast-paced digital world, APIs (Application Programming Interfaces) have become the backbone of modern…

5 months ago

Rapid API Enterprise Hub – September 2023 Release Notes

We're excited to announce the September 2023 Release Notes for the RapidAPI Enterprise Hub! Our…

6 months ago

Rapid API Enterprise Hub – August 2023 Release Notes

We hope you enjoyed your summer!  We're excited to announce the Rapid API Enterprise Hub…

7 months ago