GBIF

Overview

The Global Biodiversity Information Facility (GBIF) is an international network and data infrastructure funded by governments worldwide. Its primary mission is to provide free and open access to biodiversity data across the globe. Established in 2001, GBIF aggregates species occurrence records, taxonomic information, and associated environmental data from a vast network of publishers, including museums, botanical gardens, citizen science initiatives, and research institutions. This centralized resource makes billions of data records available for scientific research, conservation planning, and sustainable development.

GBIF's API is designed for developers, researchers, and data scientists who need programmatic access to this extensive dataset. It supports queries for species occurrences, datasets, publishers, and taxonomic classification. Users can filter data by geography, time, taxonomy, and other parameters, enabling targeted data retrieval for specific research questions. The API is particularly well-suited for ecological modeling, biogeographical studies, and analyses of biodiversity trends over time. For example, researchers might use the API to track the distribution of invasive species or analyze the impact of climate change on specific flora and fauna.

The platform also offers tools for data publishing, allowing institutions to share their biodiversity data in a standardized format, enhancing discoverability and interoperability. This collaborative approach ensures a continually growing and updated repository of global biodiversity information. While the data model can be complex due to the inherent intricacies of biological data, GBIF provides comprehensive documentation and examples in languages like R and Python to facilitate integration. Its commitment to open data aligns with principles for FAIR data (Findable, Accessible, Interoperable, Reusable), promoting broader scientific collaboration and impact, as detailed by organizations like W3C on FAIR data principles.

GBIF shines in scenarios requiring large-scale, geographically diverse, and historically rich biodiversity data. It is a foundational resource for projects in conservation biology, environmental impact assessments, and public health, where understanding species distributions and their changes is critical. The platform's generous rate limits accommodate extensive research needs, making it a reliable backbone for academic and governmental initiatives.

Key features

• Species Occurrence Data: Access billions of georeferenced records of species observations, specimens, and fossil findings.
• Taxonomic Backbone: Utilize a comprehensive and continually updated taxonomic backbone to standardize scientific names and classifications.
• Dataset Discovery: Programmatically search and retrieve metadata for thousands of biodiversity datasets published by institutions worldwide.
• Publisher Information: Explore details about the organizations contributing data to GBIF, including their location and data quality metrics.
• Geospatial Filtering: Filter occurrence data by bounding boxes, polygons, or specific countries to focus on relevant geographical areas.
• Temporal Filtering: Specify date ranges to analyze changes in species distribution or occurrence over time.
• Image Access: Link to associated media, such as photographs of species, where available.
• Data Download Tools: Facilitate large-scale data downloads in various formats for offline analysis.
• Data Publishing Tools: Provide tools and standards (e.g., Darwin Core Archive) for institutions to publish their biodiversity data.

Pricing

GBIF operates on a funding model supported by participating countries and organizations, making all its data and API access free for all users.

For more details on GBIF's operational model and funding, refer to their developer summary page.

Common integrations

• R Packages: Integration with R for statistical analysis and visualization, often using packages like rgbif for direct API calls.
• Python Libraries: Utilization of Python for data manipulation, analysis, and machine learning, with libraries such as pygbif.
• Geographic Information Systems (GIS): Integration with software like QGIS or ArcGIS for spatial analysis and mapping of species distributions, leveraging API data for ArcGIS query capabilities.
• Ecological Modeling Platforms: Feeding biodiversity data into ecological niche modeling tools and species distribution models.
• Citizen Science Platforms: Aggregating and integrating data from platforms like iNaturalist or eBird, which are also data publishers to GBIF.
• Data Visualization Tools: Connecting with platforms like Tableau or Power BI to create interactive dashboards and reports based on biodiversity data.

Alternatives

• iNaturalist: A citizen science project and online social network of naturalists, scientists, and biologists built on the concept of mapping and sharing observations of biodiversity across the globe.
• eBird: A global database of bird observations, providing scientists, researchers, and amateur naturalists with real-time access to a vast body of information on bird distribution and abundance.
• Ocean Biodiversity Information System (OBIS): A global online portal to marine biodiversity data, focusing specifically on ocean species occurrences.

Getting started

This Python example demonstrates how to use the GBIF API to search for occurrence records of a specific species (e.g., Panthera tigris) and retrieve the first few results. It utilizes the requests library for making HTTP requests.

import requests
import json

# Define the base URL for the GBIF occurrence API
BASE_URL = "https://api.gbif.org/v1/occurrence/search"

# Define parameters for the search query
# Searching for occurrences of 'Panthera tigris' (Tiger)
params = {
    "scientificName": "Panthera tigris",
    "limit": 5  # Retrieve the first 5 records
}

print(f"Searching for occurrences of {params['scientificName']}...")

try:
    # Make the GET request to the GBIF API
    response = requests.get(BASE_URL, params=params)

    # Raise an exception for HTTP errors
    response.raise_for_status()

    # Parse the JSON response
    data = response.json()

    # Check if results were found
    if data and data.get('results'):
        print(f"Found {data.get('count')} total occurrences. Displaying {len(data['results'])} results:")
        for i, occurrence in enumerate(data['results']):
            print(f"\n--- Occurrence {i+1} ---")
            print(f"Key: {occurrence.get('key')}")
            print(f"Species: {occurrence.get('species')}")
            print(f"Decimal Latitude: {occurrence.get('decimalLatitude')}")
            print(f"Decimal Longitude: {occurrence.get('decimalLongitude')}")
            print(f"Event Date: {occurrence.get('eventDate')}")
            print(f"Basis Of Record: {occurrence.get('basisOfRecord')}")
            print(f"Dataset Name: {occurrence.get('datasetName')}")
    else:
        print("No occurrences found for the specified species.")

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err}")
except requests.exceptions.ConnectionError as conn_err:
    print(f"Connection error occurred: {conn_err}")
except requests.exceptions.Timeout as timeout_err:
    print(f"Timeout error occurred: {timeout_err}")
except requests.exceptions.RequestException as req_err:
    print(f"An unexpected error occurred: {req_err}")
except json.JSONDecodeError:
    print(f"Failed to decode JSON from response: {response.text}")