arrow-left

Only this pageAll pages
gitbookPowered by GitBook
1 of 27

Fusionbase Public API

Loading...

Loading...

API Reference

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Fusionbase SDK

Loading...

Quick Start

Welcome to the Fusionbase Public API, your gateway to programmatically accessing a rich ecosystem of data streams. Before diving into the API, we recommend beginning your journey on our website to explore the vast array of data available to you.

hashtag
Step 1: Explore Data on the Fusionbase Website

hashtag
Discovering Data Streams

Visit the Hub to browse through the datasets. Here you can:

  • Search for topics that interest you.

  • Preview data to understand its structure and contents.

  • Identify the datasets that can provide the insights you need.

Take your time to explore. Once you find the data that aligns with your goals, note the Stream ID – you'll use this when interacting with the API.

hashtag
Step 2: Programmatically Access Data with the API

hashtag
Authenticate with Your API Key

To start using the API:

  1. Obtain your API key from the page in your Fusionbase account.

  2. Use the X-API-KEY header to authenticate your API requests.

hashtag
Base URL for API Requests

For all your API calls, use the base URL:

hashtag
Retrieving Your Selected Data Stream (or Any Other Data Entity)

After identifying the data you want from our website, you can retrieve it programmatically via the API endpoint:

Replace [Stream ID] with the ID of the data stream you've selected.

hashtag
Code Snippets for API Access

We provide a variety of code snippets to help you make your first API request in the language of your choice. Visit our for examples in Python, NodeJS, Java, C#, and more.

hashtag
Step 3: Integrate Data into Your Applications

Once you have successfully made requests using our sample code, it's time to integrate Fusionbase data streams into your applications. This allows you to automate data retrieval and keep your applications enriched with the latest data.

hashtag
Need Help?

If you encounter any issues or have questions as you explore and use the Fusionbase API, our support team is ready to assist you. Contact us via our .

Welcome to the Fusionbase API

hashtag
Empowering Data Exploration and Integration

At Fusionbase, we believe that working with data, particularly in its exploration and integration, should be both exciting and straightforward. Our API is crafted to support the daily workflows of data scientists and engineers with efficiency and ease.

hashtag
Designed with REST Principles for Predictability and Simplicity

The Fusionbase API embraces RESTful principles, ensuring a consistent and intuitive experience:

  • Resource-Oriented URLs: Navigate our API with clear, logical, and predictable URLs.

  • Form-Encoded Requests: Easily send requests in a widely-used, structured format.

  • JSON-Encoded Responses: Receive responses in a universally compatible and readable JSON format.

hashtag
Getting Started is Easy!

Quick-Start Guides: Ready to dive in? If you're keen to get started right away, our quick-start guides are the perfect place to begin. Make your first API request and see the immediate results:

Comprehensive API Reference: Looking for detailed information? Our comprehensive API reference provides an in-depth look at all the functionalities and possibilities of the Fusionbase API. Explore at your own pace and discover everything our API offers:

hashtag
We're Here to Help

Have questions or need some guidance? We're here to assist you every step of the way. Feel free to reach out to our support team for any inquiries or assistance you might need:

hashtag
Let's Start Your Data Journey!

Whether you're just beginning or ready to deep dive into complex data tasks, Fusionbase is here to make your data journey enjoyable and successful. Explore, integrate, and transform data like never before with Fusionbase API.

Standard Protocols: Rely on conventional HTTP response codes, authentication methods, and verbs for a seamless integration.

Quick-Start Documentation
API Reference Documentation
Contact Supportenvelope
Fusionbase Dataarrow-up-right
API Keys Managementarrow-up-right
Code Snippets Section
support emailenvelope
https://api.fusionbase.com/api/v2
https://api.fusionbase.com/api/v2/stream/data/[Stream ID]

Search

Master the Fusionbase Data Hub Search API with our concise guide. Detailed instructions and examples ensure easy integration and powerful search use.

The Fusionbase Data Hub Search API is tailored for developers seeking to harness a wealth of data for various applications. This robust API simplifies access to a diverse range of data entities, each offering unique insights and opportunities for integration:

  1. Data Streams: Access real-time and historical datasets encompassing areas like statistics, environmental data, and public records. Ideal for applications in analytics, trend monitoring, and data-driven decision-making.

  2. Data Services: Discover APIs and services for data processing and analytics. These services are crucial for enhancing data quality, interpretation, and application in your projects.

  3. Organizations: Explore detailed information about companies, going beyond mere registry data to include insights into business operations, market presence, and industry standing. This entity is invaluable for market analysis, competitive intelligence, and B2B solutions.

  4. Persons: Access official records of individuals in professional contexts, specifically those associated with organizations. This data is essential for network analysis, professional background checks, and organizational research.

  5. Locations: Utilize comprehensive geographical and locational data, useful for mapping, logistics planning, and geographical analysis.

  6. Relations: Investigate the connections between different entities, providing a deeper understanding of organizational networks, geographical correlations, and data context.

Search Endpoints:

  • Fusion Search Endpoint: An AI-driven, comprehensive search across all entities, ideal for broad queries where user intent is analyzed and results are ranked accordingly. This endpoint is particularly useful when the search context is not entity-specific and a holistic view is desired.

Entity-Specific Endpoints:

  1. Streams and Services Endpoint: Focuses on datasets and data-related services, suitable for applications needing specific data types or analytics services.

  2. Organizations Endpoint: Dedicated to detailed company information, perfect for business intelligence and market research.

  3. Persons Endpoint: Targets professional profiles and official records, ideal for background checks and professional network analysis.

Practical Application and Integration:

As a developer, you can expect the Fusionbase Data Hub Search API to be a reliable and comprehensive source for various types of data. Whether your project involves creating sophisticated market analysis tools, developing rich data visualizations, or integrating background information into professional networking platforms, this API provides the necessary data foundation.

The Fusionbase Data Hub is designed with the developer in mind, ensuring ease of integration, consistent data quality, and a wide range of data types to meet diverse application needs. By incorporating this API into your projects, you can significantly enhance your application's capabilities, offering users deeper insights and more valuable experiences.

Projections

This section of the API allows users to retrieve specific fields from a dataset. The project_fields parameter is used to specify which fields should be returned in the response. This can optimize the

hashtag
Projections

GET https://api.fusionbase.com/api/v2/stream/data/{STREAM_ID}?format=json&query_parameters={ "project_fields": ["FIELD_NAME"]}

If you are only interested in a subset of columns in a Data Stream you can project them. Therefore, the result set does not contain any additional columns. Specifically, in cases when the Data Stream has a large number of columns, this can significantly speed up the retrieval performance.

Getting a Stream

The Fusionbase API provides streamlined access to data streams, offering specialized endpoints for retrieving metadata, querying data, and conducting string searches within the data. Access to these features is achieved through authenticated GET requests.

circle-info

The base URL is always https://api.fusionbase.com

hashtag

Entities

Fusionbase Data Hub focuses on four main entities: ORGANIZATION, PERSON, EVENT, and LOCATION, each with dedicated APIs for accessing structured information efficiently.

Fusionbase Data Hub is structured around key data entities, providing specialized APIs to access structured data for each entity type. The primary entities are ORGANIZATION, PERSON, EVENT, and LOCATION.

hashtag
Organizations

Represents a structured profile of a company or institution. The data for an ORGANIZATION includes essential information such as the company name, location and industry (if applicable). It may also cover legal status, history, and various operational aspects. The API for ORGANIZATION entities is designed to offer comprehensive insights into businesses and institutions, making it valuable for market research, business intelligence, and due diligence processes.

Location Endpoint: For location-specific searches, offering detailed geographical data.

  • Relations Endpoint: Explores inter-entity connections, enhancing data context and network understanding.

  • hashtag
    Person

    Encompasses detailed information about individuals involved and related to organizations. The PERSON API is crucial for gaining insights into understanding personal networks and organizational roles. Person data is based on publicly available business registry data.

    hashtag
    Event

    Focuses on specific occurrences or happenings, either historical or current. EVENT data includes information about the time, location, participants, and nature of the event. This can range from business events like product launches and corporate meetings to broader occurrences such as political elections or natural disasters. The EVENT API aids in understanding the context and impact of significant happenings and in tracking upcoming or ongoing events.

    hashtag
    Location

    Involves detailed data about geographical places or addresses. LOCATION data can include coordinates, physical address details, and descriptive information about the place (e.g., type of location). The LOCATION API is valuable for geographic analysis. The Location search can also be used as a geocoding service.

    hashtag
    Path Parameters

    Name
    Type
    Description

    STREAM_ID

    String

    The ID of the Data Stream

    hashtag
    Query Parameters

    Name
    Type
    Description

    query_parameters

    List

    The name of the projected columns, i.e. the fields that should exist in the result set

    format

    String

    json or msgpack

    hashtag
    Request Structure

    To project fields in your data retrieval, use the project_fields parameter within the query_parameters in your GET request to /api/v2/stream/data/{STREAM_ID}. The project_fields parameter should be formatted as a JSON array of strings representing the field names.

    hashtag
    Project Fields Properties

    • project_fields: An array of string values where each string represents the name of a field that you want to include in the response.

    hashtag
    Multiple Field Projection

    You can project multiple fields in a single request. Include all desired field names as strings in the project_fields array.

    hashtag
    Example

    For instance, if you wish to retrieve only the manufacturer_brand field from a data stream, your request would be structured as follows:

    hashtag
    Notes

    • Ensure that the field names used in project_fields correspond to valid column names in the data stream.

    • The field names in project_fields are case-sensitive and should match the exact casing of the column names in the data stream.

    hashtag
    Error Handling

    Errors may occur if the project_fields criteria are not correctly structured, if invalid field names are used, or if there is a syntax error in the request. In such cases, the API might return an error response.

    This approach to documenting the 'Project Fields' feature mirrors the structure and detail provided in your example for using filters, ensuring consistency in the API documentation style.

    Endpoints
    1. Metadata Retrieval

      • Endpoint: /api/v2/stream/base/{STREAM_ID}

      • Purpose: Retrieves metadata for data streams.

    2. Data Retrieval and Querying

      • Endpoint: /api/v2/stream/data/{STREAM_ID}

      • Purpose: Retrieves and queries data from a specified data stream.

    3. String Search within Data

      • Endpoint: /api/v2/stream/data/search/{STREAM_ID}

      • Purpose: Performs string searches within a specified data stream.

    hashtag
    Basic Request Structure

    To retrieve data from a stream without specific queries, the API endpoint URL is structured as follows:

    hashtag
    URL Components

    The URL is composed of the following elements:

    • Base URL: {{base_api_url}}/api/

    • Resource Path: This varies based on the operation, such as /stream/base, /stream/data/{STREAM_ID}, or /stream/data/search/{STREAM_ID}.

    • Query Parameters: ?[QUERY_PARAMETERS], used for specifying details like pagination, sorting, and filtering.

    hashtag
    Example

    A typical request to retrieve data from a stream looks like this:

    This request fetches data from the stream with ID 403398, skipping 0 records, limiting to 10 records, and sorting the results by fb_datetime in descending order.

    circle-exclamation

    Limited access to a Data Stream may result in receiving only a restricted number of records, such as 10 records.

    hashtag
    Query Parameters

    The API supports a variety of filter and query parameters to customize the result set according to user requirements. These parameters include options for basic query operations and can be combined in a single request for comprehensive data retrieval.

    /api/v2/stream/data/{STREAM_ID}?query_parameters={"project_fields": ["manufacturer_brand"]}&format=json
    /api/v2/stream/data/{STREAM_ID}?skip=0&limit=10&sort_keys=fb_datetime&sort_order=desc
    /api/v2/stream/data/403398?skip=0&limit=10&sort_keys=fb_datetime&sort_order=desc

    Sorting

    The Data Stream can be sorted by any column in ascending or descending order. Sorting by multiple columns at once is also possible.

    hashtag
    Sorting

    GET https://api.fusionbase.com/api/v2/stream/data/{STREAM_ID}?query_parameters={"sort_order": ["asc"], "sort_keys": ["fb_datetime"]}&format=json

    The Data Stream can be sorted by any column in ascending or descending order. Sorting by multiple columns at once is also possible.

    Data Versions

    The Fusionbase API offers a sophisticated mechanism for retrieving entries based on their version. This is particularly useful for accessing data that is newer than a specific version or within a range of versions. The version_boundary parameter in the API request facilitates this functionality.

    Let's assume a Data Stream is updated five times a day and you decide to pull the data just once a day. To get all of the newly added records from your local version up to the most recent version of the Data Stream, simply use the delta endpoint.

    hashtag
    Get records from a certain version

    Person

    Discover the professional world – delve into detailed profiles and connections with Fusionbase's Person Search.

    The Person Search Endpoint is a specialized tool designed for retrieving detailed personal profiles from official business registry sources. This powerful endpoint is essential for applications requiring in-depth information about individuals, particularly in business contexts, such as their roles in organizations, location, and professional relationships. It is a valuable resource for developers building applications for business intelligence, network analysis, or compliance purposes.

    hashtag
    Example: Using the Person Search Endpoint

    To search for an individual, a GET request is made to the Person Search Endpoint. This endpoint accepts the person's name or other identifiers as query parameters. It returns a JSON object with comprehensive personal data, extracted exclusively from official business registry sources.

    GET https://api.fusionbase.com/api/v2/stream/data/{STREAM_ID}?version_boundary={FB_DATA_VERSION}&format=json

    Get the data of a given Data stream since a specified version

    hashtag
    Path Parameters

    Name
    Type
    Description

    STREAM_ID*

    String

    The ID of the Data Stream

    hashtag
    Query Parameters

    Name
    Type
    Description

    version_boundary

    String

    A string or a pair of comma-separated strings representing version IDs.

    format

    String

    json or msgpack

    hashtag
    Request Structure

    To filter data based on version, utilize the version_boundary parameter in your GET request to /api/v2/stream/data/{STREAM_ID}. This parameter can be set to a single version ID or two version IDs separated by a comma, indicating a range.

    hashtag
    Version Boundary Properties

    • version_boundary: A string or a pair of comma-separated strings representing version IDs.

      • Single Version: Retrieves entries newer than the specified version.

      • Two Versions: Retrieves all entries between the two provided versions (inclusive).

    hashtag
    Examples

    1. Single Version Filter To retrieve entries newer than a specific version:

      This request returns entries that are newer than the version bd764e07-50a1-4c0e-a102-ae1a259557av.

    2. Range of Versions Filter To retrieve entries within a specific range of versions:

      Replace version1ID and version2ID with the desired start and end versions. This request returns all entries between these two versions.

    hashtag
    Notes

    • Ensure that the version IDs used are valid and correspond to the versions in the data stream.

    • The version IDs are case-sensitive and should be used exactly as they appear in the data stream.

    hashtag
    Error Handling

    Errors may occur if the version_boundary parameter is not properly structured, if invalid version IDs are used, or if there is a syntax error in the request. In such cases, the API might return an error response.

    This documentation provides clear instructions on how to use the version_boundary parameter for filtering data by version, with examples for both single version filtering and range filtering.

    Request Example:

    It is important to URL encode the query parameter to ensure proper request formatting.

    hashtag
    Expected Response:

    The API response is a JSON object with an array under the results key, where each entry represents a person entity. The response includes detailed personal information such as the Fusionbase entity ID, name, location, organizational affiliations, and more.

    Here’s a simplified example based on the provided response:

    hashtag
    Breakdown of Response Structure:

    • results: An array of person entities matching the search query.

    • entity_type: Specifies the type of the entity, here "PERSON".

    • entity: Contains the detailed information about the person.

      • fb_entity_id: A unique identifier for the person within the Fusionbase Data Hub.

      • name: The individual’s name, including given and family names.

      • locations: Information about the person's location, such as home address.

      • relations: Details of the individual’s affiliations or roles in organizations, including position labels and related organization details.

      • source_id: The source identifier from which the data is derived.

    • score: A relevance score for the search result.

    The Person Search Endpoint is a powerful tool for developers to access rich, verified personal data. The unique fb_entity_id enables developers to reference specific individuals consistently within the Fusionbase ecosystem. This capability is crucial for applications that require tracking of individual profiles over time, understanding their business network, or conducting due diligence. The endpoint's comprehensive data set provides a solid foundation for sophisticated applications requiring reliable and detailed personal information.

    /api/v2/stream/data/{STREAM_ID}?version_boundary=bd764e07-50a1-4c0e-a102-ae1a259557av&format=json
    /api/v2/stream/data/{STREAM_ID}?version_boundary=version1ID,version2ID&format=json
    https://api.fusionbase.com/api/v2/search/entities/person?q=Kevin%20Goßling
    {
        "results": [
            {
                "entity_type": "PERSON",
                "entity": {
                    "fb_entity_id": "8e03af05947fdff52a182084b5ce0a24",
                    "entity_type": "PERSON",
                    "entity_subtype": "INDIVIDUAL",
                    "name": {
                        "given": "Kevin",
                        "family": "Goßling"
                    },
                    "locations": {
                        "home": {
                            "formatted_address": "Munich, Germany"
                        }
                    },
                    "relations": {
                        "ORGANIZATION": [
                            {
                                "label": "MANAGING_DIRECTOR",
                                "entity_to": {
                                    "fb_entity_id": "ff525267e6ff5f67a6dbe0af29b7e5cc",
                                    "display_name": "Fusionbase GmbH"
                                },
                                "meta": {
                                    "start_date": "2019-10-24"
                                }
                            }
                        ]
                    },
                    "source_id": "data_sources/1051122944"
                },
                "score": 19.639364
            }
        ],
        "total": 1
    }
    
    hashtag
    Path Parameters
    Name
    Type
    Description

    STREAM_ID

    String

    The ID of the Data Stream

    hashtag
    Query Parameters

    Name
    Type
    Description

    query_parameters

    Object

    URI encoded JSON string

    format

    String

    json or msgpack

    This is a sample response for a specific stream:

    [
            {
                "fb_id": 
    

    hashtag
    Overview

    The Fusionbase API allows users to sort data within a stream using the query_parameters parameter in the request. This feature enables efficient organization and retrieval of data based on specific sorting criteria.

    hashtag
    Sorting Data in a Stream

    hashtag
    Request Structure

    To sort data in a stream, include the query_parameters parameter in your GET request to /api/v2/stream/data/{STREAM_ID}. This parameter accepts JSON-formatted sorting instructions.

    hashtag
    Sorting Properties

    The query_parameters JSON object can contain the following properties related to sorting:

    • sort_keys: A list of column names by which the data should be sorted. These keys should correspond to columns in the data stream.

    • sort_order: Specifies the sorting order for each key in sort_keys. The available options are "asc" for ascending order and "desc" for descending order.

    hashtag
    Multiple Sorting Keys

    You can specify multiple sort keys in the sort_keys list. The data will be sorted based on the order of keys provided. The corresponding sort_order list should match the length of sort_keys to specify the sorting order for each key.

    hashtag
    Example

    Consider a data stream with columns such as fb_datetime, price, and product_name. To sort the data first by fb_datetime in ascending order and then by price in descending order, structure your request as follows:

    hashtag
    Note

    • The sorting functionality is dependent on the structure of the data stream.

    • Ensure that the column names used in sort_keys are valid and present in the data stream.

    • The order of elements in sort_keys and sort_order is significant and should correspond to each other.

    hashtag
    Error Handling

    If invalid column names are used or if there's a mismatch in the length of sort_keys and sort_order, the API might return an error response.

    Authentication

    API requests are authenticated using API keys which are sent via the custom X-API-KEY header. Any request that doesn't include an API key will return an authentication error.

    You can view and manage your API keys at the page in your Fusionbase account.

    All API requests must be made over HTTPS. Calls made over plain HTTP will be redirected to HTTPS. API requests without authentication will fail.

    circle-exclamation

    Filter Queries

    The actual values of a Data Stream can be queried and filtered using the query parameter. This allows for the selection of a subset of the data based on the records values.

    hashtag
    Filter the data stream

    GET https://api.fusionbase.com/api/v2/stream/data/{STREAM_ID]?query_parameters={"filters": [{"property": "construction_year_end", "operator": "GREATER_THAN", "value": 2013}]}&format=json

    The actual values of a Data Stream can be queried and filtered using the

    Pagination

    Some Data Streams are too large to get all the records via the API in a single call. In such cases, the API lets you paginate the results via the skip and limit parameters.

    hashtag
    Pagination

    GET https://api.fusionbase.com/api/v2/stream/data/{STREAM_ID}?skip=0&limit=2&format=json

    Some Data Streams are too large to get all the records via the API in a single call. In such cases the API lets you paginate the results via the skip

    Location Search and Geocoding

    Pinpoint Precision: Explore and Geocode with Ease

    The Location Search Endpoint is your comprehensive solution for place searches and address geocoding, akin to the functionality of Google Maps Places Search. Whether you're plotting points of interest or transforming addresses into coordinated data, this endpoint delivers accurate, map-ready results. It's the developer's tool of choice for creating location-aware applications with high precision and reliability.

    hashtag
    Example: Using the Location Search Endpoint for Geocoding

    To geocode an address such as "Agnes-Pockels-Bogen 1, 80992 München", you would make a GET request to the Location Search Endpoint. The endpoint takes the address as a query parameter and returns a JSON object with the geocoded location details, including latitude and longitude coordinates.

    Relations

    Map the web of connections – Fusionbase's Relations Endpoint unveils the intricate network of relationships between entities and data features.

    The Relations Endpoint is a powerful feature of Fusionbase API, designed to resolve and map the complex web of relationships between various entities and data features. This endpoint is particularly useful for understanding the network of connections surrounding an entity, be it a person or an organization. It is an invaluable tool for applications focusing on network analysis, relationship mapping, and comprehensive data linkage.

    hashtag
    Example: Using the Relations Endpoint

    To resolve relations for a specific entity, a POST request is made to the Relations Endpoint with the relation ID and entity ID. This endpoint efficiently maps the network of connections related to the given entity, providing insights into their professional and organizational links.

    Organization

    Navigate the corporate landscape – uncover comprehensive organizational data with Fusionbase's Organization Search.

    The Organization Search Endpoint is a dynamic solution for searching organizational data and extracting specific business information. This endpoint is ideal for applications requiring detailed information about various organizations. It provides robust data for developers building applications that require comprehensive business information, such as company names, statuses, addresses, and registration details.

    hashtag
    Example: Using the Organization Search Endpoint

    To search for an organization, a GET request is made to the Organization Search Endpoint. The endpoint accepts the organization's name or other identifying details as query parameters. In response, it returns a JSON object containing detailed information about the organization, including its status, address, registration details, and more.

    /api/v2/stream/data/{STREAM_ID}?query_parameters={"sort_keys": ["fb_datetime", "price"], "sort_order": ["asc", "desc"]}&format=json
    "
    31f72e92f33bcfb39ad100d8b981c9ac
    "
    ,
    "kba_reference_number": "011209",
    "manufacturer_recall_code": "NC3I6515R (0797186)",
    "manufacturer_brand": "MERCEDES-BENZ LKW",
    "trade_name": "SPRINTER",
    "construction_year_start": 2011,
    "construction_year_end": 2013,
    "affected_vehicles_worldwide": 5799.0,
    "affected_vehicles_germany": 3368.0,
    "recall_supervised_by_kba": "supervised",
    "recall_description": "Entfernung unzulässiger Abschalteinrichtungen bzw. der unzulässigen Reduzierung der Wirksamkeit des Emissionskontrollsystems.",
    "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
    "remedial_action_by_the_manufacturer": "Software Steuergeräte aktualisieren.",
    "known_incidents": "unknown",
    "release_date": "2021-10-25",
    "support_hotline": "06986798274",
    "fb_datetime": "2023-06-16T10:41:28.220000",
    "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
    },
    {
    "fb_id": "e8ffe1c04bc7f094520a13921e018579",
    "kba_reference_number": "011713",
    "manufacturer_recall_code": "30_2028161",
    "manufacturer_brand": "KTM",
    "trade_name": "125 SX, 125 XC, 150 SX",
    "construction_year_start": 2021,
    "construction_year_end": 2022,
    "affected_vehicles_worldwide": 5806.0,
    "affected_vehicles_germany": 104.0,
    "recall_supervised_by_kba": "supervised",
    "recall_description": "Defektes Zündsteuergerät führt zum Bruch des Pleuels. Es besteht erhöhte Sturzgefahr.",
    "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
    "remedial_action_by_the_manufacturer": "Austausch des Zündsteuergeräts.",
    "known_incidents": "Es sind derzeit 2 Schadenereignisse mit Unfallfolge oder Personenschäden bekannt.",
    "release_date": "2022-07-11",
    "support_hotline": "0962892110",
    "fb_datetime": "2023-06-16T10:41:28.220000",
    "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
    }
    ]

    Request Example:

    Make sure to URL encode the query parameter to ensure the request is properly formatted.

    Expected Response:

    The API's response will be a JSON object containing an array under the results key. Each entry in this array corresponds to a found location. For the provided address, the response includes the Fusionbase entity ID, creation and update timestamps, the entity version, and external identifiers such as OpenStreetMap data. Most importantly, it contains the coordinate object with latitude and longitude keys, providing the precise geocoded location.

    Here's a structured example based on the provided response:

    The search result from the Fusionbase Location Search Endpoint provides a structured JSON object containing detailed information about the queried location. Here's how the result is organized and how it can be utilized:

    1. results: This is an array that contains one or more location entities that match the search query. In the provided example, there is one matching location entity for the address "Agnes-Pockels-Bogen 1, 80992 München".

    2. entity: Within each item in the results array, the entity object holds the data for thelocation. This includes unique identifiers, timestamps, and structured location information.

    3. fb_entity_id: This is a crucial element as it uniquely identifies the location within the Fusionbase Data Hub. It's used to reference this specific location in subsequent API calls or to cross-reference within the Fusionbase ecosystem.

    4. coordinate: The latitude and longitude values provide the geocoded coordinates of the address, which can be used for placing markers on a map, calculating distances, or other geospatial operations.

    5. address_components: This array breaks down the address into individual components such as house_number, street, postal_code, city, state, and country. This granular information is useful for applications that need to process or display parts of an address separately.

    6. formatted_address: A human-readable address string that combines all address components, suitable for display purposes.

    The fb_entity_id is a key identifier that developers can utilize to maintain a durable reference to a specific location. It allows for the retrieval of extended details and facilitates the execution of further operations, such as resolving relations for the given location within the Fusionbase Data Hub. By leveraging this ID, developers can access related statistical indicators like household income, demographic distributions, or other socio-economic data points associated with that location, thus providing a richer and more detailed data narrative for applications and analyses.

    Request Example:

    Remember to URL encode the query parameter for proper request formatting.

    hashtag
    Expected Response:

    The API returns a JSON object containing an array under the results key, each entry corresponding to a found organization. For a given query, the response includes details like the Fusionbase entity ID, organization status, address, and registration authority.

    Here’s a simplified example based on the provided response:

    hashtag
    Breakdown of Response Structure:

    • results: Contains an array of organization entities matching the search query.

    • entity_type: Indicates the type of the entity, here "ORGANIZATION".

    • entity: Contains detailed information about the organization.

      • fb_entity_id: A unique identifier for the organization within Fusionbase Data Hub.

      • status: Indicates the current status of the organization (e.g., Active, Inactive).

      • display_address: The public address of the organization.

      • registration_authority_entity_name: The name of the authority under which the organization is registered.

      • display_name: The public name of the organization.

      • name: Official registered name of the organization.

      • source_key: A unique key from the data source.

    • score: A relevance score for the search result.

    The fb_entity_id is vital for developers as it allows for consistent referencing of a specific organization within the Fusionbase ecosystem. This unique ID enables the retrieval of more detailed information and supports various operations, such as tracking changes in the organization's status or retrieving related financial or operational data. By leveraging this ID, developers can access a wealth of information to enrich their applications and analyses with in-depth organizational data.

    https://api.fusionbase.com/api/v2/search/entities/location?q=Agnes-Pockels-Bogen%201,%2080992%20München
    {
        "results": [
            {
                "entity": {
                    "fb_entity_id": "45d488830421ebc1d9130cc0856b3c5d",
                    "fb_datetime": "2023-12-18T16:17:53.570000",
                    "fb_entity_version": "9cefd42e59f49e3de4b0b33f983b740c",
                    "entity_type": "LOCATION",
                    "updated_at": "2023-12-18T16:17:53.570000",
                    "created_at": "2023-11-09T16:17:51.381000",
                    "external_ids": {
                        "nominatim": {
                            "osm_id": 1787145076,
                            "osm_type": "node",
                            "class": "amenity"
                        }
                    },
                    "coordinate": {
                        "latitude": 48.1735835,
                        "longitude": 11.5323446
                    },
                    "location_level": null,
                    "address_components": [
                        {
                            "component_type": "house_number",
                            "component_value": "1"
                        },
                        {
                            "component_type": "street",
                            "component_value": "Agnes-Pockels-Bogen"
                        },
                        {
                            "component_type": "postal_code",
                            "component_value": "80992"
                        },
                        {
                            "component_type": "city",
                            "component_value": "Munich"
                        },
                        {
                            "component_type": "state",
                            "component_value": "Bavaria"
                        },
                        {
                            "component_type": "country",
                            "component_value": "Germany"
                        }
                    ],
                    "alternative_names": [],
                    "fb_semantic_id": "location|locality:germany:bavaria:80992:munich:agnes-pockels-bogen:1",
                    "formatted_address": "Agnes-Pockels-Bogen 1, 80992 Munich, Germany"
                },
                "entity_type": "LOCATION"
            }
        ]
    }
    https://api.fusionbase.com/api/v2/search/entities/organization?q=OroraTech%20GmbH
    {
        "results": [
            {
                "entity_type": "ORGANIZATION",
                "entity": {
                    "fb_entity_id": "82a68ab9f7151fa0af9bf189c1caa753",
                    "status": "ACTIVE",
                    "display_address": "Sankt-Martin-Straße 112, 81669 Munich, Germany",
                    "registration_authority_entity_name": "München HRB 243843",
                    "display_name": "OroraTech GmbH",
                    "name": "OroraTech GmbH",
                    "source_key": "1051122944"
                },
                "score": 40.53212
            },
            {
                "entity_type": "ORGANIZATION",
                "entity": {
                    "fb_entity_id": "64ab4b0ada714a56939c70f5e8a62e8a",
                    "status": "ACTIVE",
                    "display_address": "Birkenweg, 15834 Rangsdorf, Germany",
                    "registration_authority_entity_name": "Potsdam HRB 15953",
                    "display_name": "FloraTech GmbH",
                    "name": "FloraTech GmbH",
                    "source_key": "1051122944"
                },
                "score": 14.997058
            }
        ],
        "total": 10
    }
    
    Your API keys carry many privileges, so be sure to keep them secure! Do not share your secret API keys in publicly accessible areas such as GitHub, client-side code, and so forth.

    hashtag
    Creating API Keys

    Go to your account profile arrow-up-rightand press the Add API Key button.

    triangle-exclamation

    Do never disclose your API key publicly.

    hashtag
    Authenticate Requests

    The API key is added via the x-api-key property in the request header.

    profile settingsarrow-up-right
    filters
    parameter in
    query_parameters
    . This allows for the selection of a subset of the data based on the records values.

    hashtag
    Path Parameters

    Name
    Type
    Description

    STREAM_ID*

    String

    The ID of the Data Stream

    hashtag
    Query Parameters

    Name
    Type
    Description

    query_parameters

    Object

    URI encoded JSON string

    format

    String

    json or msgpack

    This is a sample response for a specific stream:

    [
            {
                "fb_id": 
    

    The Fusionbase API offers a powerful filtering capability to refine and narrow down the data retrieved from a data stream. This is achieved using the filters parameter within the query_parameters in your request.

    hashtag
    Using Filters in Data Streams

    hashtag
    Request Structure

    To apply filters to your data retrieval, include the filters parameter within the query_parameters in your GET request to /api/v2/stream/data/{STREAM_ID}. The filters parameter should be formatted as a JSON object.

    hashtag
    Filter Properties

    The filters JSON object comprises an array of filter objects, each containing the following properties:

    • property: The column name in the data stream that you want to filter on.

    • operator: The operation to be used for filtering. Common operators include EQUALS, GREATER_THAN, LESS_THAN, etc.

    • value: The value to compare against the column data.

    hashtag
    Multiple Filters

    You can apply multiple filters within the same request. Each filter in the array applies to the specified property independently.

    hashtag
    Example

    Suppose you want to filter a data stream to include records where the construction_year_end is later than 2013. The request would be structured as follows:

    hashtag
    Notes

    • Ensure that the property names used in filters correspond to valid column names in the data stream.

    • The filter's value should be appropriate for the property's data type (e.g., numeric, string, date).

    • Filters are case-sensitive and should match the exact casing of column names and operators.

    hashtag
    Error Handling

    Errors may occur if the filter criteria are not properly structured, if invalid column names are used, or if there is a data type mismatch. In such cases, the API might return an error response.

    circle-info

    Make sure to properly URL encode the query parameters!

    and
    limit
    parameters.

    hashtag
    Path Parameters

    Name
    Type
    Description

    STREAM_ID*

    String

    The ID of the Data Stream

    hashtag
    Query Parameters

    Name
    Type
    Description

    skip

    Integer

    Indicates the number of records that should be skipped from the beginning of the Data Stream.

    limit

    Integer

    Indicates the number of records that are retrieved in the result set.

    This is a sample data response, the response is always a list of dicts. If format is not explicitly specified, the default response format is msgpack.

    [
            {
                "fb_id": 
    

    hashtag
    Understanding skip and limit Parameters

    When querying a data stream, you can control the subset of records you retrieve by using skip and limit parameters. These parameters are crucial for pagination and managing large datasets.

    • skip Parameter: This parameter defines the number of records to skip before starting to collect the result set. It is used to bypass a specific number of entries at the beginning of the data stream. For example, skip=10 means the first 10 records in the data stream will be skipped.

    • limit Parameter: This parameter specifies the maximum number of records to include in the result set. It effectively limits the size of your data retrieval. For instance, limit=10 means only 10 records will be retrieved after applying the skip parameter.

    hashtag
    Example

    Consider a data stream containing a sequence of records represented by numbers:

    [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,...]

    Applying the query parameters ?skip=10&limit=10:

    1. Skip: The first 10 records (1 to 10) are skipped.

    2. Limit: The next 10 records after the skipped ones are included in the result set. These are records 11 to 20.

    So, the resulting dataset retrieved with these parameters will be:

    [11,12,13,14,15,16,17,18,19,20]

    These parameters are particularly useful in scenarios where you need to handle large volumes of data, allowing for efficient data access and reducing the load on both the server and client sides.

    Request Example:

    Let's take 3138484719 as the relation ID and 75e8887e25587ed64cc8e1733a6c7160 as the entity ID to execute a sample request.

    The relation with ID is the "Network" relation, showing all connected other entities,

    hashtag
    Expected Response:

    The API response is a JSON array, where each object represents a relationship linked to the queried entity. It includes details about the entities involved, the type of relationship, and relevant metadata.

    Here’s a simplified example based on the provided response:

    hashtag
    Breakdown of Response Structure:

    • label: Describes the type of relationship.

    • entity_from: The originating entity of the relation.

    • entity: Contains the details of the relationship and linked entities.

      • entity_type & entity_subtype: Specify the type and subtype of the entity.

      • fb_semantic_id: A unique identifier for the relationship feature.

      • value: An object containing details about the root entity and its links.

        • root: The primary entity from which the network originates.

        • links: An array of related entities and their respective relationships.

    The Relations Endpoint offers a detailed and comprehensive view of the networks surrounding an entity, providing crucial insights for businesses and researchers. By mapping out these relationships, the endpoint aids in understanding complex organizational structures, professional networks, and the dynamics of business ecosystems.

    Location

    Location entities offer precise and structured geographical information

    The /api/v2/entities/location/get/{FB_ENTITY_ID} endpoint in the Fusionbase API provides structured information about specific locations. This endpoint is crucial for accessing detailed and structured data about locations using their unique Fusionbase Entity ID (FB_ENTITY_ID).

    hashtag
    Request Header

    curl -X GET "https://api.fusionbase.com/api/v2/stream/base/430410" \
    -H 'X-API-KEY: 'YOUR_API_KEY \
    -H 'Content-Type: application/json; charset=utf-8' \
    
    import requests
    
    url = "https://api.fusionbase.com/api/v2/stream/base/430410"
    headers = {
        'X-API-KEY': 'YOUR_API_KEY',
        'Content-Type': 'application/json; charset=utf-8',
    }
    
    response = requests.get(url, headers=headers)
    print(response.json())
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.URL;
    
    public class Main {
        public static void main(String[] args) throws Exception {
            URL url = new URL("https://api.fusionbase.com/api/v2/stream/base/430410");
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setRequestMethod("GET");
            con.setRequestProperty("X-API-KEY", "YOUR_API_KEY");
            con.setRequestProperty("Content-Type", "application/json; charset=utf-8");
    
            BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String inputLine;
            StringBuffer content = new StringBuffer();
            while ((inputLine = in.readLine()) != null) {
                content.append(inputLine);
            }
            in.close();
            con.disconnect();
            
            System.out.println(content.toString());
        }
    }
    package main
    
    import (
        "fmt"
        "net/http"
        "io/ioutil"
    )
    
    func main() {
        url := "https://api.fusionbase.com/api/v2/stream/base/430410"
        req, _ := http.NewRequest("GET", url, nil)
    
        req.Header.Add("X-API-KEY", "YOUR_API_KEY")
        req.Header.Add("Content-Type", "application/json; charset=utf-8")
    
        res, _ := http.DefaultClient.Do(req)
        defer res.Body.Close()
        body, _ := ioutil.ReadAll(res.Body)
    
        fmt.Println(string(body))
    }
    const axios = require('axios');
    
    axios.get('https://api.fusionbase.com/api/v2/stream/base/430410', {
        headers: {
            'X-API-KEY': 'YOUR_API_KEY',
            'Content-Type': 'application/json; charset=utf-8'
        }
    })
    .then((response) => {
        console.log(response.data);
    })
    .catch((error) => {
        console.error(error);
    });
    <?php
    
    $curl = curl_init();
    
    curl_setopt_array($curl, [
        CURLOPT_URL => "https://api.fusionbase.com/api/v2/stream/base/430410",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST => "GET",
        CURLOPT_HTTPHEADER => [
            "X-API-KEY: YOUR_API_KEY",
            "Content-Type: application/json; charset=utf-8"
        ],
    ]);
    
    $response = curl_exec($curl);
    
    curl_close($curl);
    echo $response;
    ?>
    /api/v2/stream/data/{STREAM_ID}?query_parameters={"filters": [{"property": "construction_year_end", "operator": "GREATER_THAN", "value": 2013}]}&format=json
    POST https://api.fusionbase.com/api/v2/relation/resolve/<RELATION_ID>/<ENTITY_ID>
    [
        {
            "label": "ENTITY_NETWORK",
            "entity_from": {
                "fb_entity_id": "75e8887e25587ed64cc8e1733a6c7160",
                "entity_type": "ORGANIZATION",
                "display_name": "ADOS GmbH"
            },
            "entity": {
                "entity_type": "FEATURE",
                "entity_subtype": "NETWORK",
                "fb_semantic_id": "feature|network|organization:75e8887e25587ed64cc8e1733a6c7160",
                "value": {
                    "root": {
                        "fb_entity_id": "75e8887e25587ed64cc8e1733a6c7160",
                        "entity_type": "ORGANIZATION",
                        "display_name": "ADOS GmbH"
                    },
                    "links": [
                        {
                            "depth": 1,
                            "relation_id": "135ff9ab592bb1b41ab948b3ad95f91f",
                            "label": "MANAGING_DIRECTOR",
                            "entity_from": {
                                "fb_entity_id": "8a00ab6520e0b64eb83345586ba1613e",
                                "entity_type": "PERSON",
                                "display_name": "Herbert Rütgers"
                            },
                            "entity_to": {
                                "fb_entity_id": "75e8887e25587ed64cc8e1733a6c7160",
                                "entity_type": "ORGANIZATION",
                                "display_name": "ADOS GmbH"
                            },
                            "meta": {
                                "start_date": "2002-06-03",
                                "end_date": "2020-07-06"
                            }
                        }
                        // Additional links omitted for brevity
                    ]
                }
            }
        }
    ]
    

    depth: Indicates the level of connection relative to the root entity.

  • relation_id: A unique identifier for the specific relationship.

  • label: The label describing the nature of the relationship (e.g., MANAGING_DIRECTOR).

  • entity_from & entity_to: The entities involved in the relationship.

  • meta: Metadata about the relationship, such as start and end dates.

  • "
    31f72e92f33bcfb39ad100d8b981c9ac
    "
    ,
    "kba_reference_number": "011209",
    "manufacturer_recall_code": "NC3I6515R (0797186)",
    "manufacturer_brand": "MERCEDES-BENZ LKW",
    "trade_name": "SPRINTER",
    "construction_year_start": 2011,
    "construction_year_end": 2013,
    "affected_vehicles_worldwide": 5799.0,
    "affected_vehicles_germany": 3368.0,
    "recall_supervised_by_kba": "supervised",
    "recall_description": "Entfernung unzulässiger Abschalteinrichtungen bzw. der unzulässigen Reduzierung der Wirksamkeit des Emissionskontrollsystems.",
    "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
    "remedial_action_by_the_manufacturer": "Software Steuergeräte aktualisieren.",
    "known_incidents": "unknown",
    "release_date": "2021-10-25",
    "support_hotline": "06986798274",
    "fb_datetime": "2023-06-16T10:41:28.220000",
    "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
    },
    {
    "fb_id": "e8ffe1c04bc7f094520a13921e018579",
    "kba_reference_number": "011713",
    "manufacturer_recall_code": "30_2028161",
    "manufacturer_brand": "KTM",
    "trade_name": "125 SX, 125 XC, 150 SX",
    "construction_year_start": 2021,
    "construction_year_end": 2022,
    "affected_vehicles_worldwide": 5806.0,
    "affected_vehicles_germany": 104.0,
    "recall_supervised_by_kba": "supervised",
    "recall_description": "Defektes Zündsteuergerät führt zum Bruch des Pleuels. Es besteht erhöhte Sturzgefahr.",
    "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
    "remedial_action_by_the_manufacturer": "Austausch des Zündsteuergeräts.",
    "known_incidents": "Es sind derzeit 2 Schadenereignisse mit Unfallfolge oder Personenschäden bekannt.",
    "release_date": "2022-07-11",
    "support_hotline": "0962892110",
    "fb_datetime": "2023-06-16T10:41:28.220000",
    "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
    }
    ]
    "
    31f72e92f33bcfb39ad100d8b981c9ac
    "
    ,
    "kba_reference_number": "011209",
    "manufacturer_recall_code": "NC3I6515R (0797186)",
    "manufacturer_brand": "MERCEDES-BENZ LKW",
    "trade_name": "SPRINTER",
    "construction_year_start": 2011,
    "construction_year_end": 2013,
    "affected_vehicles_worldwide": 5799.0,
    "affected_vehicles_germany": 3368.0,
    "recall_supervised_by_kba": "supervised",
    "recall_description": "Entfernung unzulässiger Abschalteinrichtungen bzw. der unzulässigen Reduzierung der Wirksamkeit des Emissionskontrollsystems.",
    "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
    "remedial_action_by_the_manufacturer": "Software Steuergeräte aktualisieren.",
    "known_incidents": "unknown",
    "release_date": "2021-10-25",
    "support_hotline": "06986798274",
    "fb_datetime": "2023-06-16T10:41:28.220000",
    "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
    },
    {
    "fb_id": "e8ffe1c04bc7f094520a13921e018579",
    "kba_reference_number": "011713",
    "manufacturer_recall_code": "30_2028161",
    "manufacturer_brand": "KTM",
    "trade_name": "125 SX, 125 XC, 150 SX",
    "construction_year_start": 2021,
    "construction_year_end": 2022,
    "affected_vehicles_worldwide": 5806.0,
    "affected_vehicles_germany": 104.0,
    "recall_supervised_by_kba": "supervised",
    "recall_description": "Defektes Zündsteuergerät führt zum Bruch des Pleuels. Es besteht erhöhte Sturzgefahr.",
    "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
    "remedial_action_by_the_manufacturer": "Austausch des Zündsteuergeräts.",
    "known_incidents": "Es sind derzeit 2 Schadenereignisse mit Unfallfolge oder Personenschäden bekannt.",
    "release_date": "2022-07-11",
    "support_hotline": "0962892110",
    "fb_datetime": "2023-06-16T10:41:28.220000",
    "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
    }
    ]

    format

    String

    X-API-KEY: Your Fusionbase API key. This key authenticates your access to the API.
  • Content-Type: application/json. This header specifies the format of the request.

  • hashtag
    Request Structure

    • Access this endpoint via a GET request to https://api.fusionbase.com/api/v2/entities/location/get/{FB_ENTITY_ID}.

    • Replace {FB_ENTITY_ID} with the actual Fusionbase Entity ID of the location you wish to query.

    hashtag
    Request Samples

    import requests
    
    url = "https://api.fusionbase.com/api/v2/entities/location/get/FB_ENTITY_ID"
    
    const axios = require('axios');
    

    hashtag
    Response Structure

    The response is a JSON object containing various details about the location:

    • fb_entity_id: The unique Fusionbase Entity ID of the location.

    • fb_datetime: Timestamp indicating the last update or retrieval of data.

    • fb_entity_version: A version identifier for the entity's data.

    • entity_type: Type of the entity, here "LOCATION".

    • updated_at, created_at: Timestamps of the last update and creation of the entity record.

    • external_ids: External identifiers associated with the location.

    • coordinate: Geographical coordinates of the location (latitude and longitude).

    • location_level: The hierarchical level of the location (if available).

    • address_components: Detailed address components like city, state, and country.

    • alternative_names: Alternative names for the location (if any).

    • fb_semantic_id: A semantic identifier providing a structured representation of the location's key attributes.

    • formatted_address: A human-readable address format.

    hashtag
    Response Sample

    hashtag
    Error Handling

    The API uses standard HTTP response codes. Errors are indicated with 4xx (client errors) and 5xx (server errors), each accompanied by a message detailing the issue.

    hashtag
    Notes

    • Keep the API key confidential.

    Datasets (Streams) & API Services

    Efficient, Targeted Data and Service Discovery

    The Streams & Services Search Endpoint is a specialized API endpoint designed to streamline searches specifically for Data Streams and Data Services within the Fusionbase Data Hub. It efficiently narrows down results to these two categories, delivering precise data sets and related services. Perfect for developers who need to target their search for datasets, like statistics or environmental data, and services that complement data processing and analytics, providing a focused and detailed data selection.

    hashtag
    Data Search

    GET https://api.fusionbase.com/api/v2/search/data?q=<QUERY>

    hashtag
    Query Parameters

    Name
    Type
    Description

    To assist with integrating the Streams & Services Search API into your application, we provide examples in various programming languages. Each example illustrates how to execute a properly encoded GET request to the API. Remember to replace <QUERY> with your URL-encoded search query and YOUR_API_KEY with the actual API key provided to you.

    These code snippets provide a template for making a GET request to the Streams & Services Search endpoint of the Fusionbase Data Hub API. By encoding the query parameter, you ensure that the request is correctly formatted and can be processed efficiently by the API.

    Person

    Person entities are structured data derived from official business registry resources, such as the German "Handelsregister," providing detailed and authenticated information about individuals.

    The /api/v2/entities/person/get/{FB_ENTITY_ID} endpoint in the Fusionbase API is designed to provide structured information about specific individuals. This endpoint is crucial for accessing detailed and structured data about persons using their unique Fusionbase Entity ID (FB_ENTITY_ID).

    hashtag
    Request Headers

    • X-API-KEY: Your Fusionbase API key. This key is required for authenticating your access to the API.

    • Content-Type: application/json. This header specifies the format of the request.

    hashtag
    Request Structure

    • The endpoint is accessed via a GET request to https://api.fusionbase.com/api/v2/entities/person/get/{FB_ENTITY_ID}.

    • {FB_ENTITY_ID} should be replaced with the actual Fusionbase Entity ID of the person you are querying.

    hashtag
    Request Sample

    hashtag
    Response Structure

    The response is a JSON object containing various details about the person:

    • fb_entity_id: The Fusionbase Entity ID uniquely identifying the person.

    • fb_datetime: Timestamp indicating when the data was last updated or retrieved.

    • fb_entity_version: A version identifier for the entity's data.

    hashtag
    Response Sample

    hashtag
    Error Handling

    The API uses standard HTTP response codes. Errors are indicated with 4xx (client errors) and 5xx (server errors), each accompanied by a message detailing the issue.

    hashtag
    Notes

    • Keep the API key confidential.

    Python

    circle-exclamation

    Please be aware that the Python SDK is undergoing significant updates in preparation for its first major release. This upcoming version will introduce breaking changes. We advise caution when using the current version of the SDK, as future updates may require adjustments in your existing code.

    hashtag
    Installation in Python - PyPI release

    Fusionbase is on PyPI, so you can use pip to install it.

    If you want to use all features, you must make sure that pandas and numpy are installed.

    Fusionbase by default uses the standard JSON library of Python to serialize and locally store data. However, you can use the faster orjson library as a drop-in replacement.

    Therefore, just install orjson and Fusionbase will automatically detect and use it.

    hashtag
    Getting Started

    Got to to deep dive into Fusionbase and see various examples on how to use the package.

    Here are some Examples for a quick start:

    hashtag
    Data Streams

    The Data Stream module lets you conveniently access data and metadata of all Data Streams. Each stream can be accessed via its unique stream id or label.

    Setup

    Human readable datastream information

    Getting the data

    The samples below show how to retrieve the data of a datastream as a list of dictionaries. Each element in the list represents one row within the dataset.

    Note that the data can by hierarchical.

    Get Data as a DataFrame

    If you are working with pandas, it is probably the most convenient way to load to data directly as a pandas DataFrame.

    Storing the data

    Large datasets potentially do not fit into the memory. Therefore, it is possible to get the data of a stream directly as partitioned files.

    The folder structure is automatically created and always like ./{ID-OF-THE-STREAM}/data/*

    hashtag

    hashtag
    Data Services

    A data service can be seen as an API that returns a certain output for a specific input. For example, our address parses an address and returns the structured and normalized parts of it.

    Setup

    Human readable data service information:

    Human readable data service definition:

    Invoke a data service:

    import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    
    public class Main {
        public static void main(String[] args) {
            HttpClient client = HttpClient.newHttpClient();
            String url = "https://api.fusionbase.com/api/v2/entities/location/get/FB_ENTITY_ID";
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .header("X-API-KEY", "<YOUR API KEY>")
                    .header("Content-Type", "application/json")
                    .GET()
                    .build();
    
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                    .thenApply(HttpResponse::body)
                    .thenAccept(System.out::println)
                    .join();
        }
    }
    package main
    
    import (
        "fmt"
        "net/http"
        "io/ioutil"
    )
    
    func main() {
        url := "https://api.fusionbase.com/api/v2/entities/location/get/FB_ENTITY_ID"
        req, _ := http.NewRequest("GET", url, nil)
    
        req.Header.Add("X-API-KEY", "<YOUR API KEY>")
        req.Header.Add("Content-Type", "application/json")
    
        res, _ := http.DefaultClient.Do(req)
    
        defer res.Body.Close()
        body, _ := ioutil.ReadAll(res.Body)
    
        fmt.Println(string(body))
    }
    {
      "fb_entity_id": "bfcc19ddd9edb12efb9cfea181b0dcd3",
      "fb_datetime": "2024-01-24T10:24:58.231000",
      "fb_entity_version": "cbff4cb34ac7130802e07d0679aa417b",
      "entity_type": "LOCATION",
      "updated_at": "2024-01-24T10:24:58.231000",
      "created_at": "2023-11-09T16:14:38.082000",
      "external_ids": {
        "nominatim": {
          "osm_id": 62428,
          "osm_type": "relation",
          "class": "boundary"
        }
      },
      "coordinate": {
        "latitude": 48.1371079,
        "longitude": 11.5753822
      },
      "location_level": null,
      "address_components": [
        {
          "component_type": "city",
          "component_value": "Munich"
        },
        {
          "component_type": "state",
          "component_value": "Bavaria"
        },
        {
          "component_type": "country",
          "component_value": "Germany"
        }
      ],
      "alternative_names": [],
      "fb_semantic_id": "location|city_no_postal_code:germany:bavaria:munich",
      "formatted_address": "Munich, Germany"
    }
    headers = {
    "X-API-KEY": "<YOUR API KEY>",
    "Content-Type": "application/json"
    }
    response = requests.get(url, headers=headers)
    print(response.json())
    const url = "https://api.fusionbase.com/api/v2/entities/location/get/FB_ENTITY_ID";
    const headers = {
    "X-API-KEY": "<YOUR API KEY>",
    "Content-Type": "application/json"
    };
    axios.get(url, { headers })
    .then(response => {
    console.log(response.data);
    })
    .catch(error => {
    console.error('Error:', error);
    });

    q

    String

    This parameter accepts the user's search string, defining the specific data or information to be retrieved by the Data Search Endpoint.

    {
        "results": [
            {
                "linked_data_id": "",
                "linked_context_id": "4994292",
                "linked_data_value": "Geodata Lookups for Germany",
                "entity": {
                    "key": "4994292",
                    "name": {
                        "en": "Geodata Lookups for Germany"
                    },
                    "display_name": null,
                    "source": {
                        "name": "Fusionbase"
                    },
                    "meta": {
                        "coverage": {
                            "geographical": {
                                "iso_alpha_3": [
                                    "DEU"
                                ]
                            }
                        }
                    }
                },
                "score": 0.7391094863414764,
                "distance": 0.26089051365852356,
                "entity_type": "STREAM"
            },
            {
                "linked_data_id": "",
                "linked_context_id": "3390386",
                "linked_data_value": "IPv4 Geolocation Mappings for Germany - Timeseries",
                "entity": {
                    "key": "3390386",
                    "name": {
                        "en": "IPv4 Geolocation Mappings for Germany - Timeseries"
                    },
                    "display_name": null,
                    "source": {
                        "name": "Fusionbase"
                    },
                    "meta": {
                        "coverage": {
                            "geographical": {
                                "iso_alpha_3": [
                                    "DEU"
                                ]
                            }
                        }
                    }
                },
                "score": 0.6845411658287048,
                "distance": 0.31545883417129517,
                "entity_type": "STREAM"
            }
        }
    ]
    
    entity_type: Indicates the type of entity, here "PERSON".
  • entity_subtype: The subtype of the entity, e.g., "INDIVIDUAL".

  • updated_at, created_at: Timestamps marking the last update and creation of the entity record.

  • external_ids: External identifiers associated with the person.

  • name: An object containing various components of the person's name, such as given name, family name, maiden name (if applicable), and aliases.

  • locations: Information about the person's known locations, such as home address, including coordinates and address components.

  • birth_date: The birth date of the person, including whether the exact day or only the month is known.

  • source: Identifier of the data source from which the information is derived.

  • fb_semantic_id: A semantic identifier providing a structured representation of the person's key attributes.

  • import requests
    
    url = "https://api.fusionbase.com/api/v2/entities/person/get/FB_ENTITY_ID"
    headers = {
        "X-API-KEY": "<YOUR API KEY>",
        "Content-Type": "application/json"
    }
    
    response = requests.get(url, headers=headers)
    print(response.json())
    const axios = require('axios');
    
    const url = "https://api.fusionbase.com/api/v2/entities/person/get/FB_ENTITY_ID";
    const headers = {
        "X-API-KEY": "<YOUR API KEY>",
        "Content-Type": "application/json"
    };
    
    axios.get(url, { headers })
        .then(response => {
            console.log(response.data);
        })
        .catch(error => {
            console.error('Error:', error);
        });
    examplesarrow-up-right
    pandasarrow-up-right
    normalization servicearrow-up-right
    curl -X "GET" "https://api.fusionbase.com/api/v2/search/data?q=$(urlencode "<QUERY>")" \
         -H 'X-API-KEY: YOUR_API_KEY' \
         -H 'Content-Type: application/json; charset=utf-8'
    import requests
    import urllib.parse
    
    query = urllib.parse.quote("<QUERY>")
    url = f"https://api.fusionbase.com/api/v2/search/data?q={query}"
    headers = {
        'X-API-KEY': 'YOUR_API_KEY',
        'Content-Type': 'application/json; charset=utf-8'
    }
    
    response = requests.get(url, headers=headers)
    print(response.json())
    const axios = require('axios');
    const querystring = require('querystring');
    
    const query = querystring.escape("<QUERY>");
    const url = `https://api.fusionbase.com/api/v2/search/data?q=${query}`;
    const headers = {
        'X-API-KEY': 'YOUR_API_KEY',
        'Content-Type': 'application/json; charset=utf-8'
    };
    
    axios.get(url, { headers })
        .then(response => {
            console.log(response.data);
        })
        .catch(error => {
            console.error('Error:', error);
        });
    
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.URLEncoder;
    import java.nio.charset.StandardCharsets;
    
    public class StreamsServicesAPIExample {
        public static void main(String[] args) {
            try {
                String query = URLEncoder.encode("<QUERY>", StandardCharsets.UTF_8.toString());
                URL url = new URL("https://api.fusionbase.com/api/v2/search/data?q=" + query);
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                connection.setRequestMethod("GET");
                connection.setRequestProperty("X-API-KEY", "YOUR_API_KEY");
                connection.setRequestProperty("Content-Type", "application/json; charset=utf-8");
    
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuffer content = new StringBuffer();
                while ((inputLine = in.readLine()) != null) {
                    content.append(inputLine);
                }
                in.close();
                System.out.println(content.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    package main
    
    import (
        "fmt"
        "net/http"
        "net/url"
        "io/ioutil"
    )
    
    func main() {
        // Prepare the base URL and the query parameter
        baseURL := "https://api.fusionbase.com/api/v2/search/data?q="
        queryParam := "<QUERY>" // replace with your actual query
        encodedQuery := url.QueryEscape(queryParam)
        requestURL := baseURL + encodedQuery
    
        // Create a new HTTP client and request
        client := &http.Client{}
        req, err := http.NewRequest("GET", requestURL, nil)
        if err != nil {
            fmt.Println("Error creating request:", err)
            return
        }
    
        // Add headers to the request
        req.Header.Add("X-API-KEY", "YOUR_API_KEY") // replace with your actual API key
        req.Header.Add("Content-Type", "application/json; charset=utf-8")
    
        // Perform the request
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println("Error making request:", err)
            return
        }
        defer resp.Body.Close
        
        // Read and print the response body
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            fmt.Println("Error reading response:", err)
            return
        }
        fmt.Println(string(body))
    }
    import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    
    public class Main {
        public static void main(String[] args) {
            HttpClient client = HttpClient.newHttpClient();
            String url = "https://api.fusionbase.com/api/v2/entities/person/get/FB_ENTITY_ID";
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .header("X-API-KEY", "<YOUR API KEY>")
                    .header("Content-Type", "application/json")
                    .GET()
                    .build();
    
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                    .thenApply(HttpResponse::body)
                    .thenAccept(System.out::println)
                    .join();
        }
    }
    package main
    
    import (
        "fmt"
        "net/http"
        "io/ioutil"
    )
    
    func main() {
        url := "https://api.fusionbase.com/api/v2/entities/person/get/FB_ENTITY_ID"
        req, _ := http.NewRequest("GET", url, nil)
    
        req.Header.Add("X-API-KEY", "<YOUR API KEY>")
        req.Header.Add("Content-Type", "application/json")
    
        res, _ := http.DefaultClient.Do(req)
    
        defer res.Body.Close()
        body, _ := ioutil.ReadAll(res.Body)
    
        fmt.Println(string(body))
    }
    curl -X GET \
    "https://api.fusionbase.com/api/v2/entities/person/get/FB_ENTITY_ID" \
    -H "X-API-KEY: <YOUR API KEY>" \
    -H "Content-Type: application/json"
    {
      "fb_entity_id": "35a263b5408b085899b5a4fab6be5d75",
      "fb_datetime": "2023-11-24T12:33:49.162000",
      "fb_entity_version": "8b98f7dd22a477db37f3d0741be8239d",
      "entity_type": "PERSON",
      "entity_subtype": "INDIVIDUAL",
      "updated_at": "2023-11-24T12:33:49.162000",
      "created_at": "2023-11-24T12:33:49.162000",
      "external_ids": {
        "fb_german_business_registry_entity_id": "35a263b5408b085899b5a4fab6be5d75"
      },
      "name": {
        "given": "Oliver",
        "family": "Bäte",
        "maiden": null,
        "aliases": []
      },
      "locations": {
        "home": {
          "fb_entity_id": "6823b26e115adfa60fe49caea0485615",
          "fb_datetime": "2023-11-09T16:14:38.553000",
          "fb_entity_version": "f05bf4207b19eaa9e8d8c9b6f2afd387",
          "entity_type": "LOCATION",
          "entity_subtype": "CITY_NO_POSTAL_CODE",
          "updated_at": "2023-11-09T16:14:38.553000",
          "created_at": "2023-11-09T16:14:38.553000",
          "external_ids": {
            "nominatim": {
              "osm_id": 62578,
              "osm_type": "relation",
              "class": "boundary"
            }
          },
          "coordinate": {
            "latitude": 50.938361,
            "longitude": 6.959974
          },
          "location_level": null,
          "address_components": [
            {
              "component_type": "city",
              "component_value": "Cologne"
            },
            {
              "component_type": "state",
              "component_value": "North Rhine-Westphalia"
            },
            {
              "component_type": "country",
              "component_value": "Germany"
            }
          ],
          "elevation": null,
          "alternative_names": [],
          "fb_semantic_id": "location|city_no_postal_code:germany:north_rhine-westphalia:cologne",
          "formatted_address": "Cologne, Germany"
        }
      },
      "birth_date": {
        "value": "1965-03-01T00:00:00",
        "is_month": false
      },
      "source": {
        "id": "data_sources/1051122944"
      },
      "fb_semantic_id": "person|individual|name:given:oliver|name:family:bäte|birth_date:value:1965-03-01t00:00:00|birth_date:is_month:false|locations:home:location|city_no_postal_code:germany:north_rhine-westphalia:cologne|source:data_sources/1051122944"
    }
    pip install fusionbase
    pip install pandas
    pip install numpy
    pip install orjson
    # Import Fusionbase
    from fusionbase import Fusionbase
    
    # Create a new datastream
    # Provide your API Key
    fusionbase = Fusionbase(auth={"api_key": "*** SECRET CREDENTIALS ***"})
    
    # If you prefer to have extended logging output and information 
    # Like a progress bar for downloading datastreams etc.
    # Turn on the log 
    fusionbase = Fusionbase(auth={"api_key": "*** SECRET CREDENTIALS ***"}, log=True)
    
    # Get the datastream with the key "28654971"
    data_stream_key = "28654971"
    data_stream = fusionbase.get_datastream(data_stream_key)
    # Print a nice table containing the meta data of the stream
    data_stream.pretty_meta_data()
    # The following returns the full datastream as a list of dictionaries
    # It uses a local cache if available
    data = data_stream.get_data()
    print(data)
    
    # Get always the latest data from Fusionbase
    data = data_stream.get_data(live=True)
    print(data)
    
    # If you only need a subset of the columns
    # You'll gain much performance by only selecting those columns
    data = data_stream.get_data(fields=["NAME_OF_COLUMN_1", "NAME_OF_COLUMN_N"])
    print(data)
    
    # If you need only an excerpt of the data you can use skip and limit
    # The sample below gets the 10 first rows
    data = data_stream.get_data(skip=0, limit=10)
    print(data)
    
    # Load the data from Fusionbase, cache it and put it in a pandas DataFrame
    df = data_stream.as_dataframe()
    print(df)
    
    # Force ignoring the cache and make sure to get the latest data
    df = data_stream.as_dataframe(live=True)
    print(df)
    from pathlib import Path
    
    # Store as JSON files
    data_stream.as_json_files(storage_path=Path("./data/"))
    
    # Store as CSV files
    data_stream.as_csv_files(storage_path=Path("./data/"))
    
    # Store as Pickle files
    data_stream.as_pickle_files(storage_path=Path("./data/"))
    # Import Fusionbase
    from fusionbase.Fusionbase import Fusionbase
    
    # Create a new dataservice
    # Provide your API Key and the Fusionbase API URI (usually: https://api.fusionbase.com/api/v1)
    fusionbase = Fusionbase(auth={"api_key": "*** SECRET CREDENTIALS ***"})
    
    data_service_key = "50527318"
    data_service = fusionbase.get_dataservice(data_service_key)
    # Retrieves the metadata from a Service by giving a Service specific key and prints it nicely to console
    data_service.pretty_meta_data()
    # Retrieve the request definition (such as required parameters) from a Service by giving a Service specific key and print it to console.
    data_service.pretty_request_definition()
    # Invoke a service by providing input data
    
    # The following lines of code are equivalent
    # Services can be invoked directly by their parameter names
    result = data_service.invoke(company_name="OroraTech GmbH", zip_code="81669")
    
    print(result)

    Services

    Fusionbase not only provides stream access to a large number of data sources but also to a large number of intelligent data services.

    Our Data Service API functions as an interface that delivers specific outputs in response to defined inputs. It is designed to streamline the process of retrieving targeted data efficiently and accurately.

    Example: Web Context Service for Organizationsarrow-up-right

    Functionality: The Web Context Service for Organizations is a specialized feature of our Data Service API. It is engineered to collect and return comprehensive, publicly available information about various companies.

    How It Works:

    • Input: You provide the base data of an organization.

    • Process: The service searches through an extensive database of public records and digital resources.

    • Output: It returns a detailed compilation of information about the specified company. This may include company size, location, industry, and other relevant organizational data.

    Use Case: This service is particularly useful for market researchers, financial analysts, and business development professionals who need quick and reliable access to company profiles and industry data.

    circle-info

    All services work the exact same way - No need to learn and adapt to a lot of different API services and documentations.

    There is only a single endpoint to access services through Fusionbase:

    hashtag
    Invoke data service

    POST https://api.fusionbase.com/api/v2/service/invoke

    Takes the service specific input values and returns the result of the service.

    hashtag
    Request Body

    Name
    Type
    Description

    hashtag
    Example

    All services are used in the exact same way. Let's take the as an example on how to use them via the API.

    The Company Web Context Service is designed to retrieve and compile comprehensive internet-based information about specific companies.

    Key Features:

    • Input Parameters: The service requires four input values: entity_name, postal_code, street and city

    • Service ID: This service is identified by the ID 4658603456.

    Example Usage: To invoke this service for "OroraTech GmbH" located in the zip code area "81669", a POST request can be made as follows:

    AI Completions

    Experience Fusionbase AI: Seamlessly Interact with Every Entity in the Acclaimed Fusionbase Data Hub Through Advanced Chat-Based Contextual Access.

    triangle-exclamation

    The Fusionbase AI API is not yet publicly accessible for all accounts. If you are interested in getting early access, drop us a message via [email protected]envelope

    The /api/v2/chat/completions endpoint of the Fusionbase API is designed to generate chat completions based on a given context and a series of messages. This endpoint is particularly useful for obtaining context-aware responses in a conversational format.

    hashtag
    Request Headers

    • Content-Type: application/json

    • X-API-KEY: Your Fusionbase API key.

    hashtag
    Request Body

    • model (required): String. Specifies the model to be used for generating completions. For example, "fusion-one".

    • linked_context (optional): Array of Objects. Each object represents a context entity linked to the chat.

      • type: String. The type of the linked context entity (e.g., "ORGANIZATION", "PERSON").

    hashtag
    Request Samples

    hashtag
    Response Structure

    • id: A unique 32-character alphanumeric hash identifying the completion request.

    • object: String, indicating the type of the object, here "chat.completion".

    • created: Unix timestamp indicating the creation time of the response.

    hashtag
    Response Sample

    hashtag
    Error Handling

    The API uses standard HTTP response codes. Errors are indicated with 4xx (client errors) and 5xx (server errors), each accompanied by a message detailing the issue.

    hashtag
    Notes

    • Keep the API key confidential.

    • Context and message relevance is crucial for accurate results.

    Organizations

    Organization entities represent legally established business or corporate entities. Each organization entity typically corresponds to a unique company, nonprofit, government body, or any other type.

    The /api/v2/entities/organization/get/{FB_ENTITY_ID} endpoint in the Fusionbase API provides structured information about specific organizations. This endpoint is essential for retrieving detailed and structured data about companies using their unique Fusionbase Entity ID (FB_ENTITY_ID).

    hashtag
    Request Header

    service_key*

    String

    The service ID as specified on the service's API page.

    inputs

    Object

    JSON object containing the key (input parameter name) and value pairs to invoke the data service.

    https://api.fusionbase.com/api/v2arrow-up-right
    /service/invokearrow-up-right
    Web Context Service for Organizationsarrow-up-right
    Entity Web Context - Data Service
  • id: String. A unique identifier for the context entity.

  • messages (required): Array of Objects. Each object represents a message in the conversation.

    • role: String. The role of the message sender ("system" or "user").

    • content: String. The content of the message.

  • model: String, indicating the model used, revised to match the request's model.

  • usage: Object detailing the token usage.

    • prompt_tokens: Number of tokens used in the prompt.

    • completion_tokens: Number of tokens used in the completion.

    • total_tokens: Total number of tokens used.

  • choices: Array of objects, each representing a generated response.

    • message: Object containing the role and content of the response.

    • logprobs: Null or containing log probabilities for the response.

    • finish_reason: Reason for the completion's end, e.g., "stop".

    • index: The index of the choice.

  • import requests
    
    url = "https://api.fusionbase.com/api/v2/chat/completions"
    headers = {
        "Content-Type": "application/json",
        "X-API-KEY": "<YOUR API KEY>"
    }
    data = {
        "model": "fusion-one",
        "linked_context": [
            {"type": "ORGANIZATION", "id": "35b263b5408bc85899b5a4fab6be5d75"},
            {"type": "PERSON", "id": "bc6a357dc563ad838e213ff06e0c1c91"}
        ],
        "messages": [
            {"role": "system", "content": "You are an insurance and underwriting expert."},
            {"role": "user", "content": "What are potential insurance risks of the given company?"}
        ]
    }
    
    response = requests.post(url, json=data, headers=headers)
    print(response.json())
    curl -X "POST" "https://api.fusionbase.com/api/v2/service/invoke" \
    -H 'X-API-KEY: YOUR_API_KEY' \
    -H 'Content-Type: application/json; charset=utf-8' \
    -d $'{
    "inputs": {
        "entity_name": "OroraTech GmbH",
        "postal_code": "81669",
        "street": "St. Martin Straße 112",
        "city": "München"
    },
    "service_key": "4658603456" # THE ID OF THE SERVICE
    }'
    import requests
    import json
    
    url = "https://api.fusionbase.com/api/v2/service/invoke"
    headers = {
        "X-API-KEY": "YOUR_API_KEY",
        "Content-Type": "application/json; charset=utf-8"
    }
    payload = {
        "inputs": {
           "entity_name": "OroraTech GmbH",
           "postal_code": "81669",
           "street": "St. Martin Straße 112",
           "city": "München"
        },
        "service_key": "4658603456"
    }
    
    response = requests.post(url, headers=headers, data=json.dumps(payload))
    print(response.text)
    
    const axios = require('axios');
    
    const url = "https://api.fusionbase.com/api/v2/service/invoke";
    const headers = {
        "X-API-KEY": "YOUR_API_KEY",
        "Content-Type": "application/json; charset=utf-8"
    };
    const payload = {
        inputs: {
           entity_name: "OroraTech GmbH",
           postal_code: "81669",
           street: "St. Martin Straße 112",
           city: "München"
        },
        service_key: "4658603456"
    };
    
    axios.post(url, payload, { headers: headers })
        .then(response => console.log(response.data))
        .catch(error => console.error('Error:', error));
    
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.io.OutputStream;
    import java.nio.charset.StandardCharsets;
    
    public class Main {
        public static void main(String[] args) {
            try {
                URL url = new URL("https://api.fusionbase.com/api/v2/service/invoke");
                String jsonInputString = "{\"inputs\": {"
                    + "\"entity_name\": \"OroraTech GmbH\", "
                    + "\"postal_code\": \"81669\", "
                    + "\"street\": \"St. Martin Straße 112\", "
                    + "\"city\": \"München\"}, "
                    + "\"service_key\": \"4658603456\"}";
                byte[] postData = jsonInputString.getBytes(StandardCharsets.UTF_8);
    
                HttpURLConnection con = (HttpURLConnection) url.openConnection();
                con.setRequestMethod("POST");
                con.setRequestProperty("X-API-KEY", "YOUR_API_KEY");
                con.setRequestProperty("Content-Type", "application/json; charset=utf-8");
                con.setDoOutput(true);
    
                try(OutputStream os = con.getOutputStream()) {
                    os.write(postData, 0, postData.length);
                }
    
                int responseCode = con.getResponseCode();
                System.out.println("POST Response Code : " + responseCode);
                // Handle response...
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    package main
    
    import (
        "bytes"
        "encoding/json"
        "fmt"
        "net/http"
    )
    
    func main() {
        url := "https://api.fusionbase.com/api/v2/service/invoke"
        payload := map[string]interface{}{
            "inputs": map[string]string{
                "entity_name": "OroraTech GmbH",
                "postal_code": "81669",
                "street": "St. Martin Straße 112",
                "city": "München"
            },
            "service_key": "4658603456",
        }
        jsonPayload, _ := json.Marshal(payload)
    
        client := &http.Client{}
        req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonPayload))
        req.Header.Add("X-API-KEY", "YOUR_API_KEY")
        req.Header.Add("Content-Type", "application/json; charset=utf-8")
    
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println("Error:", err)
            return
        }
        defer resp.Body.Close()
        
        // Read response
        fmt.Println("Response status:", resp.Status)
    }
    
    
    const axios = require('axios');
    
    const url = "https://api.fusionbase.com/api/v2/chat/completions";
    const headers = {
        "Content-Type": "application/json",
        "X-API-KEY": "<YOUR API KEY>"
    };
    const data = {
        model: "fusion-one",
        linked_context: [
            { type: "ORGANIZATION", id: "35b263b5408bc85899b5a4fab6be5d75" },
            { type: "PERSON", id: "bc6a357dc563ad838e213ff06e0c1c91" }
        ],
        messages: [
            { role: "system", content: "You are an insurance and underwriting expert." },
            { role: "user", content: "What are potential insurance risks of the given company?" }
        ]
    };
    
    axios.post(url, data, { headers: headers })
        .then(response => {
            console.log(response.data);
        })
        .catch(error => {
            console.error('Error:', error);
        });
    import okhttp3.*;
    
    import java.io.IOException;
    
    public class Main {
        public static void main(String[] args) throws IOException {
            OkHttpClient client = new OkHttpClient();
    
            MediaType mediaType = MediaType.parse("application/json");
            RequestBody body = RequestBody.create(mediaType, "{\n    \"model\": \"fusion-one\",\n    \"linked_context\": [\n        {\n            \"type\": \"ORGANIZATION\",\n            \"id\": \"35b263b5408bc85899b5a4fab6be5d75\"\n        },\n        {\n            \"type\": \"PERSON\",\n            \"id\": \"bc6a357dc563ad838e213ff06e0c1c91\"\n        }\n    ],\n    \"messages\": [\n        {\n            \"role\": \"system\",\n            \"content\": \"You are an insurance and underwriting expert.\"\n        },\n        {\n            \"role\": \"user\",\n            \"content\": \"What are potential insurance risks of the given company?\"\n        }\n    ]\n}");
            Request request = new Request.Builder()
              .url("https://api.fusionbase.com/api/v2/chat/completions")
              .post(body)
              .addHeader("Content-Type", "application/json")
              .addHeader("X-API-KEY", "<YOUR API KEY>")
              .build();
    
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        }
    }
    package main
    
    import (
        "bytes"
        "encoding/json"
        "fmt"
        "io/ioutil"
        "net/http"
    )
    
    func main() {
        url := "https://api.fusionbase.com/api/v2/chat/completions"
        requestBody := map[string]interface{}{
            "model": "fusion-one",
            "linked_context": []map[string]string{
                {"type": "ORGANIZATION", "id": "35b263b5408bc85899b5a4fab6be5d75"},
                {"type": "PERSON", "id": "bc6a357dc563ad838e213ff06e0c1c91"},
            },
            "messages": []map[string]string{
                {"role": "system", "content": "You are an insurance and underwriting expert."},
                {"role": "user", "content": "What are potential insurance risks of the given company?"},
            },
        }
    
        jsonData, err := json.Marshal(requestBody)
        if err != nil {
            panic(err)
        }
    
        req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
        req.Header.Set("Content-Type", "application/json")
        req.Header.Set("X-API-KEY", "<YOUR API KEY>")
    
        client := &http.Client{}
        resp, err := client.Do(req)
        if err != nil {
            panic(err)
        }
        defer resp.Body.Close()
    
        body, _ := ioutil.ReadAll(resp.Body)
        fmt.Println("Response: ", string(body))
    }
    
    curl https://api.fusionbase.com/api/v2/chat/completions \
    -H "Content-Type: application/json" \
    -H "X-API-KEY: <YOUR API KEY>" \
    -d '{
        "model": "fusion-one",
        "linked_context": [
            {
                "type": "ORGANIZATION",
                "id": "35b263b5408bc85899b5a4fab6be5d75"
            },
            {
                "type": "PERSON",
                "id": "bc6a357dc563ad838e213ff06e0c1c91"
            }
        ],
        "messages": [
            {
                "role": "system",
                "content": "You are an insurance and underwriting expert."
            },
            {
                "role": "user",
                "content": "What are potential insurance risks of the given company?"
            }
        ]
    }'
    {
        "id": "1234abcd5678efgh9012ijkl3456mnop",
        "object": "chat.completion",
        "created": 1677858242,
        "model": "fusion-one",
        "usage": {
            "prompt_tokens": 13,
            "completion_tokens": 7,
            "total_tokens": 20
        },
        "choices": [
            {
                "message": {
                    "role": "assistant",
                    "content": "The potential insurance risks for the given company include..."
                },
                "logprobs": null,
                "finish_reason": "stop",
                "index": 0
            }
        ]
    }
    X-API-KEY: Your Fusionbase API key. This key authenticates your access to the API.
  • Content-Type: application/json. This header specifies the format of the request body.

  • hashtag
    Request Structure

    • The endpoint is accessed via a GET request to https://api.fusionbase.com/api/v2/entities/organization/get/{FB_ENTITY_ID}.

    • {FB_ENTITY_ID} should be replaced with the actual Fusionbase Entity ID of the organization you wish to query.

    hashtag
    Request Sample

    import requests
    
    url = "https://api.fusionbase.com/api/v2/entities/organization/get/FB_ENTITY_ID"
    
    const axios = require('axios');
    

    hashtag
    Response Structure

    Due to the extensive nature of the response, only key elements are highlighted here:

    • fb_entity_id: Unique identifier for the organization within Fusionbase.

    • fb_datetime: Timestamp of the data retrieval or update.

    • fb_entity_version: Version identifier of the entity's data.

    • entity_type: Type of the entity, e.g., "ORGANIZATION".

    • entity_subtype: Subtype of the entity, e.g., "CORPORATION".

    • updated_at, created_at: Timestamps for the last update and creation of the entity record.

    • name: Official name of the organization.

    • description: Detailed description of the organization, often including the business scope.

    • address: Comprehensive address information, including geographical coordinates.

    • jurisdiction: Jurisdiction information represented by ISO country codes.

    • contact: Contact information like websites and phone numbers.

    • founding_date: The date when the organization was founded.

    • classifications: Various classifications of the organization, including industry codes and legal forms.

    • legal: Legal registration details of the organization.

    hashtag
    Response Sample

    hashtag
    Error Handling

    The API uses standard HTTP response codes. Errors are indicated with 4xx (client errors) and 5xx (server errors), each accompanied by a message detailing the issue.

    hashtag
    Notes

    • Keep the API key confidential.

    import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    
    public class Main {
        public static void main(String[] args) {
            HttpClient client = HttpClient.newHttpClient();
            String url = "https://api.fusionbase.com/api/v2/entities/organization/get/FB_ENTITY_ID";
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .header("X-API-KEY", "<YOUR API KEY>")
                    .header("Content-Type", "application/json")
                    .GET()
                    .build();
    
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                    .thenApply(HttpResponse::body)
                    .thenAccept(System.out::println)
                    .join();
        }
    }
    package main
    
    import (
        "fmt"
        "net/http"
        "io/ioutil"
    )
    
    func main() {
        url := "https://api.fusionbase.com/api/v2/entities/organization/get/FB_ENTITY_ID"
        req, _ := http.NewRequest("GET", url, nil)
    
        req.Header.Add("X-API-KEY", "<YOUR API KEY>")
        req.Header.Add("Content-Type", "application/json")
    
        res, _ := http.DefaultClient.Do(req)
    
        defer res.Body.Close()
        body, _ := ioutil.ReadAll(res.Body)
    
        fmt.Println(string(body))
    }
    curl -X GET \
    "https://api.fusionbase.com/api/v2/entities/organization/get/FB_ENTITY_ID" \
    -H "X-API-KEY: <YOUR API KEY> " \
    -H "Content-Type: application/json"
    {
      "fb_entity_id": "75e8887e25587ed64cc8e1733a6c7160",
      "fb_datetime": "2024-02-01T16:12:18.849000",
      "fb_entity_version": "55afcba0d74181bd508e0207e3fbddfc",
      "entity_type": "ORGANIZATION",
      "entity_subtype": "CORPORATION",
      "updated_at": "2024-02-01T16:12:18.849000",
      "created_at": "2023-11-24T10:30:02.502000",
      "external_ids": {
        "fb_german_business_registry_entity_id": "75e8887e25587ed64cc8e1733a6c7160"
      },
      "status": {
        "active": true,
        "status": "ACTIVE",
        "status_detail": null
      },
      "name": "ADOS GmbH",
      "other_names": [
        "Ados Gesellschaft mit beschränkter Haftung"
      ],
      "description": {
        "registry": {
          "de": "Gegenstand des Unternehmens ist die Herstellung und der Verkauf der unter dem Namen \"ADOS\" geschützten Artikel sowie der Erwerb, die Veräußerung, die Verwertung von Patenten und Erfinderrechten und die Herstellung, Anschaffung und der Vertrieb von anderen Gegenständen des Gewerbefleisses."
        }
      },
      "address": {
        "fb_entity_id": "b69ea5ed95c054a3ad9b3d75335386a7",
        "fb_datetime": "2023-11-23T16:00:34.569000",
        "fb_entity_version": "036c16c81f808da80a4099ca1ad85d22",
        "updated_at": "2023-11-23T16:00:34.569000",
        "created_at": "2023-11-23T16:00:34.569000",
        "external_ids": {
          "nominatim": {
            "osm_id": 163641824,
            "osm_type": "way",
            "class": "building"
          }
        },
        "coordinate": {
          "latitude": 50.7697654,
          "longitude": 6.1196758544025
        },
        "location_level": null,
        "address_components": [
          {
            "component_type": "house_number",
            "component_value": "23-25"
          },
          {
            "component_type": "street",
            "component_value": "Trierer Straße"
          },
          {
            "component_type": "postal_code",
            "component_value": "52078"
          },
          {
            "component_type": "city",
            "component_value": "Aachen"
          },
          {
            "component_type": "county",
            "component_value": "Städteregion Aachen"
          },
          {
            "component_type": "state",
            "component_value": "North Rhine-Westphalia"
          },
          {
            "component_type": "country",
            "component_value": "Germany"
          }
        ],
        "alternative_names": [],
        "fb_semantic_id": "location|locality:germany:north_rhine-westphalia:52078:aachen:trierer_strasse:23-25",
        "formatted_address": "Trierer Straße 23-25, 52078 Aachen, Germany"
      },
      "other_addresses": null,
      "jurisdiction": {
        "iso_alpha3": "DEU"
      },
      "contact": {
        "websites": {
          "primary": "https://www.ados.de/"
        },
        "phone_numbers": {
          "primary": "0241 97690"
        }
      },
      "founding_date": "1961-02-20T00:00:00",
      "cessation_date": null,
      "classifications": {
        "web": [
          {
            "source": "Google",
            "value": {
              "de": "Hersteller elektronischer Geräte"
            }
          }
        ],
        "industry_codes": null,
        "legal_form": null
      },
      "source": {
        "id": "data_sources/1051122944"
      },
      "fb_semantic_id": "organization|corporation|registration_authority_id:r3101|registration_authority_name:r3101|registration_type:hrb|registration_number:5|registration_authority_location_id:2077c7f46e95a3740492448c2beb2011|source:data_sources/1051122944",
      "legal": {
        "registration_authority": {
          "local": {
            "registration_authority_id": "R3101",
            "registration_authority_name": "Aachen",
            "registration_authority_entity_id": "R3101 HRB 5",
            "registration_authority_entity_name": "Aachen HRB 5",
            "registration_type": "HRB",
            "registration_number": "5",
            "registration_id_extra": null,
            "registration_authority_location": {
              "fb_entity_id": "2077c7f46e95a3740492448c2beb2011",
              "fb_datetime": "2023-11-17T07:29:40.987000",
              "fb_entity_version": "feddb22b0fa9166a41602a99f63601af",
              "entity_type": "LOCATION",
              "entity_subtype": "CITY_NO_POSTAL_CODE",
              "updated_at": "2023-11-17T07:29:40.987000",
              "created_at": "2023-11-09T16:14:31.050000",
              "external_ids": {
                "nominatim": {
                  "osm_id": 62564,
                  "osm_type": "relation",
                  "class": "boundary"
                }
              },
              "coordinate": {
                "latitude": 50.776351,
                "longitude": 6.083862
              },
              "location_level": null,
              "address_components": [
                {
                  "component_type": "city",
                  "component_value": "Aachen"
                },
                {
                  "component_type": "county",
                  "component_value": "Städteregion Aachen"
                },
                {
                  "component_type": "state",
                  "component_value": "North Rhine-Westphalia"
                },
                {
                  "component_type": "country",
                  "component_value": "Germany"
                }
              ],
              "elevation": null,
              "alternative_names": [],
              "fb_semantic_id": "location|city_no_postal_code:germany:north_rhine-westphalia:aachen",
              "formatted_address": "Aachen, Germany"
            }
          }
        }
      }
    }
    headers = {
    "X-API-KEY": "<YOUR API KEY>",
    "Content-Type": "application/json"
    }
    response = requests.get(url, headers=headers)
    print(response.json())
    const url = "https://api.fusionbase.com/api/v2/entities/organization/get/FB_ENTITY_ID";
    const headers = {
    "X-API-KEY": "<YOUR API KEY>",
    "Content-Type": "application/json"
    };
    axios.get(url, { headers })
    .then(response => {
    console.log(response.data);
    })
    .catch(error => {
    console.error('Error:', error);
    });

    Event

    Event entities encompass comprehensive data gathered from various global sources, detailing significant occurrences. These include corporate milestones, publications, and key events of businesses.

    The /api/v2/entities/event/get/{FB_ENTITY_ID} endpoint in the Fusionbase API provides structured information about specific events. This endpoint is crucial for accessing detailed and structured data about events using their unique Fusionbase Entity ID (FB_ENTITY_ID).

    hashtag
    Request Headers

    • X-API-KEY: Your Fusionbase API key. This key is required for authenticating your access to the API.

    • Content-Type: application/json. This header specifies the format of the request.

    hashtag
    Request Structure

    • Access this endpoint via a GET request to https://api.fusionbase.com/api/v2/entities/event/get/{FB_ENTITY_ID}.

    • Replace {FB_ENTITY_ID} with the actual Fusionbase Entity ID of the event you wish to query.

    hashtag
    Request Samples

    hashtag
    Response Structure

    The response is a JSON object containing various details about the event:

    • fb_entity_id: The unique Fusionbase Entity ID of the event.

    • fb_entity_version: A version identifier for the entity's data.

    • entity_type: Type of the entity, here "EVENT".

    hashtag
    Response Sample

    entity_subtype: The subtype of the entity, e.g., "PUBLICATION".
  • external_ids: External identifiers associated with the event (if available).

  • name: The name of the event in different languages.

  • description: Short descriptions of the event in different languages.

  • start_date, live_date, end_date, announce_date: Relevant dates associated with the event.

  • status: The current status of the event, e.g., "FINISHED".

  • category: The category of the event, e.g., "MEMBER_EXIT_POSITION".

  • source: Identifier of the data source from which the information is derived.

  • details: Detailed information about the event, including roles and linked entities like persons and organizations.

  • origin_location, event_location, effect_location: Locations related to the event (if applicable).

  • import requests
    
    url = "https://api.fusionbase.com/api/v2/entities/event/get/FB_ENTITY_ID"
    headers = {
        "X-API-KEY": "<YOUR API KEY>",
        "Content-Type": "application/json"
    }
    
    response = requests.get(url, headers=headers)
    print(response.json())
    const axios = require('axios');
    
    const url = "https://api.fusionbase.com/api/v2/entities/event/get/FB_ENTITY_ID";
    const headers = {
        "X-API-KEY": "<YOUR API KEY>",
        "Content-Type": "application/json"
    };
    
    axios.get(url, { headers })
        .then(response => {
            console.log(response.data);
        })
        .catch(error => {
            console.error('Error:', error);
        });
    import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    
    public class Main {
        public static void main(String[] args) {
            HttpClient client = HttpClient.newHttpClient();
            String url = "https://api.fusionbase.com/api/v2/entities/event/get/FB_ENTITY_ID";
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .header("X-API-KEY", "<YOUR API KEY>")
                    .header("Content-Type", "application/json")
                    .GET()
                    .build();
    
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                    .thenApply(HttpResponse::body)
                    .thenAccept(System.out::println)
                    .join();
        }
    }
    package main
    
    import (
        "fmt"
        "net/http"
        "io/ioutil"
    )
    
    func main() {
        url := "https://api.fusionbase.com/api/v2/entities/event/get/FB_ENTITY_ID"
        req, _ := http.NewRequest("GET", url, nil)
    
        req.Header.Add("X-API-KEY", "<YOUR API KEY>")
        req.Header.Add("Content-Type", "application/json")
    
        res, _ := http.DefaultClient.Do(req)
    
        defer res.Body.Close()
        body, _ := ioutil.ReadAll(res.Body)
    
        fmt.Println(string(body))
    }
    curl -X GET \
    "https://api.fusionbase.com/api/v2/entities/event/get/FB_ENTITY_ID" \
    -H "X-API-KEY: <YOUR API KEY>" \
    -H "Content-Type: application/json"
    {
        "fb_entity_id": "9befc075e19843dba4ed7dcfc3b70dc5",
        "fb_entity_version": "7fe58d301af8541a1eaee7adc0861120",
        "entity_type": "EVENT",
        "entity_subtype": "PUBLICATION",
        "external_ids": null,
        "name": {
            "en": "Exit of position",
            "de": "Austritt einer Position"
        },
        "description": {
            "short": {
                "en": "A member has exited their position",
                "de": "Ein Mitglied hat seine Position verlassen"
            }
        },
        "start_date": "2013-11-26T00:00:00",
        "live_date": null,
        "end_date": null,
        "announce_date": "2013-11-26T00:00:00",
        "status": "FINISHED",
        "category": "MEMBER_EXIT_POSITION",
        "source": {
            "id": "data_sources/1784627846"
        },
        "details": {
            "value": {
                "role": {
                    "name": "Director",
                    "original_name_source": "director",
                    "responsibilities": null,
                    "representation_scheme": null,
                    "liability_deposit": null
                }
            },
            "linked_entities": {
                "person": {
                    "fb_entity_id": "72a0dbb560e4219e76763d28d6eeadb6",
                    "name": {
                        "given": "Nicholas John",
                        "family": "Dell",
                        "maiden": null,
                        "aliases": []
                    }
                },
                "organization": {
                    "fb_entity_id": "745973f63bb8ce5c36bd16361fc7da3a",
                    "name": "The Bristol Law Society"
                }
            }
        },
        "origin_location": null,
        "event_location": null,
        "effect_location": null
    }

    (All in One) Fusion Search

    AI-Enhanced, Comprehensive Data Discovery

    The Fusion Search Endpoint is an AI-enhanced API endpoint offering comprehensive searches across all Fusionbase Data Hub entities. It adeptly interprets user intent to deliver relevant, ranked results and, where applicable, knowledge graphs. Ideal for developers requiring an overarching, context-rich data overview.

    hashtag
    Fusion Search

    GET https://api.fusionbase.com/api/v2/search/fusion?q={QUERY}

    Search accross all Fusionbase data entities with a single query.

    hashtag
    Query Parameters

    Name
    Type
    Description

    The Fusion Search API response primarily consists of a results section, categorizing matched entities like organizations, persons, and streams with detailed information. When applicable, a knowledge_graph is included, offering direct answers to the query, and a ranks list details the relevance order of entity types.

    To help you integrate the Fusion Search API into your application, we provide examples in various programming languages. Each example demonstrates how to make a properly encoded GET request to the API. Ensure you replace <QUERY> with your URL-encoded search query and YOUR_API_KEY with your actual API key.

    Each code snippet is an example of how to call the Fusion Search API in a specific programming language, ensuring the query is correctly URL-encoded to maintain the integrity of the request.

    q

    String

    This parameter accepts the user's search string, defining the specific data or information to be retrieved by the Fusion Search Endpoint.

    {
        "knowledge_graph": {
            "intent": "RELATION",
            "from_entity_type": "ORGANIZATION",
            "from_entity_id": "546bb06ee922e3b09dc50c50068044a3",
            "relation_id": "67533702",
            "relation_parameters": {}
        },
        "results": {
            "persons": [],
            "organizations": [
                {
                    "entity_type": "ORGANIZATION",
                    "entity": {
                        "fb_entity_id": "546bb06ee922e3b09dc50c50068044a3",
                        "status": "ACTIVE",
                        "display_address": "Aidenbachstraße 140, 81479 Munich, Germany",
                        "registration_authority_entity_name": "München HRB 137024",
                        "display_name": "Health Care Insurance Versicherungsservice GmbH, Zweigniederlassung München",
                        "old_display_name_matched": null,
                        "name": "Health Care Insurance Versicherungsservice GmbH, Zweigniederlassung München"
                    },
                    "score": 10.070869
                },
                {
                    "entity_type": "ORGANIZATION",
                    "entity": {
                        "fb_entity_id": "b868b2702752d55edd2c25115724f621",
                        "status": "ACTIVE",
                        "display_address": "Schockenriedstraße 17, 70565 Stuttgart, Germany",
                        "registration_authority_entity_name": "Stuttgart HRB 23323",
                        "display_name": "Health Insurance Service AG",
                        "old_display_name_matched": null,
                        "name": "Health Insurance Service AG"
                    },
                    "score": 26.590382
                },
                {
                    "entity_type": "ORGANIZATION",
                    "entity": {
                        "fb_entity_id": "5e1c322419666b33fd0d89442f46766c",
                        "status": "ACTIVE",
                        "display_address": null,
                        "registration_authority_entity_name": "07391552",
                        "display_name": "Health Insurance Services (Sw) Limited",
                        "old_display_name_matched": null,
                        "name": "Health Insurance Services (Sw) Limited"
                    },
                    "score": 24.026272
                },
                {
                    "entity_type": "ORGANIZATION",
                    "entity": {
                        "fb_entity_id": "3228a8cd0c6d720672d4e97b837a73cc",
                        "status": "ACTIVE",
                        "display_address": null,
                        "registration_authority_entity_name": "05191059",
                        "display_name": "Health Insurance Matters Ltd.",
                        "old_display_name_matched": null,
                        "name": "Health Insurance Matters Ltd."
                    },
                    "score": 26.590382
                },
                {
                    "entity_type": "ORGANIZATION",
                    "entity": {
                        "fb_entity_id": "9419edbe466b488ed13b6e568e83e032",
                        "status": "ACTIVE",
                        "display_address": null,
                        "registration_authority_entity_name": "07350776",
                        "display_name": "The Health Insurance Bureau Limited",
                        "old_display_name_matched": null,
                        "name": "The Health Insurance Bureau Limited"
                    },
                    "score": 24.026272
                }
            ],
            "locations": [],
            "relations": [
                {
                    "entity": {
                        "id": "64395606",
                        "key": "64395606",
                        "name": {
                            "en": "Multiscale Global and Local Statistical Indicators for Locations",
                            "de": "Standortbezogene Globale und Lokale Statistische Indikatoren"
                        },
                        "description": {
                            "en": "Comprehensive statistical indicators across various levels of granularity worldwide, encompassing a wide range of demographic, economic, and social data for countries, regions, and municipalities.",
                            "de": "Umfassende statistische Indikatoren auf verschiedenen Granularitätsstufen weltweit, die eine breite Palette an demographischen, wirtschaftlichen und sozialen Daten für Länder, Regionen und Gemeinden abdecken."
                        },
                        "parameter": {
                            "name": {
                                "de": "Deutschland: Gesamtzahl der Krankenhäuser nach Region",
                                "en": "Germany: Total Number of Hospitals by Region"
                            },
                            "value": {
                                "indicator_name": "TOTAL_HOSPITALS"
                            },
                            "source": {
                                "name": "Bundesinstitut für Bau-, Stadt- und Raumforschung (BBSR)"
                            }
                        },
                        "meta": {
                            "coverage": {
                                "geographical": {
                                    "iso_alpha_3": [
                                        "DEU"
                                    ]
                                }
                            },
                            "granularity": {
                                "geographical": [
                                    2,
                                    6
                                ]
                            }
                        }
                    },
                    "score": 0.6493748426437378,
                    "distance": 0.3506251573562622,
                    "entity_type": "RELATION"
                },
                {
                    "entity": {
                        "id": "64395606",
                        "key": "64395606",
                        "name": {
                            "en": "Multiscale Global and Local Statistical Indicators for Locations",
                            "de": "Standortbezogene Globale und Lokale Statistische Indikatoren"
                        },
                        "description": {
                            "en": "Comprehensive statistical indicators across various levels of granularity worldwide, encompassing a wide range of demographic, economic, and social data for countries, regions, and municipalities.",
                            "de": "Umfassende statistische Indikatoren auf verschiedenen Granularitätsstufen weltweit, die eine breite Palette an demographischen, wirtschaftlichen und sozialen Daten für Länder, Regionen und Gemeinden abdecken."
                        },
                        "parameter": {
                            "name": {
                                "en": "Global: Global Jobs Indicators Database (JOIN)"
                            },
                            "value": {
                                "indicator_name": "GLOBAL_JOBS_INDICATORS_DATABASE__JOIN"
                            },
                            "source": {
                                "name": "World Bank"
                            }
                        },
                        "meta": {
                            "coverage": {
                                "geographical": {
                                    "iso_alpha_3": [
                                        "TUR",
                                        "BWA",
                                        "MHL",
                                        "ETH",
                                        "COM",
                                        "DEU",
                                        "SDN",
                                        "BGR",
                                        "AUS",
                                        "NIC",
                                        "MWI",
                                        "PAK",
                                        "BTN",
                                        "TJK",
                                        "SLV",
                                        "CRI",
                                        "VNM",
                                        "GNB",
                                        "TGO",
                                        "EGY",
                                        "LSO",
                                        "BLR",
                                        "TCD",
                                        "BDI",
                                        "CZE",
                                        "DOM",
                                        "KIR",
                                        "CIV",
                                        "DNK",
                                        "MOZ",
                                        "AFG",
                                        "NAM",
                                        "POL",
                                        "IRQ",
                                        "RWA",
                                        "CHL",
                                        "ARM",
                                        "PRI",
                                        "HTI",
                                        "SSD",
                                        "ZWE",
                                        "ALB",
                                        "PER",
                                        "ITA",
                                        "NLD",
                                        "FRA",
                                        "UGA",
                                        "KEN",
                                        "MLI",
                                        "MNG",
                                        "JOR",
                                        "TZA",
                                        "CPV",
                                        "MYS",
                                        "GHA",
                                        "GBR",
                                        "LBR",
                                        "BIH",
                                        "STP",
                                        "AUT",
                                        "SEN",
                                        "IDN",
                                        "ECU",
                                        "USA",
                                        "MDG",
                                        "MNE",
                                        "GTM",
                                        "SVK",
                                        "ISL",
                                        "TUV",
                                        "PNG",
                                        "MMR",
                                        "DJI",
                                        "IND",
                                        "PHL",
                                        "NOR",
                                        "YEM",
                                        "VUT",
                                        "URY",
                                        "JAM",
                                        "MAR",
                                        "ROU",
                                        "BEL",
                                        "ARG",
                                        "GUY",
                                        "ESP",
                                        "LKA",
                                        "NPL",
                                        "SOM",
                                        "MDV",
                                        "SYC",
                                        "LAO",
                                        "VEN",
                                        "BHS",
                                        "PRT",
                                        "MUS",
                                        "MEX",
                                        "IRN",
                                        "TUN",
                                        "HRV",
                                        "BEN",
                                        "CAF",
                                        "RUS",
                                        "TTO",
                                        "KOR",
                                        "PLW",
                                        "HUN",
                                        "MLT",
                                        "ZMB",
                                        "CHN",
                                        "GAB",
                                        "IRL",
                                        "BLZ",
                                        "CAN",
                                        "COG",
                                        "SRB",
                                        "FSM",
                                        "UZB",
                                        "BFA",
                                        "CYP",
                                        "LUX",
                                        "MKD",
                                        "GIN",
                                        "NGA",
                                        "BRB",
                                        "ZAF",
                                        "AZE",
                                        "MDA",
                                        "LTU",
                                        "CHE",
                                        "COL",
                                        "PAN",
                                        "FIN",
                                        "KHM",
                                        "NER",
                                        "UKR",
                                        "BRA",
                                        "BOL",
                                        "GMB",
                                        "SLE",
                                        "KGZ",
                                        "SWZ",
                                        "AGO",
                                        "GRC",
                                        "SLB",
                                        "LVA",
                                        "PRY",
                                        "KAZ",
                                        "MRT",
                                        "EST",
                                        "CMR",
                                        "COD",
                                        "SVN",
                                        "SWE",
                                        "TLS",
                                        "THA",
                                        "FJI",
                                        "GEO",
                                        "BGD",
                                        "TON",
                                        "HND"
                                    ]
                                }
                            },
                            "granularity": {
                                "geographical": [
                                    1
                                ]
                            }
                        }
                    },
                    "score": 0.6404404044151306,
                    "distance": 0.3595595955848694,
                    "entity_type": "RELATION"
                }
            ],
            "streams": [
                {
                    "linked_data_id": "",
                    "linked_context_id": "55012638",
                    "linked_data_value": "USA: ACS1 - Imputation of Direct-purchase Health Insurance",
                    "entity": {
                        "key": "55012638",
                        "name": {
                            "en": "USA: ACS1 - Imputation of Direct-purchase Health Insurance"
                        },
                        "display_name": null,
                        "source": {
                            "name": "United States Census Bureau"
                        },
                        "meta": {
                            "coverage": {
                                "geographical": {
                                    "iso_alpha_3": [
                                        "USA"
                                    ]
                                }
                            }
                        }
                    },
                    "score": 0.7111876904964447,
                    "distance": 0.2888123095035553,
                    "entity_type": "STREAM"
                },
                {
                    "linked_data_id": "",
                    "linked_context_id": "55000993",
                    "linked_data_value": "USA: ACS1 - Imputation of Health Insurance Coverage",
                    "entity": {
                        "key": "55000993",
                        "name": {
                            "en": "USA: ACS1 - Imputation of Health Insurance Coverage"
                        },
                        "display_name": null,
                        "source": {
                            "name": "United States Census Bureau"
                        },
                        "meta": {
                            "coverage": {
                                "geographical": {
                                    "iso_alpha_3": [
                                        "USA"
                                    ]
                                }
                            }
                        }
                    },
                    "score": 0.7104124128818512,
                    "distance": 0.2895875871181488,
                    "entity_type": "STREAM"
                }
            ],
            "services": []
        },
        "ranks": [
            "STREAM",
            "RELATION",
            "ORGANIZATION"
        ]
    }
    curl -X "GET" "https://api.fusionbase.com/api/v2/search/fusion?q=<QUERY>" \
         -H 'X-API-KEY: YOUR_API_KEY' \
         -H 'Content-Type: application/json; charset=utf-8'
    import requests
    import urllib.parse
    
    query = urllib.parse.quote("<QUERY>")
    url = f"https://api.fusionbase.com/api/v2/search/fusion?q={query}"
    headers = {
        'X-API-KEY': 'YOUR_API_KEY',
        'Content-Type': 'application/json; charset=utf-8'
    }
    
    response = requests.get(url, headers=headers)
    print(response.json())
    const axios = require('axios');
    const querystring = require('querystring');
    
    const query = querystring.escape("<QUERY>");
    const url = `https://api.fusionbase.com/api/v2/search/fusion?q=${query}`;
    const headers = {
        'X-API-KEY': 'YOUR_API_KEY',
        'Content-Type': 'application/json; charset=utf-8'
    };
    
    axios.get(url, { headers })
        .then(response => {
            console.log(response.data);
        })
        .catch(error => {
            console.error('Error:', error);
        });
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.URLEncoder;
    import java.nio.charset.StandardCharsets;
    
    public class FusionbaseAPIExample {
        public static void main(String[] args) {
            try {
                String query = URLEncoder.encode("<QUERY>", StandardCharsets.UTF_8.toString());
                URL url = new URL("https://api.fusionbase.com/api/v2/search/fusion?q=" + query);
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                connection.setRequestMethod("GET");
                connection.setRequestProperty("X-API-KEY", "YOUR_API_KEY");
                connection.setRequestProperty("Content-Type", "application/json; charset=utf-8");
    
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuffer content = new StringBuffer();
                while ((inputLine = in.readLine()) != null) {
                    content.append(inputLine);
                }
                in.close();
                System.out.println(content.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    package main
    
    import (
        "fmt"
        "net/http"
        "net/url"
        "io/ioutil"
    )
    
    func main() {
        baseURL := "https://api.fusionbase.com/api/v2/search/fusion?q="
        query := url.QueryEscape("<QUERY>")
        requestURL := baseURL + query
    
        client := &http.Client{}
        req, _ := http.NewRequest("GET", requestURL, nil)
        req.Header.Add("X-API-KEY", "YOUR_API_KEY")
        req.Header.Add("Content-Type", "application/json; charset=utf-8")
    
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err)
            return
        }
        defer resp.Body.Close()
        body, _ := ioutil.ReadAll(resp.Body)
        fmt.Println(string(body))
    }

    Streams

    The Data Stream API lets you conveniently access data and metadata of all Data Streams. Each stream can be accessed via its unique stream id.

    circle-info

    You can access almost any available Data Stream even if you are not subscribed to it!

    The API provides most functions but is limited to a maximum of 10 records per stream.

    hashtag
    TL;DR

    The Fusionbase API provides a streamlined way to interact with data streams, offering three primary endpoints: /base, /data, and /search. Each endpoint serves a distinct purpose, enabling users to access metadata, retrieve and query data, and perform searches within the data streams.

    For the /data and /search endpoints the default response type is msgpack, JSON is available using the GET parameter format=json

    hashtag
    Data Structure

    All Data Streams in Fusionbase, independent of the source or content follow the same data structure.

    The table below gives you a full overview of all attributes, their description and data types.

    Name
    Description
    Data Type

    hashtag
    Example

    Let's assume we would like to retrieve the latest automotive recalls in Germany. Luckily, we found a real-time in the Fusionbase Data Hub.

    The Data Stream API will return the stream in the above mentioned structure which looks like the following:

    hashtag
    Fusionbase Specific Columns

    Fusionbase adds three additional metadata columns to each Data Stream. These columns may make your live easier in certain scenarios.

    Fusionbase ID

    The Fusionbase ID fb_id is a hash value based on all data values in the same row. You can see it as a primary and unique key for each record.

    Fusionbase Datetime

    The Fusionbase Datetime fb_datetime is an ISO formatted timestamp that represents the exact date and time when the record was added to the Data Stream by Fusionbase.

    Fusionbase Data Version

    The Fusionbase Data Version fb_data_version is automatically added to any new record or batch of records that are added to the Data Stream. The version corresponds to the fb_datetime but offers more query functionalities via the API.

    description

    Description of the stream by language

    Object

    meta

    Various meta information: is_active: Stream still actively updated entry_count: Number of records main_property_count: Number of properties, i.e., columns

    Object

    source

    Information about the data source

    Object

    data_item_collections

    Data property and schema information. This contains attribute names and the corresponding data types

    List

    data_version

    The current version of the data

    String

    data_updated_at

    The date when the data of the stream has been last updated

    Datetime

    data

    The data of the stream based on the query input

    List

    created_at

    Date and time when the stream was created on Fusionbase

    Datetime

    updated_at

    Date and time when the stream was last updated either by it's data or metadata

    Datetime

    _key

    Unique identifier of the stream

    String

    name

    Name of the stream by language

    Object

    automotive recalls Data Streamarrow-up-right
    import requests
    
    headers = {
        'x-api-key': 'YOUR_API_KEY',
    }
    
    response = requests.get('https://api.fusionbase.com/api/v2/stream/base/STREAM_ID', headers=headers, params=params)
    assert response.code == 200, "CONNECTION_ERROR"
    
    data_stream = response.json()
    print(data_stream)
    import requests
    import json
    
    # Replace 'YOUR_API_KEY' with your actual API key
    headers = {
        'x-api-key': 'YOUR_API_KEY',
    }
    
    # Define the query parameters
    params = {
        'skip': '1000',
        'limit': '5',
        'version_boundary': 'bd764e07-50a1-4c0e-a102-ae1a259557av',
        'format': 'json',
        'query_parameters': json.dumps({
            "sort_order": ["asc"],
            "sort_keys": ["fb_datetime"],
            "skip": 0,
            "limit": 2,
            "project_fields": ["manufacturer_brand", "recall_supervised_by_kba"],
            "filters": [{
                "property": "construction_year_end",
                "operator": "GREATER_THAN",
                "value": 2013
            }]
        })
    }
    
    # The URL for the GET request
    url = 'https://api.fusionbase.com/api/v2/stream/data/430410'
    
    # Make the GET request
    response = requests.get(url, headers=headers, params=params)
    
    # Check if the request was successful
    assert response.status_code == 200, "CONNECTION_ERROR"
    
    # Parse the response to JSON
    data = response.json()
    
    # Example of how to use the data
    print(data)
    import requests
    
    # Replace 'YOUR_API_KEY' with your actual API key
    headers = {
        'x-api-key': 'YOUR_API_KEY',
    }
    
    # Define the query parameters
    params = {
        'q': 'LAMBORGHINI',  # Your search query
        'format': 'json'      # Specify the response format
    }
    
    # Construct the full URL for the GET request
    url = f'https://api.fusionbase.com/api/v2/stream/data/search/430410'
    
    # Make the GET request
    response = requests.get(url, headers=headers, params=params)
    
    # Check if the request was successful
    assert response.status_code == 200, "CONNECTION_ERROR"
    
    # Parse the response to JSON
    search_results = response.json()
    
    # Example of how to use the data
    print(search_results)
    
    {
        "id": "data_streams/430410",
        "key": "430410",
        "name": {
            "en": "Germany: Automotive Recalls"
        },
        "description": {
            "en": "This extensive database presents a systematic compilation of all automotive recalls issued in Germany from 1995 to the current date. Encompassing a wide range of vehicles and car accessories, the catalog serves as a vital tool for researchers, automotive engineers, policy makers, and safety analysts. Each entry in the database is meticulously documented, providing detailed information on the nature of the defect, the models and components affected, and the remedial actions recommended. By offering a chronological and categorical organization of the data, the catalog facilitates trend analysis and retrospective studies, contributing to the broader understanding of automotive safety and reliability over time. The aim of this resource is to support scientific inquiry and data-driven decision-making in the field of automotive safety, ensuring a safer and more informed vehicular environment in Germany."
        },
        "meta": {
            "entry_count": 8119,
            "main_property_count": 18
        },
        "created_at": "2021-06-16T12:16:18.367162",
        "updated_at": "2023-10-26T22:35:11.296891",
        "data_item_collections": [
            {
                "id": "data_item_collections/430413",
                "key": "430413",
                "name": "fb_id",
                "description": {
                    "en": "The ID is a unique fingerprint that is calculated based on the values of all non-Fusionbase specific columns."
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.525145",
                "updated_at": "2021-06-18T10:46:26.888675",
                "definition": {
                    "en": "Unique record identifier and primary key"
                },
                "basic_data_type": "String",
                "semantic_type": "Fusionbase ID",
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430416",
                "key": "430416",
                "name": "kba_reference_number",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.528423",
                "updated_at": "2021-06-18T10:46:26.894534",
                "definition": {
                    "en": "Unique reference number provided by Kraftfahrtbundesamt"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430419",
                "key": "430419",
                "name": "manufacturer_recall_code",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.531390",
                "updated_at": "2021-06-18T10:46:26.900453",
                "definition": {
                    "en": "Unique recall code provided by the manufacturer"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430422",
                "key": "430422",
                "name": "manufacturer_brand",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.533831",
                "updated_at": "2021-06-18T10:46:26.906302",
                "definition": {
                    "en": "Manufacturer brand of the car or accessory"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430425",
                "key": "430425",
                "name": "trade_name",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.536421",
                "updated_at": "2021-06-18T10:46:26.912149",
                "definition": {
                    "en": "Trade name of the car or accessory"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430428",
                "key": "430428",
                "name": "construction_year_start",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.538828",
                "updated_at": "2021-06-18T10:46:26.918302",
                "definition": {
                    "en": "Year when construction began"
                },
                "basic_data_type": "int",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430431",
                "key": "430431",
                "name": "construction_year_end",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.541334",
                "updated_at": "2021-06-18T10:46:26.924226",
                "definition": {
                    "en": "Year when construction ended"
                },
                "basic_data_type": "int",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430434",
                "key": "430434",
                "name": "affected_vehicles_worldwide",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.543767",
                "updated_at": "2021-06-18T10:46:26.930195",
                "definition": {
                    "en": "Number of vehicles affected worldwide"
                },
                "basic_data_type": "float",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430437",
                "key": "430437",
                "name": "affected_vehicles_germany",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.546184",
                "updated_at": "2021-06-18T10:46:26.936015",
                "definition": {
                    "en": "Number of vehicles affected in Germany"
                },
                "basic_data_type": "float",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430440",
                "key": "430440",
                "name": "recall_supervised_by_kba",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.548717",
                "updated_at": "2021-06-18T10:46:26.941896",
                "definition": {
                    "en": "Note whether the recall is supervised by Kraftfahrtbundesamt"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430443",
                "key": "430443",
                "name": "recall_description",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.551148",
                "updated_at": "2021-06-18T10:46:26.947900",
                "definition": {
                    "en": "Description of the recall"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430446",
                "key": "430446",
                "name": "possible_restrictions_of_the_affected_vehicle_versions",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.553559",
                "updated_at": "2021-06-18T10:46:26.954070",
                "definition": {
                    "en": "Possible restrictions that apply to the affected vehicle version"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430449",
                "key": "430449",
                "name": "remedial_action_by_the_manufacturer",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.556197",
                "updated_at": "2021-06-18T10:46:26.960045",
                "definition": {
                    "en": "Remedial action suggested by the manufacturer"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430452",
                "key": "430452",
                "name": "known_incidents",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.558624",
                "updated_at": "2021-06-18T10:46:26.966000",
                "definition": {
                    "en": "Known incidents in connection to the recall"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430455",
                "key": "430455",
                "name": "release_date",
                "description": {
                    "en": ""
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.561138",
                "updated_at": "2021-06-18T10:46:26.971823",
                "definition": {
                    "en": "Release date of the recall"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430458",
                "key": "430458",
                "name": "support_hotline",
                "description": {
                    "en": "This can be from Kraftfahrtbundesamt, the manufacturer or other separate organizations. "
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.563631",
                "updated_at": "2021-06-18T10:46:26.977575",
                "definition": {
                    "en": "Support hotline for the recall"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430461",
                "key": "430461",
                "name": "fb_datetime",
                "description": {
                    "en": "The ISO-8601 timestamp of when the record was added to the data stream."
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.566053",
                "updated_at": "2021-06-18T10:46:26.983433",
                "definition": {
                    "en": "Timestamp of the record"
                },
                "basic_data_type": "Datetime",
                "semantic_type": "Datetime",
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            },
            {
                "id": "data_item_collections/430464",
                "key": "430464",
                "name": "fb_data_version",
                "description": {
                    "en": "Each new set of records that is added to the data stream gets automatically versioned by Fusionbase."
                },
                "meta": null,
                "created_at": "2021-06-16T12:16:18.568492",
                "updated_at": "2021-06-18T10:46:26.994883",
                "definition": {
                    "en": "Version of the record"
                },
                "basic_data_type": "String",
                "semantic_type": null,
                "semantic_tags": null,
                "data_streams": [
                    "data_streams/430410"
                ]
            }
        ],
        "source": {
            "_id": "data_sources/47480",
            "stream_specific": {
                "uri": "https://www.kba.de/DE/Home/home_node.html"
            }
        },
        "store_version": null,
        "data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b",
        "data_updated_at": "2023-06-16T10:41:28.220833",
        "data": [
            {
                "fb_id": "31f72e92f33bcfb39ad100d8b981c9ac",
                "kba_reference_number": "011209",
                "manufacturer_recall_code": "NC3I6515R (0797186)",
                "manufacturer_brand": "MERCEDES-BENZ LKW",
                "trade_name": "SPRINTER",
                "construction_year_start": 2011,
                "construction_year_end": 2013,
                "affected_vehicles_worldwide": 5799.0,
                "affected_vehicles_germany": 3368.0,
                "recall_supervised_by_kba": "supervised",
                "recall_description": "Entfernung unzulässiger Abschalteinrichtungen bzw. der unzulässigen Reduzierung der Wirksamkeit des Emissionskontrollsystems.",
                "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
                "remedial_action_by_the_manufacturer": "Software Steuergeräte aktualisieren.",
                "known_incidents": "unknown",
                "release_date": "2021-10-25",
                "support_hotline": "06986798274",
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "e8ffe1c04bc7f094520a13921e018579",
                "kba_reference_number": "011713",
                "manufacturer_recall_code": "30_2028161",
                "manufacturer_brand": "KTM",
                "trade_name": "125 SX, 125 XC, 150 SX",
                "construction_year_start": 2021,
                "construction_year_end": 2022,
                "affected_vehicles_worldwide": 5806.0,
                "affected_vehicles_germany": 104.0,
                "recall_supervised_by_kba": "supervised",
                "recall_description": "Defektes Zündsteuergerät führt zum Bruch des Pleuels. Es besteht erhöhte Sturzgefahr.",
                "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
                "remedial_action_by_the_manufacturer": "Austausch des Zündsteuergeräts.",
                "known_incidents": "Es sind derzeit 2 Schadenereignisse mit Unfallfolge oder Personenschäden bekannt.",
                "release_date": "2022-07-11",
                "support_hotline": "0962892110",
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "619f71bc1d0ddf6c7231af2019ecc2a4",
                "kba_reference_number": "012715",
                "manufacturer_recall_code": "21DC10",
                "manufacturer_brand": "HYUNDAI",
                "trade_name": "I30",
                "construction_year_start": 2021,
                "construction_year_end": 2022,
                "affected_vehicles_worldwide": 5858.0,
                "affected_vehicles_germany": 2958.0,
                "recall_supervised_by_kba": "supervised",
                "recall_description": "Durch eine nicht korrekte Ansteuerung der elektrischen Ölpumpe kann es zu einem plötzlichen Druckabfall im Doppelkupplungsgetriebe kommen.",
                "possible_restrictions_of_the_affected_vehicle_versions": "i30 N",
                "remedial_action_by_the_manufacturer": "Ein Softwareupdate wird auf das Getriebesteuergerät (TCU) aufgespielt.",
                "known_incidents": "unknown",
                "release_date": "2023-04-27",
                "support_hotline": "069380767212",
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "a80368505a45f8576b1eceea1e72138d",
                "kba_reference_number": "012543",
                "manufacturer_recall_code": "0061460700",
                "manufacturer_brand": "BMW",
                "trade_name": "7, I7",
                "construction_year_start": 2022,
                "construction_year_end": 2023,
                "affected_vehicles_worldwide": 6074.0,
                "affected_vehicles_germany": 580.0,
                "recall_supervised_by_kba": "supervised",
                "recall_description": "Softwarefehler kann zum Verlust der Initialisierung des Airbagsteuergeräts führen. Dadurch würden die Beifahrer-Front- und Knieairbags sowie die aktive Kopfstütze deaktiviert werden.",
                "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
                "remedial_action_by_the_manufacturer": "Die Steuergeräte (Sitzmodul) werden programmiert.",
                "known_incidents": "unknown",
                "release_date": "2023-02-23",
                "support_hotline": "089125016175",
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "439068622105a7c514cd708e2094eaad",
                "kba_reference_number": "012459",
                "manufacturer_recall_code": "26V",
                "manufacturer_brand": "IVECO",
                "trade_name": "S-WAY, T-WAY, X-WAY",
                "construction_year_start": 2022,
                "construction_year_end": 2022,
                "affected_vehicles_worldwide": 6279.0,
                "affected_vehicles_germany": 622.0,
                "recall_supervised_by_kba": "supervised",
                "recall_description": "Eine nicht konforme geschweißte Zylinderhalterung an der Kippkabine kann brechen, wenn das Fahrerhaus gekippt wird.",
                "possible_restrictions_of_the_affected_vehicle_versions": "Wenn die Chargenkennzeichnung eine der folgenden ist: NF3 / NF4 / NF5 / NG1 / NG2 / NG3 / NH4 / NH5 / NJ1 / NJ2 / NJ3 / NJ4 / NK1 / NK2 / NK3 / NK4 , muss die Halterung des Zylinders getauscht werden. Ist die Chargenkennzeichnung nicht sichtbar oder können die Zeichen nicht gelesen werden, sit die Halterung des Zylinders auszutauschen.",
                "remedial_action_by_the_manufacturer": "Überprüfung und ggf. Austausch der Halterung der Kippvorrichtung.",
                "known_incidents": "no_incidents",
                "release_date": "2023-02-09",
                "support_hotline": "07314085419",
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "b71c2f87c3f4a6310dce0fb54931991f",
                "kba_reference_number": "012284",
                "manufacturer_recall_code": "F-PEDAL",
                "manufacturer_brand": "MERCEDES-BENZ LKW",
                "trade_name": "E-ACTROS, E-AROCS, E- ATEGO",
                "construction_year_start": 2021,
                "construction_year_end": 2022,
                "affected_vehicles_worldwide": 6349.0,
                "affected_vehicles_germany": 2069.0,
                "recall_supervised_by_kba": "supervised",
                "recall_description": "Kurzschluss im Fahrpedalsensor kann zur Unterbrechung der Gasannahme und in der Folge zum Liegenbleiben des Fahrzeugs führen.",
                "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
                "remedial_action_by_the_manufacturer": "Überprüfung und ggf. Erneuerung des Fahrpedals",
                "known_incidents": "no_incidents",
                "release_date": "2022-11-16",
                "support_hotline": "+49 69 95 30 73 89",
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "0cd42887e6f0bc92f1b52e80fe564632",
                "kba_reference_number": "002000",
                "manufacturer_recall_code": "4",
                "manufacturer_brand": "MASERATI",
                "trade_name": "CILINDRI, GHIBLI, QUATTROPORTE",
                "construction_year_start": 1995,
                "construction_year_end": 1997,
                "affected_vehicles_worldwide": null,
                "affected_vehicles_germany": 110.0,
                "recall_supervised_by_kba": "supervised",
                "recall_description": "Möglicher Kraftstoffverlust an den Kraftstoffleitungen im Motorraum",
                "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
                "remedial_action_by_the_manufacturer": null,
                "known_incidents": "unknown",
                "release_date": "2008-01-01",
                "support_hotline": null,
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "5e7bee1560328da245cd993fc9c77355",
                "kba_reference_number": "001909",
                "manufacturer_recall_code": "163",
                "manufacturer_brand": "MASERATI",
                "trade_name": "QUATTROPORTE",
                "construction_year_start": 2007,
                "construction_year_end": 2007,
                "affected_vehicles_worldwide": null,
                "affected_vehicles_germany": 71.0,
                "recall_supervised_by_kba": "supervised",
                "recall_description": "Fehlerhafte Software führt zum Ausfall des Stabilitätsprogramms.",
                "possible_restrictions_of_the_affected_vehicle_versions": "Automatic",
                "remedial_action_by_the_manufacturer": null,
                "known_incidents": "unknown",
                "release_date": "2008-01-01",
                "support_hotline": null,
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "830fd08351a6ce095a2677500357c8f9",
                "kba_reference_number": "003195",
                "manufacturer_recall_code": "R29162",
                "manufacturer_brand": "VOLVO",
                "trade_name": "C30, S40, S60, S80, V50, V60, V70, XC60, XC70",
                "construction_year_start": 2010,
                "construction_year_end": 2010,
                "affected_vehicles_worldwide": null,
                "affected_vehicles_germany": 291.0,
                "recall_supervised_by_kba": "unsupervised",
                "recall_description": "Bei Fahrzeugen mit einem Fünfzylinder-Diesel (D5) sind die Kraftstoffleitungen möglicherweise nicht mit dem erforderlichen Anzugsdrehmoment am Motor befestigt worden. Dies kann zu Kraftstoffaustritt und folglich  zu einer verminderten Motorleistung und Kraftstoffgeruch führen. Ausgetretener Kraftstoff kann sich im Motorraum entzünden.",
                "possible_restrictions_of_the_affected_vehicle_versions": "unknown",
                "remedial_action_by_the_manufacturer": null,
                "known_incidents": "unknown",
                "release_date": "2011-02-21",
                "support_hotline": "02219393393",
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            },
            {
                "fb_id": "74044378a70c356b2c570f1dba775b30",
                "kba_reference_number": "008428",
                "manufacturer_recall_code": "18SMD-113",
                "manufacturer_brand": "LEXUS",
                "trade_name": "LS",
                "construction_year_start": 2017,
                "construction_year_end": 2018,
                "affected_vehicles_worldwide": 6600.0,
                "affected_vehicles_germany": 9.0,
                "recall_supervised_by_kba": "unsupervised",
                "recall_description": "Durch eine fehlerhafte Berechnung der Luftmasse kann es unter bestimmten Bedingungen bei der Verwendung  des Start-Stopp-Systems zum Absterben des Motors kommen.",
                "possible_restrictions_of_the_affected_vehicle_versions": "LS500",
                "remedial_action_by_the_manufacturer": "Neuprogrammierung des Motor-Steuergeräts",
                "known_incidents": "unknown",
                "release_date": "2018-12-12",
                "support_hotline": "022341026111",
                "fb_datetime": "2023-06-16T10:41:28.220000",
                "fb_data_version": "3e727ad8-5cf0-43a9-ae28-88c08421187b"
            }
        ]
    }