• Skip to primary navigation
  • Skip to main content
  • Skip to primary sidebar
  • Skip to footer

Rapid Blog

  • Enterprise
  • API Hub
  • Add Your API
  • About
  • Docs
    • API Glossary
  • Blog
    • What is an API?
    • REST API Tutorials
    • Most Popular APIs
    • Write for Us
  • Sign Up
    • Log In
Blog » API Tutorials » Amazon Alexa Tutorial: Build Google Translate Skill

Amazon Alexa Tutorial: Build Google Translate Skill

By Lindsey // July 29, 2020

Table of Contents

    • This article will go through…
    • The result
    • What you’ll need:
  • Step 0: Clone our Repo on GitHub
  • Step 1: Define the Skill’s Elements
    • 1a: Create the skill
    • 1b. Define the intent
    • 1c. Define the slots and slot types
    • 1d. Define the utterances
  • Step 2: Connect to Amazon Lambda
    • 2a. Create or login to AWS account
    • 2b. Add an Alexa Skills Kit trigger
    • 2c. Install the Directory 01 to NPM
    • 2d. Zip and upload the Directory 01 file to AWS
    • 2e. Fill in the Lambda Function and Role section
    • 2f. Connect Lambda to your Alexa skill
    • 2g. Test your skill
  • Step 3: Add the Translation Functionality with RapidAPI
    • 3a. Connect to the Google Translate API with RapidAPI
    • 3b. Install RapidAPI into Directory 01
    • 3c. Incorporate Google Translate snippet
    • 3d. Compare your code to Directory 02
    • 3e. Compress the files and upload them to the Amazon Lambda function
  • Success!

We just got our hands on the Amazon Echo – a new Alexa-powered voice assistant device from Amazon. Let’s see what we can do with it.

The Amazon Alexa platform is based on skills. Amazon Alexa Skills are the equivalent of apps for this voice-powered platform. While there are countless skills we could potentially build for Alexa, today we’ll focus on letting users translate words using the Google Translate API.

We’ll be working from this GitHub tutorial. Directory 01 is for you to edit and work in. If you get stuck, we’ve also created Directory o2 as a reference with the completed code.

This article will go through…

  1. Adding the translation skill to Amazon Alexa
  2. Creating the skill’s backend in AWS Lambda
  3. Connecting Alexa to the Google Translate API using RapidAPI

The result

The end result will look something like this…

https://rapidapi.com/blog/wp-content/uploads/2016/10/Alexa-Tutorial-Ad.mp4

What you’ll need:

  • Amazon Echo device
  • Amazon account

On that note, let the hacking begin!

Step 0: Clone our Repo on GitHub

Lucky for you, the first step is the easiest! Clone this repo on GitHub by pasting the following in your terminal: 

git clone https://github.com/RapidSoftwareSolutions/Alexa_Google_Translate_Skill.git

Step 1: Define the Skill’s Elements

1a: Create the skill

Our new Skill will be a voice-powered tool for translating text. This skill means that the user will be able to ask Alexa to translate words or phrases from over 90 languages. For example, the user might say, Alexa translate “butterfly” to German and Alexa will respond by saying, The word for “butterfly” in German is Schmetterling. Pretty cool, right?

To get started, we’ll head over to the Amazon Developer Portal and login. If you don’t yet have a developer account, the site will ask you to add some information to your profile (ex. company name), accept a registration agreement, and declare any financial purpose your app may serve (ex. if you plan on monetizing your app).

Pro Tip: the account you use to log in here should be the same account your device is configured with. That way, any skills that you build will sync to your Echo automatically.

Once logged in, head over to the Alexa tab and click “Get Started” under the Alexa Skills Kit block.  Next, you’ll click the “Add a New Skill” button near the header of the page.

The first step in creating a new skill is filling out some basic information in the Skill Information tab. Set your skill’s language to English. The skill’s name is what shows up in the developer dashboard, and the invocation name is what you will actually say out loud when you ask Alexa to call the skill. For ease of use, set your skill name and invocation name “Translate.”

Here’s what those first steps look like.

1b. Define the intent

The next step will be to define the skill’s intent schema on the Interaction Model tab. Every skill in the Alexa platform is made of intents. An intent is basically an action that the user can perform with the skill. Our skill will have one intent – Translate. Thus, our definition will look like this:

{
    "intents": [
        {
            "intent" : "Translate",
            "slots": [
                {
                    "name" : "Source",
                    "type" : "SOURCE"
                },
                {
                    "name" : "Language",
                    "type" : "LANGUAGES_LIST"
                }
            ]
        },
      	{ 
          "intent": "LaunchRequest" 
        }
    ]
}

Copy and paste this code snippet into the intent schema area.

1c. Define the slots and slot types

As you can see in the intent schema code, the intent has two slots. A slot is like a placeholder for a piece of data that the user can supply to the intent. The slots in our case will be:

  • Source: the original word to be translated.
  • Language: the language we want to translate it to.

Each of the slots has slot name (“Source” and “Language”) and a slot type (SOURCE and LANGUAGES_LIST). A slot type defines what information can go into the slot. You define slot types by providing examples of words that can go in the slot.

For us, the slot types will look like this:


As you can see, the slot type values for SOURCE are sample words that you may ask Alexa to translate (ex. airplane, butterfly, book etc.). The values for LANGUAGES_LIST are the actual languages you’d like the phrase translated into (ex. German, Dutch, Spanish).

1d. Define the utterances

The last part of the definition is the utterances. An utterance is an example phrase that the user can say to invoke this specific intent. In other words, utterances are the data Alexa uses to recognize commands. Our utterances will be pretty basic:

Translate translates {Source} to {Language} 
Translate ask Translate how to say {Source} in {Language} 
Translate ask Translate to translate {Source} to {Language} 
Translate get translation for {Source} in {Language} 
Translate what is {Source} in {Language}

We’ll copy/paste these utterances into “Sample Utterances,” the last section of the interaction model tab.

screen-shot-2017-01-25-at-10-48-50-am

Notice that our slots are represented in curly braces {}. These braces allow Alexa to separate variables from static text when the user says a command. The more utterances you define, the better Alexa will be at querying your data. Now that we have the intent, its slots types, and its utterances set, we can move on to configuring our Amazon skill. This step will connect our new skill to a ‘backend’ that will actually perform the translation.

Step 2: Connect to Amazon Lambda

In the Configuration tab, define your Service Endpoint to use AWS Lambda. AWS Lambda is a service that lets you write code that runs whenever an event (ex. an HTTP request or an AWS Alexa command) occurs. We will use Lambda in this tutorial so that we will not have to worry about setting up servers, load balancer etc.

2a. Create or login to AWS account

Head over to AWS in a new tab and sign in to your console. The login should be the same as your Amazon login from creating a skill. You may have to re-enter some data if you do not already have an AWS account. It will ask you for credit card information, but don’t worry. You won’t be charged unless you go over one million free requests a month. Read more information on AWS pricing if you have questions.

2b. Add an Alexa Skills Kit trigger

In the console, type “Lambda” in the search bar to be directed to the Lambda service. Next, create a new blank Lambda function and click “Blank Function.” Add the trigger “Alexa Skills Kit” and click next. Here’s what that process looks like:

aws-lambda-gif

You should now be on the “Configure function” tab. Give your new Lambda function the name “ALEXA-TRANSLATE-SKILL”–the description is optional.  Since our code is in Node.js, keep the runtime at Node.js 4.3.  Next, set the  “Code entry type” to “Upload a .ZIP file,” as seen below.

.

2c. Install the Directory 01 to NPM

Before uploading the zip file, you’ll need to install all of the dependencies for this particular directory by doing the following:

  • Go to the Terminal and navigate to the directory 01
  • Run “npm install”

This step will allow Alexa to recognize the alexa-sdk dependency.

2d. Zip and upload the Directory 01 file to AWS

The code that we zip and upload here will be the code that runs every time that we call an intent on Echo. We will upload a compressed file from directory 01 in our GitHub repo.  All this directory 01 code will do is reply to the request by saying something like Translating **butterfly** to German*. The reply will let us see that all the data is passed correctly. Note: directory 01 will not actually translate the response yet.  

If you haven’t cloned this repository, go ahead and clone it now.

  • Head over to the directory 01, compress its files and upload the directory to the Lambda page.
  • Make sure to compress the files and the node_modules folder and not the directory 01 folder overall, otherwise the skill will not work.

Upload this zip file to the function package button. You don’t have to enable encryption helpers nor add any environment variables for this project.

2e. Fill in the Lambda Function and Role section

After uploading the directory 01 zip file, move on to the Lambda function and role section. For the role, just choose the “Create a custom role” option and when sent to another page, choose “lambda_basic_execution” as the IAM Role. You won’t need to create a new Role policy.

After you fill in your information, the Lambda function code section should look like this.

screen-shot-2017-01-25-at-11-39-30-am

Since this project doesn’t require any advanced settings, go ahead and click “Next,” then click “Create function.”

2f. Connect Lambda to your Alexa skill

To connect the Alexa skill to the Lambda function, simply copy the ARN function identifier of the Lambda function and paste it in the Configuration tab on the Amazon skill settings page (as shown below).

We have now gone through all the steps necessary to create a basic Alexa skill! Woohoo!

2g. Test your skill

In the Alexa developer portal, you can say/type inputs and see this output:

If you have an Amazon Alexa compatible device like the Amazon Echo, you can try the skill on it. If you used the same account while configuring and creating the skill, the Translate skill will show up automatically under Your skills on the Alexa app.

If all goes well, you should get a result where the Alexa skill repeats exactly what you are saying (ex. “Translate butterfly to German”) versus an actual translation.

Step 3: Add the Translation Functionality with RapidAPI

While this is all very exciting (we have an Alexa skill now!), our skill doesn’t actually translate anything. Yet!

The next (and last step) will be to add the actual translation functionality. We’ll use RapidAPI to connect to the Google Translate API. Here’s how it works:

3a. Connect to the Google Translate API with RapidAPI

We’re using RapidAPI for two reasons: it lets you test and call APIs in the browser and you can export the code snippet that calls the API directly into the project.

Head over to RapidAPI’s Google Translate package. You’ll notice that this API requires an API key. To get the Google Translate API key, do the following:

  1. Go to the projects page
  2. Select or create a Cloud Platform Console project.

screen-shot-2017-01-25-at-4-33-00-pm3. Enable billing for your project. Don’t worry–you’ll get a thirty day free trial and Google will not automatically charge you after the trial ends.
4. Click “Use Google APIs” and search for the Google Translate API.
5. Click the “Enable” button on the Google Translate API page.
6. Navigate to the credentials tab on the left of the screen to get an API key (select API key when prompted). Note: If you have an existing API key, you can use that key.

Now, you can test the call with RapidAPI. Go back to the Google Translate package page, fill in your API key and parameters for an API call to test it out for yourself.

Nifty, am I right? Feel free to test out multiple calls/languages.

3b. Install RapidAPI into Directory 01

In order to export the code snippet for the API call, you’ll need to get a RapidAPI account. You can sign in with GitHub, Facebook, Google or a custom email/password.

Once you sign up for RapidAPI, you will be prompted to create a new project. Go ahead and name it RapidAPI Translate. The next window will prompt you to pick a language. Leave the language setting at Node.js and copy the two lines under “Require SDK.” They should look something like this:

 

const RapidAPI = new require('rapidapi-connect');
const rapid = new RapidAPI('PROJECT-NAME', 'RAPIDAPI APP ID');

Open the index.js file. This is the code run by the Lambda function to handle requests sent to the skill. At the top of the file, add the copied lines to connect to RapidAPI.

Once you have the RapidAPI credentials in index.js file, navigate to the 01 directory and install the RapidAPI SDK by running the following line in the command line.

npm install rapidapi-connect --save

3c. Incorporate Google Translate snippet

We’re on the home stretch! Now, we’ll copy and paste the following code snippets into index.js.

First, put this language code object at the top of the Translate function. Your code should look like this:

'Translate': function() {
    const langCodes = {
        "German" : "de",
        "Dutch" : "nl",
        "English" : "en",
        "French" : "fr",
        "Italian" : "it",
        "Polish" : "pl",
        "Russian" : "ru",
        "Spanish" : "es"
    };

 

Next, you’ll need to add a variable that can access the language codes from the above object. Add this line directly beneath the object:

var langCode = langCodes[language];

Next, grab the RapidAPI call and put it at the very bottom of the function.

rapid.call('GoogleTranslate', 'translateAutomatic', {
       'apiKey': 'Your Google API key',
        'string': word,
        'targetLanguage': langCode

    }).on('success', (payload) => {
      this.emit(":tell", `${word} is ${payload} in ${language}`);
    }).on('error', (payload) => {
      this.emit(":tell", "Sorry, translation was unsuccessful..");
    });

So, what did we just do? Every time the Lambda function gets a request, it call the exports.handler function (last function in the code). If the type of the request is LaunchRequest (meaning the user is trying to get the skill to perform an intent, “ask Translate”), the request will call the “LaunchRequest” function. If the name of the intent is Translate (we defined this as the only valid intent in our skill), the request will call the “Translate” function. That’s the function we’ll use to perform the translation.

3d. Compare your code to Directory 02

If you followed the directions above, you should have a fully working translation function! If you’re running into trouble, compare your directory to the reference directory 02.

3e. Compress the files and upload them to the Amazon Lambda function

This is the final step! Moment of truth. Compress all the files in the directory 01 (remember to compress the individual files vs. the directory 01 folder). Next, go back to Amazon Lambda and upload your compressed file under “Lambda Function Code.”

screen-shot-2017-01-25-at-11-39-30-am

When you test the function this time, it should have full translation capabilities. No more repeating what you’ve said, Alexa should now be able to translate your phrases.

Success!

Congratulations–you’ve just built an Alexa skill! While this project used the Google Translate API, you can also build more skills with different APIs and a similar process. Here are some other Amazon Alexa skill ideas to keep you coding:

  • Ask Alexa to check flight status with the Skyscanner Flight API 
  • Prompt Alexa to send text messages with Twilio’s API (here’s a Twilio tutorial)
  • Have Alexa check you in with the Foursquare API

Comment with links to any of your projects and happy hacking!

 

 

 

4.9/5 - (189 votes)
7 Ways to Celebrate Ada Lovelace Day »

Related Blog Posts

How to use Google Vision API with Python
How to use Google Vision API with Python

RapidQL Tutorial: MySQL + Open Weather API + Twilio SMS API
RapidQL Tutorial: MySQL + Open Weather API + Twilio SMS API

How to Build a Custom Search Engine with the Google Search API (with Ruby)
How to Build a Custom Search Engine with the Google Search API (with Ruby)

Top 8 Best Search Engines (of 2022)
Top 8 Best Search Engines (of 2022)

How to Build an API in Python (with Django)
How to Build an API in Python (with Django)

RapidAPI for Teams [The Complete Tutorial + FAQs]
RapidAPI for Teams [The Complete Tutorial + FAQs]


Filed Under: REST API Tutorials Tagged With: alexa developer, alexa skill, amazon alexa, amazon alexa api, amazon alexa tutorial, build alexa skill, Google, google translate skill, tutorial

Lindsey

Content Marketer at RapidAPI.

Reader Interactions

Comments

  1. Rene says

    December 17, 2016 at 11:25 am

    This is exactly what I’ve been looking for to create a Translator for the German Alexa to the other languages. However, I cannot find the directories 01 and 02 you mention. Where do I get those from?

    Reply
    • David Noah says

      January 26, 2017 at 1:00 am

      Hi Rene! We’ve updated the article to be a little more thorough. You can find more instructions in the updated post and the directories here: https://github.com/RapidSoftwareSolutions/Alexa_Google_Translate_Skill

      Reply
  2. Jeff Bolton says

    March 1, 2017 at 6:33 pm

    Thanks for the great tutorial! This really helps you learn how to build some really clever skills for Alexa. My first two projects are Sleep Sounds (https://www.amazon.com/dp/B06XBXR97N) and Guard Dog (https://www.amazon.com/dp/B06XC3D4KN)

    Reply
  3. Ashish Jayan says

    August 19, 2017 at 9:32 am

    Great! this helped us with our translator application.

    Reply
  4. Kshitija Murudi says

    November 6, 2017 at 6:13 pm

    Our bot idea to use Alexa as scrum master bot integrated with JIRA

    Reply

Leave a Reply

Your email address will not be published. Required fields are marked *

Primary Sidebar

Build anything with APIs, faster.

Discover, evaluate, and integrate with any API. RapidAPI is the world’s largest API Hub with over 4 Million developers and 35,000 APIs.

Browse APIs »

Footer

  • API Guides
  • API Courses
  • API Glossary
  • API Testing
  • API Management
  • How to use an API
  • For API Providers
  • Most Popular APIs
  • For Developers
  • Free APIs List
  • Learn REST API
  • Build API’s
  • About
  • Team
  • Careers
  • Contact Us
  • Write for Us
  • API Directory
  • Press Room
  • Privacy Policy
  • Terms of Use

© 2023 RapidAPI. All rights reserved.