SDKs overview

GeoScore provides Software Development Kits (SDKs) to facilitate integration with its Location Sentiment API and Geo-Contextual NLP services. These SDKs are designed to abstract the underlying HTTP requests and JSON parsing, allowing developers to interact with the GeoScore platform using native language constructs. The primary goal of offering SDKs is to reduce development time and potential errors when building applications that leverage GeoScore's data and analytics capabilities for hyperlocal sentiment analysis and geo-based market research.

The GeoScore API is accessible via standard RESTful HTTP requests, but SDKs offer a higher level of abstraction. They manage aspects such as API key authentication, request payload construction, and response deserialization. This approach is consistent with common practices in API integration, where SDKs serve as a bridge between a raw API endpoint and a developer's application code. The official GeoScore documentation provides comprehensive guides for using these SDKs, along with API reference materials detailing all available endpoints and parameters.

While official SDKs are provided for commonly used programming languages, the GeoScore API can be accessed from any language capable of making HTTP requests. This flexibility is a characteristic of RESTful APIs, which adhere to principles that enable broad interoperability across different technology stacks. Developers can refer to general guides on HTTP status codes and JSON data format to understand the fundamental mechanics of API communication, even when using an SDK.

Official SDKs by language

GeoScore maintains official SDKs for Python and Node.js. These SDKs are developed and supported by GeoScore to ensure compatibility with the latest API versions and features. They are the recommended tools for integrating GeoScore services into applications built with these languages.

The following table summarizes the official SDKs available:

Language Package Name Install Command Maturity
Python geoscore-python pip install geoscore-python Stable
Node.js @geoscore/node npm install @geoscore/node Stable

Each SDK provides a client library that encapsulates the API interactions. For example, the Python SDK might offer methods like client.analyze_sentiment(latitude, longitude, text), which internally construct the necessary HTTP request to the GeoScore Location Sentiment API endpoint. Developers can find detailed usage instructions and method signatures in the GeoScore API reference documentation.

Installation

Installation of the GeoScore official SDKs typically follows standard package management procedures for their respective languages.

Python SDK Installation

To install the GeoScore Python SDK, use pip, the Python package installer. Ensure you have a compatible Python version installed (typically Python 3.7 or newer).

pip install geoscore-python

After installation, you can import the library into your Python projects. For detailed instructions on managing Python packages, refer to the official Python documentation on installing packages.

Node.js SDK Installation

For Node.js projects, the GeoScore SDK is available via npm, the Node.js package manager. Ensure Node.js and npm are installed on your system.

npm install @geoscore/node

Once installed, the package can be imported into your JavaScript or TypeScript files. The npm install command reference provides additional options for managing Node.js dependencies.

Quickstart example

The following quickstart examples demonstrate how to make a basic API call using the official GeoScore SDKs to perform a location sentiment analysis. These examples assume you have already installed the respective SDK and have a valid GeoScore API key.

Python Quickstart

This Python example initializes the GeoScore client and performs a sentiment analysis for a given location and text input:

from geoscore import GeoScoreClient
import os

# Replace 'YOUR_API_KEY' with your actual GeoScore API Key
# It's recommended to store your API key in an environment variable
api_key = os.environ.get('GEOSCORE_API_KEY', 'YOUR_API_KEY')

client = GeoScoreClient(api_key=api_key)

latitude = 34.0522
longitude = -118.2437
text_input = "The restaurant at this location has amazing food and great service!"

try:
    response = client.analyze_location_sentiment(
        latitude=latitude,
        longitude=longitude,
        text=text_input
    )
    print("Location Sentiment Analysis Result:")
    print(f"  Sentiment: {response.sentiment}")
    print(f"  Score: {response.score}")
    print(f"  Keywords: {', '.join(response.keywords)}")
except Exception as e:
    print(f"An error occurred: {e}")

Node.js Quickstart

This Node.js example demonstrates how to use the GeoScore Node.js SDK to analyze sentiment for a specific geographical point and text:

const { GeoScoreClient } = require('@geoscore/node');

// Replace 'YOUR_API_KEY' with your actual GeoScore API Key
// It's recommended to store your API key in an environment variable
const apiKey = process.env.GEOSCORE_API_KEY || 'YOUR_API_KEY';

const client = new GeoScoreClient(apiKey);

const latitude = 34.0522;
const longitude = -118.2437;
const textInput = "This park is beautiful and always well-maintained. A perfect spot for a picnic.";

async function analyzeSentiment() {
  try {
    const response = await client.analyzeLocationSentiment({
      latitude,
      longitude,
      text: textInput,
    });
    console.log('Location Sentiment Analysis Result:');
    console.log(`  Sentiment: ${response.sentiment}`);
    console.log(`  Score: ${response.score}`);
    console.log(`  Keywords: ${response.keywords.join(', ')}`);
  } catch (error) {
    console.error(`An error occurred: ${error.message}`);
  }
}

analyzeSentiment();

These examples illustrate the basic pattern for interacting with GeoScore's API using the SDKs. For more advanced features, such as batch processing, error handling, or specific Geo-Contextual NLP queries, developers should consult the GeoScore official documentation.

Community libraries

While GeoScore provides official SDKs, the open nature of its RESTful API allows for the development of community-contributed libraries in various programming languages. These libraries are typically open-source projects maintained by individual developers or groups within the GeoScore user community. Community libraries can offer support for languages not officially covered by GeoScore, or provide alternative implementations, utility functions, and integrations with other frameworks.

Developers interested in contributing to or using community libraries should exercise due diligence. It is advisable to review the project's documentation, check its activity on platforms like GitHub, and assess its maintenance status and compatibility with the latest GeoScore API versions. Community contributions often emerge organically based on developer needs and preferences, and their quality and feature sets can vary.

As of late 2025, there are no widely adopted community-driven SDKs or libraries explicitly listed by GeoScore. Developers seeking to contribute to the GeoScore ecosystem in languages other than Python or Node.js may consider initiating new open-source projects. Such projects could potentially be listed on the GeoScore developer resources page if they meet certain criteria for quality and maintenance. The GeoScore API is designed to be language-agnostic, meaning developers can interact with it using standard HTTP clients available in virtually any programming environment, such as fetch in JavaScript, requests in Python, or Java's HttpClient.