BreezoMeter Pollen Getting Started: API Integration (2026)

Getting started overview

Integrating with the BreezoMeter Pollen API involves a sequence of steps designed to enable developers to retrieve environmental pollen data for specific locations and times. The process begins with account creation to secure an API key, which serves as the primary authentication method for all API requests. Once authenticated, developers can formulate HTTP GET requests to the Pollen API endpoint, specifying parameters such as latitude, longitude, and optionally, a date and time range for historical or forecasted data. The API responds with JSON-formatted data detailing various pollen types and their corresponding severity levels.

BreezoMeter provides a comprehensive developer documentation portal that includes API references, code examples in multiple programming languages, and guides for common use cases. This resource is designed to support developers through the integration process, from initial setup to advanced data querying and error handling. Adhering to the rate limits and best practices outlined in the documentation helps ensure efficient and reliable API consumption.

Quick reference

The following table summarizes the essential steps for getting started with BreezoMeter Pollen:

Create an account and get keys

To begin using the BreezoMeter Pollen API, developers must first establish an account. This process typically involves navigating to the BreezoMeter website and selecting a plan, which includes a free trial option offering up to 50,000 requests. During the signup, users provide basic contact information and agree to the terms of service.

Upon successful registration, an API key is automatically generated and made available within the user's developer dashboard. This API key is a unique alphanumeric string that authenticates all requests made to the BreezoMeter API. It is crucial to treat this key as sensitive information, similar to a password, and protect it from unauthorized access. Best practices for API key management include:

• Storing the API key securely, avoiding hardcoding it directly into client-side code.
• Using environment variables or a dedicated secrets management service for server-side applications.
• Restricting the key's permissions if applicable, although BreezoMeter API keys generally grant access to the subscribed services.
• Regenerating the API key periodically or immediately if compromise is suspected.

The API key must be included as a query parameter in every request to the BreezoMeter Pollen API. Without a valid and active API key, the API will return an authentication error.

Your first request

After obtaining an API key, the next step is to make a successful API call to retrieve pollen data. The BreezoMeter Pollen API is accessed via HTTP GET requests. A basic request requires specifying the latitude, longitude, and your API key. For example, to retrieve current pollen data for a specific location, you would use the /pollen/v2/current endpoint.

Example Request (cURL)

Using cURL, a common command-line tool for making HTTP requests, you can construct your first API call. Replace YOUR_API_KEY with your actual BreezoMeter API key and adjust the latitude and longitude as needed.

curl -X GET \
  "https://api.breezometer.com/pollen/v2/current?lat=34.052235&lon=-118.243683&key=YOUR_API_KEY&features=allergens_types,plants_details,trees_details,grasses_details,weeds_details" \
  -H "Accept: application/json"

This cURL command requests current pollen data for a location in Los Angeles, including details on allergen types and specific plant, tree, grass, and weed pollen. The Accept: application/json header ensures the response is returned in JSON format.

Example Request (Python)

For Python developers, the requests library is a common choice for making HTTP requests. Ensure you have it installed (pip install requests).

import requests
import json

api_key = "YOUR_API_KEY"
latitude = 34.052235
longitude = -118.243683

url = f"https://api.breezometer.com/pollen/v2/current?lat={latitude}&lon={longitude}&key={api_key}&features=allergens_types,plants_details,trees_details,grasses_details,weeds_details"

headers = {
    "Accept": "application/json"
}

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)
    data = response.json()
    print(json.dumps(data, indent=2))
except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err}")
except Exception as err:
    print(f"Other error occurred: {err}")

This Python script performs the same request as the cURL example, printing the formatted JSON response to the console. Error handling is included to catch potential issues during the API call.

Example Request (JavaScript - Node.js with fetch)

In a Node.js environment, you can use the built-in fetch API (available in Node.js 18+ or via a polyfill) to make requests.

const apiKey = "YOUR_API_KEY";
const latitude = 34.052235;
const longitude = -118.243683;

const url = `https://api.breezometer.com/pollen/v2/current?lat=${latitude}&lon=${longitude}&key=${apiKey}&features=allergens_types,plants_details,trees_details,grasses_details,weeds_details`;

fetch(url, {
  method: "GET",
  headers: {
    "Accept": "application/json",
  },
})
  .then(response => {
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return response.json();
  })
  .then(data => {
    console.log(JSON.stringify(data, null, 2));
  })
  .catch(error => {
    console.error("Error during API call:", error);
  });

This JavaScript example demonstrates how to fetch pollen data and process the JSON response, including basic error handling.

Understanding the response

A successful response from the BreezoMeter Pollen API will be a JSON object containing various fields related to pollen data. Key fields to look for include:

• data: The main object containing pollen information for the requested location and time.
• datetime: The timestamp for which the data is valid.
• types: An array or object detailing different pollen types (e.g., tree, grass, weed) and their respective concentration levels, often categorized by severity (e.g., low, moderate, high).
• plants: More granular details about specific plants contributing to pollen.

Refer to the BreezoMeter Pollen API current conditions documentation for a complete breakdown of the response structure and available fields.

Common next steps

Once you have successfully made your first request and parsed the response, several common next steps can enhance your integration with the BreezoMeter Pollen API:

1. Explore Historical and Forecast Data: The Pollen API offers endpoints for pollen forecasts and historical data. Integrate these to provide users with predictive insights or analyze past trends.
2. Implement Error Handling: Develop robust error handling for various API response codes (e.g., 400 Bad Request, 401 Unauthorized, 429 Too Many Requests). This ensures your application remains stable and provides informative feedback to users.
3. Manage Rate Limits: Be aware of the API rate limits associated with your BreezoMeter plan. Implement strategies like request queuing or exponential backoff to avoid exceeding limits and ensure continuous service availability.
4. Optimize API Calls: Consider caching pollen data where appropriate, especially for static locations or short timeframes, to reduce the number of API calls and improve application performance.
5. Integrate with User Interfaces: Display pollen data clearly and intuitively in your application's UI. This might involve using color-coded indicators for severity, charts for trends, or detailed text descriptions.
6. Explore Additional Features: BreezoMeter offers other APIs, such as the Air Quality API and Fire API. If your application requires broader environmental data, consider integrating these additional services.
7. Secure Your API Key: Reiterate and enforce strong security practices for your API key, especially in production environments. For web applications, consider using a backend proxy to make API calls, preventing direct exposure of the key in client-side code, as recommended by security guidelines for Google Maps API Key Best Practices, which also apply to other API keys.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting steps:

• Check API Key: Verify that your API key is correctly copied and pasted into the request URL, and that it is active in your BreezoMeter dashboard. A common error is a 401 Unauthorized response due to an invalid or missing key.
• Review URL Parameters: Ensure all required parameters (lat, lon, key) are present and correctly formatted. Latitude and longitude values must be within their valid ranges. Incorrect parameters can lead to a 400 Bad Request.
• Examine Endpoint: Double-check that you are using the correct API endpoint (e.g., /pollen/v2/current). Typos in the endpoint path will result in a 404 Not Found error.
• Inspect Response Body: If you receive an error status code (e.g., 4xx or 5xx), the API response body often contains a detailed error message that can help diagnose the problem. For example, a 429 Too Many Requests indicates you've hit your rate limit.
• Consult Documentation: Refer to the BreezoMeter documentation for specific error codes and their meanings. The documentation also provides expected request and response formats.
• Network Connectivity: Ensure your development environment has an active internet connection and that no firewalls or proxy settings are blocking outgoing HTTP requests to api.breezometer.com.
• CORS Issues (Client-Side): If making requests directly from a web browser (client-side JavaScript), you might encounter Cross-Origin Resource Sharing (CORS) errors. BreezoMeter's API typically requires requests to be made from a server-side application to avoid exposing your API key and circumvent CORS restrictions. For more on CORS, refer to MDN Web Docs on CORS.
• Rate Limit Check: If you receive a 429 status code, you have exceeded your plan's rate limit. Wait for the cooldown period or upgrade your plan.