Celebrate 110 years of national parks with Maps, Search, and Gemini

Celebrate 110 years of national parks with Maps, Search, and Gemini

The year 2026 brings a rare milestone for public lands in the United States: 110 years since the National Park Service was created. To mark the occasion, Google published an announcement on August 24, 2026, with a straightforward message: the anniversary can be experienced through three familiar tools—Google Maps, Google Search, and the Gemini AI assistant. The post, titled Celebrate 110 years of national parks with Maps, Search, and Gemini, is a reminder that technology no longer merely documents a trip; it can plan the route, answer the questions, and tell the story behind every overlook.

What follows is both a summary of that announcement and a practical companion. If you are a developer, a data hobbyist, or simply someone who wants to build a small "parks explorer" of your own, the second half of this article offers a working Python project that connects to the same trio of Google services.

A milestone 110 years in the making

The National Park Service Organic Act, signed in 1916, established a single system to protect America's most extraordinary landscapes. A hundred and ten years later, those lands remain a cultural anchor, drawing visitors who come for geysers, canyons, ancient forests, and quiet meadows alike. The 2026 anniversary is deliberately framed not as a look backward, but as an invitation to engage with parks in the present—and Google's announcement reflects that spirit.

The blog post appeared on August 24, 2026, at https://blog.google/products-and-platforms/products/maps/national-parks-week-google-2026. It is an accessible primary source, written by Google, and it positions Maps, Search, and Gemini as the digital companions for the anniversary. For the purpose of this article, the post itself is the factual anchor; anything beyond its broad themes—such as specific product capabilities—is general background knowledge about how these services work, not a claim extracted from the announcement.

What Maps, Search, and Gemini bring to the anniversary

Each of the three tools plays a distinct role in a park visit, and together they cover the full arc of the experience: before, during, and after.

Google Maps handles the spatial layer. It provides driving directions to park entrances, walking routes on trails (where available), traffic estimates, and satellite views for scouting a location before you commit. For the anniversary, this is the tool that answers the basic Logistics questions: How far is it? How long will it take? Is there an alternative route through the mountains?

Google Search adds the information layer. Official National Park Service pages, weather forecasts, fee schedules, reservation rules, and seasonal alerts are all reachable with a single query. Search is especially valuable for the less obvious details of a park trip—fire restrictions, road closures, bear-safe food storage guidelines, and which visitor centers are open in the off-season.

Gemini brings the conversational layer. Instead of reading five different pages and stitching the facts together yourself, you can ask a question in plain language—"What should I pack for a weekend at Olympic National Park in March?"—and receive a synthesized answer with a suggested itinerary, a packing list, and even a brief history of the park's glaciers. For the 110th anniversary, Gemini can also serve as a storytelling companion, explaining how a particular canyon was formed or why a lodge was built where it stands.

None of this requires the official blog post to be technical documentation; it is simply how these services have evolved. The announcement's role is to direct attention to that capability at the moment of the anniversary.

From reading to building: a parks explorer in Python

Reading about Maps, Search, and Gemini is one thing. Wiring them together is another. The rest of this article walks through the creation of a small command-line application that queries all three services for a national park of your choice. You will get a driving estimate from Maps, a set of relevant links from Search, and a short summary from Gemini.

The project uses Google's official client libraries, so the code stays small and readable. You will need to create a few API keys and a custom search engine ID, but the setup takes only a few minutes if you already have a Google account.

Requirements

Before starting, gather the following:

• Python 3.10 or newer installed on your machine. Check with python3 --version.
• A Google Cloud project with the relevant APIs enabled. For this tutorial you will enable the Directions API (part of Google Maps), the Custom Search JSON API, and the Gemini API.
• A Gemini API key, obtained from Google AI Studio or your Google Cloud console.
• A standard Google API key for the Maps and Custom Search services. This is the same kind of key used across Google Cloud APIs.
• A Programmable Search Engine ID (CX). Create one at the Programmable Search Engine control panel and set it to search the entire web, then copy its search engine ID.
• Internet access, since all three services are cloud-based.

Step-by-step installation

Begin by creating a project directory and moving into it.

mkdir parks-explorer && cd parks-explorer

Next, create a Python virtual environment. This keeps the project's dependencies isolated from your system Python.

python3 -m venv parks-env

Activate the virtual environment. On macOS and Linux use the command below; on Windows the equivalent is parks-env\Scripts\activate.

source parks-env/bin/activate

Upgrade pip to its latest version so that package installation works smoothly.

pip install --upgrade pip

Install the four libraries we need: google-genai for Gemini, googlemaps for Maps, google-api-python-client for the Custom Search JSON API, and python-dotenv for loading credentials from a local file.

pip install google-genai googlemaps google-api-python-client python-dotenv

Create a .env file to hold your secrets. Using a dotenv file keeps keys out of your source code and prevents accidental exposure if you commit the project to a repository.

touch .env

Open the file in your editor and add the following four lines, replacing the placeholders with your actual values:

GEMINI_API_KEY=your_gemini_api_key_here
GOOGLE_API_KEY=your_google_api_key_here
GOOGLE_CSE_ID=your_custom_search_engine_id_here

Finally, verify that the libraries import correctly. This should produce no errors if the installation worked.

python -c "import googlemaps, googleapiclient, google.genai, dotenv; print('OK')"

Usage examples

All of the examples below assume the virtual environment is active and the .env file is present in the working directory.

Example 1: Ask Gemini about a park

The google-genai SDK makes a request in a few lines. The script loads the API key from the environment, creates a client, and asks for a suggestion.

import os
from dotenv import load_dotenv
from google import genai

load_dotenv()

client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

response = client.models.generate_content(
    model="gemini-2.5-flash",  # use the model ID enabled for your project
    contents=(
        "My family is visiting Rocky Mountain National Park next month. "
        "Suggest three moderate hikes under five miles."
    ),
)

print(response.text)

Note that the model name in the example is illustrative. Model identifiers change over time and vary by project, so check the list of available models for your API key before running the code.

Example 2: Search for official park information with the Custom Search JSON API

This example uses the Programmable Search Engine to fetch three relevant links for a park query.

import os
from dotenv import load_dotenv
from googleapiclient.discovery import build

load_dotenv()

service = build("customsearch", "v1", developerKey=os.getenv("GOOGLE_API_KEY"))

result = service.cse().list(
    q="Great Smoky Mountains National Park current conditions",
    cx=os.getenv("GOOGLE_CSE_ID"),
    num=3,
).execute()

for item in result.get("items", []):
    print(item.get("title"))
    print(item.get("link"))
    print("---")

Run this and you should see titles and URLs drawn from the web, typically including the official NPS pages for the park.

Example 3: Get a driving estimate from Maps

The googlemaps client wraps the Maps web services neatly. Here we ask for a driving route from Denver to Rocky Mountain National Park.

import os
import googlemaps
from dotenv import load_dotenv

load_dotenv()

gmaps = googlemaps.Client(key=os.getenv("GOOGLE_MAPS_API_KEY"))

route = gmaps.directions(
    origin="Denver, CO",
    destination="Rocky Mountain National Park",
    mode="driving",
)

if route:
    leg = route[0]["legs"][0]
    print(f"Distance: {leg['distance']['text']}")
    print(f"Duration: {leg['duration']['text']}")
else:
    print("No route found.")

The output will show the total driving distance and the estimated time in traffic-free conditions. For a longer route, such as a cross-country drive to Yellowstone, the same two-line call scales without difficulty.

Example 4: Combine all three into a single parks explorer

Now we bring everything together. The script below defines one constant for the park name and one for the starting city, then queries Maps, Search, and Gemini in sequence. Save it as parks_explorer.py.

import os
from dotenv import load_dotenv
import googlemaps
from google import genai
from googleapiclient.discovery import build

load_dotenv()

PARK = "Yosemite National Park"
ORIGIN = "San Francisco, CA"

# 1. Maps: driving estimate
gmaps = googlemaps.Client(key=os.getenv("GOOGLE_MAPS_API_KEY"))
route = gmaps.directions(ORIGIN, PARK, mode="driving")
if route:
    leg = route[0]["legs"][0]
    print(f"Driving time: {leg['duration']['text']}")
    print(f"Distance: {leg['distance']['text']}")

# 2. Search: visitor guide links
service = build("customsearch", "v1", developerKey=os.getenv("GOOGLE_API_KEY"))
results = service.cse().list(
    q=f"{PARK} visitor guide",
    cx=os.getenv("GOOGLE_CSE_ID"),
    num=3,
).execute()
print("\nUseful links:")
for item in results.get("items", []):
    print(f"- {item['title']}: {item['link']}")

# 3. Gemini: two-sentence summary
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
summary = client.models.generate_content(
    model="gemini-2.5-flash",  # use your enabled model ID
    contents=(
        f"In two sentences, explain why {PARK} is worth visiting "
        f"during its 110th anniversary year."
    ),
)
print("\nGemini says:")
print(summary.text)

Running the script produces a compact trip briefing. This is the minimal viable version of the "Google triplet" for a national park: a route from Maps, a reading list from Search, and a narrative from Gemini.

python parks_explorer.py

It is worth stressing that the model ID line must be adjusted to whatever Gemini model your project has access to. If you run into an API_KEY_INVALID error during the Gemini call, double-check the key in your .env and ensure the Gemini API is enabled in your Google Cloud project.

Practical limits and open questions

The example project is intentionally minimal, but even a minimal script reveals the boundaries of these tools.

First, the Maps Directions API returns estimates based on the current road network and typical traffic conditions, not real-time congestion. A route that looks perfect at noon may look very different at 5 PM on a summer Friday. Treat the duration as a planning aid, not a promise.

Second, the Custom Search JSON API enforces daily query quotas for free projects. If you plan to run the script hundreds of times, you will need to request a higher quota or switch to a paid tier. The same caution applies to the Gemini API, which has rate limits that vary by model. Google's documentation describes exact numbers, and those numbers change; the safe habit is to read the current limits before building a service on top of them.

Third, Gemini can generate fluent-sounding answers that are subtly wrong. Park hours, trail conditions, and reservation rules change frequently, and an AI model's training data can be stale. Always verify Gemini output against the official park pages you find through Search. This is not a criticism of the technology; it is the correct mental model for any generative assistant.

Finally, the source blog post itself is the authoritative statement about Google's celebration. The feature descriptions in this article are based on general knowledge of Maps, Search, and Gemini, and the specific anniversary content—such as any curated collections, search features, or Maps overlays that Google introduced—may provide more detail. Read the announcement for the official word; use the code in this article to explore the territory.

Conclusion

One hundred and ten years is a long life for any institution, and the national parks have spent that century balancing preservation with accessibility. The 2026 anniversary by Google's Maps, Search, and Gemini is a practical illustration of how that balance now works: Maps gets you to the trailhead, Search tells you what is waiting there, and Gemini helps you understand why it matters.

The Python project in this article is a starting point, not a finished product. You can extend it with geocoding to accept arbitrary addresses, with the Places API to find nearby campgrounds, or with Gemini's streaming mode to generate a full day-by-day itinerary. The essential pieces—an API key, a search engine ID, and a little patience—are all you need to celebrate the anniversary in your own way. The parks have survived eleven decades; your code can survive the next software update.