How to Connect Gravity Forms to Any API for Live Data Lookup

1. The Setup
   1. Install GC API Alchemist
   2. Connect to NTHSA
   3. Build the Form
2. Two Ways to Display Data
   1. Method 1: Standard
      1. Set Up Feed
      2. Webhook Settings
      3. Request Configuration
      4. Response Handling
      5. Map Response Data
   2. Method 2: Live
      1. Activate GP Populate Anything
      2. Edit API Connection Profile
      3. Map to Form Fields
3. Alchemy Complete

Imagine typing in a single piece of info and having your form instantly pull up all the related details from an external database. That’s pretty powerful—turning Gravity Forms into a tool that can push and pull data from the rest of the web.

Say someone fills out your form and enters their Vehicle Identification Number (VIN). You could also ask them to type in the year, make and model, or you could just ask for the VIN and pull the rest automatically.

With GC API Alchemist, you connect your form to an external database, pull in those vehicle details, and save them with the entry. Add GP Populate Anything to the mix, and those details are now auto-populated in the form fields instantly.

Here are two ways to do this:

1. Standard: Data is fetched after the form is submitted. Great if you just need it stored in the entry.
2. Live: Data shows up as the user types, before they submit the form. Great for instant validation, real-time lookups, or building conditional logic based on the fetched data.

Let’s walk through both methods and turn a basic VIN field into a lookup tool. 🔎

The Setup

First, we’ll connect our website to the NHTSA API and build the form that’ll display the vehicle data.

Install GC API Alchemist

1. Open your Spellbook › click Connect › install and activate GC API Alchemist.
2. Once active, you’ll see API Connections in the dashboard under Forms.

Connect to NTHSA

Let’s connect your site to the NHTSA API and save it as a new “Connection Profile.”

1. Open API Connections from the dashboard.
2. Click Add New API Connection.
3. Set name: VIN
4. Base URL: https://vpic.nhtsa.dot.gov/api/
5. Authentication tab: None
6. Click Publish.

Build the Form

Let’s build the form that’ll pull in and display the vehicle data.

1. Create a new form (or edit an existing one).
2. Add Single Line Text fields and label with the following:
   • VIN
   • Year — Hidden
   • Make — Hidden
   • Model — Hidden
3. Save the form.

We’ve hidden the Year, Make, and Model fields because they don’t need to be seen, as they’ll only be filled in once the form is submitted.

Two Ways to Display Data

1. Method 1 (Standard) pulls in the data after the form is submitted, which can be viewed in the entry.
2. Method 2 (Live) populates the vehicle data instantly as soon as someone types in a VIN, all before the form is submitted.

Method 1: Standard

In this method, the user enters a VIN and submits the form. GC API Alchemist then “talks” to the database, brings back the vehicle data, and automatically updates the submitted entry.

This works well if you only need the data behind the scenes—for validation, record-keeping, notifications, and more.

Set Up Feed

Think of a feed as the instructions. When someone submits a form, the feed says: “Hey, take this VIN, send it to NHTSA, and bring back the vehicle data for me.”

1. In the form, navigate to Settings › API Alchemist.
2. Click Add New › name the feed Decode VIN.

Webhook Settings

3. Under Connection Profile › select None (Direct URL).
4. For Endpoint Path: https://vpic.nhtsa.dot.gov/api/vehicles/DecodeVin/{VIN}
5. HTTP Method: GET

Request Configuration

6. Click the merge tag icon and select the VIN field.
7. Parameter: format
8. Value: json

Response Handling

9. Enable Response Handling › select Simple.

Map Response Data

When you ask the NHTSA database for a vehicle’s data, it sends back around 140 pieces of data, way more than we need!

To grab just the year, make, and model, we’ll use a JSONPath. Think of it as a filter that picks out exactly what you’re looking for.

10. Still in the feed settings › click Open Response Mapping Editor.
11. Temporarily add a test value with a real VIN for testing purposes: try 1J8HH48K68C202997 › click Test Request.
12. You’ll see the response data displayed as an interactive tree.
    
    You can drag items to the right to map them, or simply copy/paste these ready-made filters under the JSONPath Expression column for each field:
    • Year: $.Results[?(@.Variable=="Model Year")].Value
    • Make: $.Results[?(@.Variable=="Make")].Value
    • Model: $.Results[?(@.Variable=="Model")].Value

4. Close the window › click Save Settings.

Test it out! Preview the form, enter a VIN, and submit. When you check the entry, the GC API Alchemist has already populated the Year, Make, and Model fields with the actual vehicle data.

Method 2: Live

This method populates vehicle data instantly as users type, no need to wait for the form to be submitted. 

Here’s where GP Populate Anything comes in. It pulls in the data and displays it right away. You can then use that info to set up conditional logic, show or hide fields, or build workflows that adapt to user input.

In practice, this comes in handy for all sorts of scenarios: tracking a package with an order number, looking up a patient’s info by ID, checking stock with a product code, and more.

In our case, we’re displaying vehicle details as soon as the VIN is entered. We’ll use GC API Alchemist to fetch the data from NHTSA, and GP Populate Anything to map it to the fields in real-time.

Activate GP Populate Anything

1. Open your Spellbook › install and activate GP Populate Anything.

Edit API Connection Profile

Let’s head back to the VIN Decoder connection profile we created earlier and set up the live lookup endpoints. These will let each field in our form pull data in real-time.

2. Navigate to Forms › API Connections › open VIN Decoder.
3. Scroll to Populate Anything Endpoints › click + Create Endpoint.
4. Name: Year
5. API Endpoint: vehicles/DecodeVin/{vin}?format=json

5. Click Next — Data & Property Mapping.
6. In the vin field: enter a test VIN 1J8HH48K68C202997
7. Click Test Request › a new field will appear with all the vehicle data.
8. In the JSONPath field: $.Results[?(@.Variable=="Model Year")] — which will pull up the year when the vehicle was made.

9. Click Next — Query Parameters (Filters)
10. Check the vin (string) which will allow GP Populate Anything to filter the results by.
11. Click Next — Cache Settings › leave as is.
12. Click Create Endpoint.

This is for the Year only. Repeat steps 3 to 11 for the Make and Model, changing only the name and its corresponding JSONPath:

• Make: $.Results[?(@.Variable=="Make")]
• Model: $.Results[?(@.Variable=="Model")]

Map to Form Fields

Now let’s wire up your form fields to use this live data.

13. Open the form › click Year field.
14. Check Populate value dynamically.
15. Type: API Alchemist
16. Connection Profile: VIN
17. Endpoint: Year
18. Click Add Filter Group › set to Vin / is / VIN (the VIN field).
19. Set Value › Value
20. Repeat steps 13 to 19 for the Make and Model fields, selecting the appropriate endpoint for each.
21. Save form.

Now test it out. Enter a VIN, and watch the year, make, model auto-populate instantly. ✨

Alchemy Complete

This same approach works for any API you want to connect your Gravity Forms to. GC API Alchemist handles the bridge-building, you control the magic.

That said, what will you automate alchemize next? 🎩