API Data Ingestion

How to Pull Live Data from Google Maps & Spotify

📅 April 2025 · ⏱ 8 min read · 🛠 Beginner–Intermediate

What Even Is API Data Ingestion?

You've probably heard 'API' thrown around a lot. But what does it actually mean when someone says they're 'ingesting data from an API'? Let's break it down simply.

An API (Application Programming Interface) is basically a waiter at a restaurant. You (the developer) sit at the table, the kitchen (the data server) has all the food (data), and the waiter carries your order back and forth. You never go into the kitchen — the API handles that for you.

Data ingestion just means: pulling that data into your system so you can actually use it — in a dashboard, an app, a database, or an analysis.

TL;DR

API Data Ingestion = making HTTP requests to a service's endpoint → receiving structured data (JSON) → using/storing it for your purpose.

Google Maps vs Spotify: Quick Comparison

Before we dive into code, here's what you're actually working with:

Feature | Google Maps API | Spotify API

Auth Type |API Key | OAuth 2.0

Free Tier | $200/month credit |Unlimited (non-commercial)

Data Type |Location, places, routes | Tracks, playlists, artists

Rate Limit |~2,500 req/day (free) | ~180 req/30 sec

Response Format |JSON |JSON

SDK Available | Yes (JS, Python, etc.) |Yes (spotipy, etc.)

Part 1: Google Maps API

Google Maps Platform has 20+ APIs. The most useful ones for data ingestion are:

Places API — search for restaurants, ATMs, hospitals nearby
Geocoding API — convert address → coordinates (lat/lng)
Distance Matrix API — travel time between multiple locations
Directions API — get route data between two points

Step 1: Get Your API Key

Go to console.cloud.google.com
Create a project → Enable 'Maps JavaScript API' or 'Places API'
Go to Credentials → Create API Key
Restrict it (HTTP referrers or IP) so no one else uses it

💡 Tip

Google gives you $200 free credit monthly — enough for ~40,000 geocoding requests. More than enough for projects and learning.

Step 2: Make Your First Request (Python)

Let's fetch place details using the Places API with Python's requests library:

import requests

API_KEY = 'YOUR_GOOGLE_MAPS_API_KEY'

query = 'coffee shops in Connaught Place Delhi'

url = 'https://maps.googleapis.com/maps/api/place/textsearch/json'

params = {

'query' : query,

'key' : API_KEY

response = requests.get(url, params=params)

data = response.json()

for place in data['results']:

print(place['name'], '|', place['rating'], '|', place['formatted_address'])

Step 3: What the Response Looks Like

The API returns JSON. Here's a simplified sample:

'results': [

'name': 'Blue Tokai Coffee',

'rating': 4.5,

'formatted_address': 'N-14, CP, New Delhi',

'geometry': {

'location': { 'lat': 28.6315, 'lng': 77.2167 }

},

'types': ['cafe', 'food', 'establishment']

],

'status': 'OK'

Geocoding: Address → Lat/Lng

Very common use case in dashboards and data pipelines:

def geocode_address(address, api_key):

url = 'https://maps.googleapis.com/maps/api/geocode/json'

resp = requests.get(url, params={'address': address, 'key': api_key})

result = resp.json()['results'][0]

return result['geometry']['location'] # {'lat': ..., 'lng': ...}

# Example

coords = geocode_address('India Gate, New Delhi', API_KEY)

print(coords) # {'lat': 28.6129, 'lng': 77.2295}

Part 2: Spotify API

Spotify's API is a goldmine for music data — tracks, audio features, playlists, artist info, listening trends. But unlike Google Maps, it uses OAuth 2.0 authentication, which is slightly more involved.

OAuth 2.0 — Don't Panic

There are two flows to know:

Client Credentials

No user login needed. Use this for public data — search, artist info, track metadata. Perfect for data pipelines.

Authorization Code

Requires user to log in. Use this to access user's playlists, listening history, saved tracks.

Step 1: Register Your App

Go to developer.spotify.com/dashboard
Create an App → note your Client ID and Client Secret
Set Redirect URI to http://localhost:8888/callback for local testing

Step 2: Get an Access Token (Client Credentials)

For public data — no user login required:

import requests, base64

CLIENT_ID = 'your_client_id'

CLIENT_SECRET = 'your_client_secret'

def get_token():

creds = base64.b64encode(f'{CLIENT_ID}:{CLIENT_SECRET}'.encode()).decode()

headers = {'Authorization': f'Basic {creds}'}

data = {'grant_type': 'client_credentials'}

resp = requests.post('https://accounts.spotify.com/api/token',

headers=headers, data=data)

return resp.json()['access_token']

TOKEN = get_token()

print('Got token:', TOKEN[:20], '...')

Step 3: Search for Tracks

def search_tracks(query, token, limit=5):

headers = {'Authorization': f'Bearer {token}'}

params = {'q': query, 'type': 'track', 'limit': limit}

resp = requests.get('https://api.spotify.com/v1/search',

headers=headers, params=params)

tracks = resp.json()['tracks']['items']

for t in tracks:

print(t['name'], '—', t['artists'][0]['name'],

'|', t['popularity'], '/100')

search_tracks('Arijit Singh', TOKEN)

Bonus: Audio Features — The Fun Part

This is where Spotify's data gets really interesting for analysis. Every track has audio features like danceability, energy, valence (happiness):

def get_audio_features(track_id, token):

headers = {'Authorization': f'Bearer {token}'}

url = f'https://api.spotify.com/v1/audio-features/{track_id}'

return requests.get(url, headers=headers).json()

# Sample response fields:

# danceability: 0.85 (0.0 - 1.0)

# energy: 0.72

# valence: 0.61 (0.0 = sad, 1.0 = happy)

# tempo: 128.5 (BPM)

# acousticness: 0.12

Best Practices for API Ingestion

Handle Rate Limits

APIs throttle excessive requests. Always add delays or retry logic:

import time

for item in large_list:

result = call_api(item)

time.sleep(0.5) # 500ms delay between calls

Never Hardcode Secrets

# BAD — never do this

API_KEY = 'AIzaSyXXXXXXXXXXXXXXX'

# GOOD — use environment variables

import os

API_KEY = os.environ.get('GOOGLE_MAPS_KEY')

Cache Responses

If you're hitting the same endpoint repeatedly, cache the result locally:

import json, os

def cached_request(url, params, cache_file):

if os.path.exists(cache_file):

return json.load(open(cache_file))

data = requests.get(url, params=params).json()

json.dump(data, open(cache_file, 'w'))

return data

Project Ideas to Practice

🗺 Google Maps

🎵 Spotify

PG/hostel locator dashboard

Music mood analyzer by audio features

Nearest hospital finder by city

Top 50 tracks by country tracker

Travel time matrix for delivery apps

Artist discography explorer

Store density heatmap by PIN code

Playlist analyzer for energy/valence

Wrapping Up

API data ingestion is one of those skills that unlocks everything — dashboards, pipelines, apps, research projects. The pattern is always the same:

Authenticate (API key or OAuth token)
Make a GET request to the endpoint with your parameters
Parse the JSON response
Store, display, or analyze the data

Google Maps is great for location intelligence. Spotify is perfect for behavioral/content data analysis. Both will look excellent on a portfolio or resume.

Next Steps

Try combining both APIs — e.g., find coffee shops near a music venue, then pull the venue's featured playlist. Real-world projects beat tutorials every time.

Happy building 🚀

API Data Ingestion: How to Pull Live Data from Google Maps or Spotify.