DEV Community: Alex Walling

Introducing RapidQL: Fetch, combine, and aggregate data from multiple APIs and databases in a single call

Alex Walling — Tue, 04 Feb 2020 16:55:59 +0000

Have you ever wanted to grab an address, lookup the 10 nearest restaurants, and provide Uber price and ETAs — all in a single API call? What about fetching a list of users from a database and simultaneously doing email validation and phone number validation?

Well now you can, with RapidQL, our recently launched open source project.

And those are just two examples of the many combinations made possible when you can query, combine, and aggregate data from multiple APIs and databases in a single API call.

// Get a list of users and fetch the weather based on the city saved on their account
rql.log(`{
    - MySQL.RQLDemo.rqlDemo.find(){
        username,
        city,
        - Http.get(
            url:"https://community-open-weather-map.p.rapidapi.com/weather",
            params: {
                "units": "imperial",
                "q" : city
            }
        ){
            - weather {
                main
            },
            - main {
                temp
            }
        }
    }

We Launched on ProductHunt! 🎉

Check us out on ProductHunt to learn more about why we launched it and how it will help simplify fetching data from multiple data sources!

Try it out

The inspiration for RapidQL is to make it easy for developers to simultaneously make requests to APIs as well as databases, defining only the fields you need returned from each and avoiding expensive additional round trips.

Queries made to databases like MySQL, PostgreSQL, and MongoDB can take advantage of aggregations like count and average. These results can be fed into the next query in the RapidQL statement.

And of course, you can also connect to more than 10,000 public APIs on RapidAPI’s Marketplace.

RapidQL itself is a JSON-like query language implemented in JavaScript. Just $ npm install rapidql to download it, then check out the documentation to see how to run your first query.

Show us what you’ve got

To celebrate the launch of RapidQL, we’ll be highlighting and sharing any projects that you build over the next few weeks! Here’s how you can join in:

Take a look at the RapidQL docs
Create an example RapidQL call on CodePen
Tweet us your best ideas, mentioning @Rapid_API and #RapidQL. Include a link to the pen and a screenshot, if possible.
We’ll retweet all of the most useful, the funniest, and the most complex queries you build!

Contributions welcome

RapidQL is open source, and we welcome all contributions to the codebase. You’re invited to support the core system (see open issues in GitHub), as well as develop integrations with more data sources and database systems (see planned integration in project board in GitHub).

Introducing RapidAPI's Student Program: RapidAPI School [Who is Eligible, How to Apply]

Alex Walling — Thu, 24 Oct 2019 21:42:37 +0000

Introducing RapidAPI School

We know just how powerful APIs are, and we want to ensure students are getting ample experience with APIs as they learn to code — that’s why we created RapidAPI School.

RapidAPI School includes a selection of free or discounted pricing plans just for students. It includes some of the most popular APIs available on the RapidAPI Marketplace like TheRundown, Zestful, and API-FOOTBALL.

You can view the current collection of APIs that have customized pricing plans for students here.

Who is Eligible for RapidAPI School?

Student Eligibility

Students who are currently enrolled at an accredited college or university can join the waitlist now. Be sure to enter your “.edu” email when you apply for the program! After your acceptance into the program, you will immediately have access to the discounted pricing plans.

API Provider Eligibility

API Providers interested in being a part of the program can get started in a few simple steps:

1: Create a Custom Pricing Plan for Students

Navigate to your RapidAPI Provider Dashboard and select the Plans & Pricing tab of your API.

Scroll to the bottom of the page to the Private Plans section and select +Add Private Plan.

Create a new subscription called “CUSTOM-STUDENT” that includes your desired pricing plan.

We recommend using a free pricing plan, with a hard rate limit on the number of requests/billing objects allowed. This will ensure students won’t incur an overage fee on accident.

2: Email Us and Say You Want to Join RapidAPI School

Send us an email at support@rapidapi.com and let us know you want to be part of the program. You can also ask us any questions you have about the program or our recommended pricing model.

Future Plans for RapidAPI School

As RapidAPI School continues to evolve, we hope to add more benefits to help support our student community. Our current plans for the program include:

1: Continuing to expand the number of APIs that have student pricing plans
2: Creating more educational resources for students and beginners
3: Posting more tutorials about how to use RapidAPI and APIs on the RapidAPI Marketplace

If you have any suggestions or ideas about other benefits you would like to see in the RapidAPI School program, please let us know at support@rapidapi.com, or send us a message on Twitter.

Creating an API with AWS Lambda and RapidAPI [Tutorial]

Alex Walling — Wed, 18 Sep 2019 22:33:32 +0000

Lately, I’ve been really interested in serverless technology and the various use cases that would be ideal to use it for. I had a project come up that was going to be a perfect use case for it, so I decided to dive right in and learn all about AWS Lambda!

Unfortunately, as I was getting started with the project, I couldn’t find very many good, up to date, resources around exactly how to create an API using AWS Lambda and API Gateway. After learning the ins and outs of how to accomplish this, I decided to write my own blog post for others who are trying to learn too.

Creating the Lambda Function

To get started, first sign in to AWS console, navigate to the Lambda page, and create a new Lambda function. For the “role” of your Lambda function, I would recommend that you create a new role from a template and use the Basic Edge Lambda Permissions template. If your API needs to write to S3 or do any more complex operations, you may need to grant your Lambda function more permissions. To learn more about Lambda function permissions, here is an interesting doc from Amazon about it.

The most basic version of an API would be an API that simply allows you to call the API and return a 200 response with a body of “hello from AWS Lambda!” To achieve this functionality with a Lambda function, here’s the code you’ll input to do this:

exports.handler = (event, context, callback) => {
    var responseBody = {
        message: "hello from AWS Lambda!"
    };
    callback(null, {
        statusCode: 200,
        headers: { "x-custom-header" : "my custom header value" },
        body: JSON.stringify(responseBody)
    });
};

This is pretty straightforward code where you’re using the callback parameter result of successful function execution. That includes a status code of 200 along with headers and a body. All of this information will be sent as a response to the code that called your API in the first place.

Parsing Params and Headers in Lambda Function

With some API requests, your API may be sent parameters or headers to change the functionality of the API. If this is the case for the API you want to build, then you’ll need to access the headers and parameters through the event parameter. You can use the following code to access these variables:

let parameter = event['queryStringParameters']['name_of_parameter'];
let header = event['headers']['name_of_header'];

// OR

let paramter2 = event.queryStringParameters.name_of_parameter_one;
let header2 = event.headers.name_of_header_one;

Creating the API Gateway

Now that you have the code for the Lambda function, you’ll need to set up the API gateway which will be what initiates the Lambda code. Go to the AWS API Gateway page and create a new API.

Once you’ve created your API, you need to start defining the spec of the API.

Proxy API vs. Defined API

There are two different ways to set up your API and each one has it’s own benefits. The two types are “proxy resource” and “fully defined API”

Proxy API

When defining a new resource, you have the option to configure it as a proxy resource.

This means that your API gateway will route every single HTTP requests that include your base URL to your Lambda integration, then your Lambda integration will do the heavy lifting to process the different types of requests.

Let’s say your base URL is https://api.myapi.com/ and then you have a GET request to https://api.myapi.com/hello and POST request https://api.myapi.com/goodbye. Although these are both different HTTP methods to different resources, when using the proxy resource integration your lambda function will be executed for both of these requests.

The upside to this setup is that you are able to route multiples paths to the same Lambda integration. If you already have a codebase setup in this way it will be an easy way to get started with serverless technology without having to completely refactor your code.

There are quite a few downsides that you should know though. Some of these downsides include:

The code for your Lambda function will be large as you’re having to handle all of the logic paths in the code.
You’re paying to run the routing in the Lambda function instead of allowing the API gateway to do it for you.
You’re not utilizing a lot of the features of the API gateway like API documentation.

Parsing different endpoints within the same Lambda function

If you do end up using the proxy integration feature, then you’ll need to do your own logic to handle each endpoint in a different manner. You will access the API request path information in a similar way to how you accessed the header and parameter information. The code to do this is:

let nameOfPath = event['path'];

// OR

let nameOfPath2 = event.path;

Should you go with this option, you will likely want to use if statements to handle each different path available and have a catch-all else statement to handle any non-defined API endpoints. This could look something like this:

exports.handler = (event, context, callback) => {
    if (event.path === '/hello') {
        callback(null, {
            statusCode: 200,
            body: JSON.stringify({message: 'hello'})
        });
    } else if (event.path === '/goodbye') {
        callback(null, {
            statusCode: 200,
            body: JSON.stringify({message: 'goodbye'})
        });
    } else {
        callback(null, {
            statusCode: 404
        }); 
    }
}

Fully Defined API

The other option is to define each of your API endpoints within the API Gateway. This will allow you to restrict the endpoints that are able to be called to only the endpoints you define. You can also have a different Lambda function for each of your endpoints.

I decided to add in a new resource called “/my-resource”

When defining the resource, you’ll just need to input the resource name and resource path. Since we’re not using the proxy resource, you can leave that unchecked.

After you’ve created your resource, you’ll want to create a method for that resource.

I’ve opted to use a GET request to my /my-resource endpoint.

When creating a new method, be sure that you use the Lambda Proxy integration. This allows the parameters and headers to be sent to your Lambda function. You’ll also want to select the Lambda function you want to activate when this endpoint is called.

Once you’ve defined all of your API endpoints, you need to deploy your API.

When Deploying, you’ll have to create a new stage to deploy your API. I’ve decided to name mine Staging because I am still in the development phase, but you can name your API stage whatever you like.

After deploying your API, you should now see an “Invoke URL” This is the URL that you will use to call your API. The format to call the API will be your Invoke URL followed by your resource name: https://qa397wgn73.execute-api.us-west-1.amazonaws.com/Staging/my-resource

Making your First Request

You can now make a GET request to the base URL of your API which will look like this:

Adding API Key Authentication with RapidAPI

One way to authenticate requests would be to do it through the API gateway and set up new API keys there. This is fairly straightforward to do, but if you ever want to allow other developers to consume this API, then it becomes difficult to generate new API keys and manage all of the different active API keys you have. You’ll also have to think about whether or not you want to charge for usage of the API, which then envolves handling payments and invoicing.

A great tool to do user management, API key generation, analytics, and billing for you is a tool called RapidAPI.

To start, you’ll need to be logged in to RapidAPI. Once you’ve created an account, you can head over to our documentation on Adding and Managing Your API. This will detail exactly how you’ll want to add your API to the RapidAPI marketplace. The basic steps are:

Create & name your API
Add the base URL for your API
- This is going to be the Invoke URL from your AWS API Gateway.
Document all of the endpoints your API has available
- This is going to be all of the resources and methods you’ve defined for your API.

Now that your API has been documented for consumption through RapidAPI, you’re ready to set up authentication.

The beauty of RapidAPI is that we handle all user management and billing for you! That means as long as you set up a pricing plan and API access according to how you want to allow developers to access the API, then all you have to do is authenticate if a request is coming from RapidAPI in your code. Since we do all of the authentications before an API request is made to your systems, then you can allow any request coming from the RapidAPI systems to successfully call your API.

The easiest way to do this is to use our secret hidden header called “X-RapidAPI-Proxy-Secret” which is a unique secret key sent with every API request to your systems. The developers using your API will never see this key and the key is unique to every API. To find your X-RapidAPI-Proxy-Secret, go to your API settings page in the RapidAPI Provider Dashboard.

To use this key to authenticate requests as coming from RapidAPI, you’ll just want to do a quick check right when a request comes in to see if the X-RapidAPI-Proxy header is present and matches your unique key. Here’s the code to do that:

exports.handler = (event, context, callback) => {
    if(event['headers']['X-RapidAPI-Proxy-Secret'] != '*******************') {
        callback(null, {
            statusCode: 401,
            body: JSON.stringify({message: 'Unauthorized'})
        });
    } else {
        // You API logic goes here
        let name = event['queryStringParameters']['name'];

        var responseBody = {
            message: "hello " + name + "!"
        };
        callback(null, {
            statusCode: 200,
            body: JSON.stringify(responseBody)
        });
    }
}

On top of easily adding user authentication and API key management, you also get the benefit of automatically exposing your API to our large developer community that would be thrilled to use your awesome API! If you get your API up and running on the marketplace, we would love to hear all about it! Feel free to email us at community@rapidapi.com to let us know about any APIs you’ve added on RapidAPI or projects you’re working on that use an API through RapidAPI.

How to Use an API in Google Sheets – RapidAPI for Google Sheets

Alex Walling — Thu, 12 Sep 2019 23:44:31 +0000

In this article, you'll learn how to use an API from RapidAPI right in Google Sheets.

Google Sheets can be a very powerful tool for storing, managing and transforming all kinds of data. I use it all the time for tracking my monthly spending, potential conferences RapidAPI might sponsor, emails of partnership leads, my yearly goals, and much more! With Google Sheets being such a useful tool already, we wanted to help enable anyone to supercharge their sheets through the power of APIs.

The RapidAPI add-on for Google Sheets allows you to make API requests to any API on RapidAPI from within a Google Sheet, and embed the data you get back into the sheet - all through a single function that can be dragged down across many rows

This tutorial will walk you through the basics of using the add-on.

1) Installing the Plugin

To install the plugin, simply head to the Google Sheets add-on store and install the free RapidAPI for Google Sheets add-on. During the installation process, there will be a prompt to accept permissions to run - which are required because this add-on makes requests to external APIs.
By default, the add-on will be disabled in any new spreadsheets that you create. Before using it in a new spreadsheet, you must enable it for that document. To do so:

Open the sheet you want to use the add-on in.
Open the “Add-ons” menu at the top of the window.
Click “Manage Add-ons”
You should see the RapidAPI Add-on there - click the green “Manage” button next to it and select “Use in this document”. Once selected it should have a check next to it.

2) Forming the Request

The RapidAPI Google Sheets Add-on supports two different types of functions

=GET(url, selectPaths, rapidApiKey)
=GETARR(url, arrPath, selectPaths, rapidApiKey)

The main difference between the two functions is how the response of the data is displayed. If an API has a single object as the response, then you will use the GET function. If the API returns an object that contains an array of values, then you will use the GETARR function.

For this tutorial, we’ll be using the GETARR functionality to search the Movie Database (IMDB Alternative) API to get information about a movie search term.

3) Subscribing to the API

Before being able to make a request to the API, you’ll first need to subscribe to an API plan. To do that, use the ‘Pricing’ tab. There are four different pricing plans currently available for the API we’re using for this example. The most affordable plan is a free BASIC plan, which allows for 1,000 calls per month and $0.01 for each additional request over 1,000. The plan that allows you the highest amount of requests is the $10 per month MEGA plan, which enables you to make unlimited API calls.

If the API you are using does have an overage fee associated, please be sure to be careful about the number of requests that your account is making. You will be charged for any additional usage. You can keep track of your quota in your RapidAPI Developer Dashboard.

Please note. Every time the Google Sheet is opened, the Google Script request is run. What this means is another API request will be made. Make sure you are aware of this when implementing RapidAPI into your Google Sheet.

4) Gathering the Required Information

For the GETARR function, at the bare minimum requires the url, arrPath, selectPaths, and rapidApiKey. You are also able to provide optional and required query string parameters too. All of this information can easily be found on the API's listing page from RapidAPI. Here’s where you can locate the information:

URL: "https://rapidapi.com/imdb/api/movie-database-imdb-alternative"
arrPath: "Search"
selectPath: "imdbID,Title,Year,Poster"
rapidApiKey: "*****************************"
requiredParameters: "s",{Cell Containing Search Term}
optionalParameters: "page","1","r","json"

With this information in hand, you’re ready to start forming your request! Here’s what the full request will look like:

=GETARR("https://movie-database-imdb-alternative.p.rapidapi.com/","Search","imdbID,Title,Year,Poster","*********************","page","1","r","json","s",B3)

One thing to note here is that after entering all of the required values [url, arrPath, selectPaths, rapidApiKey], you are able to provide the optional and required query string parameters in the following format: ,“key”,”value”,”key2”,”value2” ,etc.

When I’m utilizing this tool, I like to format the Spreadsheet by using a cell for the search term since it is the dynamic parameter. This makes it easy to update that particular cell and get a new search result.

The API request is what fills in the IMDB ID, TITLE, Release Year, and Link columns of this spreadsheet. Then as an added bonus, I use the =IMG() function, that is provided by default in Google Sheets, to add in the image of the movie posters based on the link the API returned!

I went ahead and created a template for this specific example to help you get started. The template Google Sheet can be found here.

With this spreadsheet, you can select ‘Add to Drive’ and follow the instructions in this blog post to help you get started. Once you subscribe and have your API key, just add it to the spreadsheet to see your results. For more example use cases, you can take a look at this example spreadsheet that shows you how you can validate a list of email addresses, find stock information, geocode an address.

We’re really excited to see the ways in which you will use the RapidAPI Google Sheets plugin! Shoot us a Tweet at @rapid_api to let us know what you end up building.