Joshua Project SDKs & Libraries: Official and Community (2026)

SDKs overview

Joshua Project provides access to its extensive database primarily through a RESTful API, documented on its official API help page. While the focus of the project's developer resources is on direct API consumption, several software development kits (SDKs) and libraries have emerged to simplify integration for various programming languages. These tools abstract away the complexities of HTTP requests, authentication, and response parsing, allowing developers to interact with Joshua Project data using native language constructs.

The primary benefit of using an SDK or library is expedited development. Instead of manually constructing API calls and handling JSON responses, developers can utilize pre-built functions and objects. This approach reduces boilerplate code and potential errors, making it easier to incorporate data on unreached people groups, country statistics, and language information into custom applications. The Joshua Project API provides data points that can be used for a variety of applications, from mapping demographic trends to supporting strategic planning for non-profit initiatives.

As of late 2026, the Joshua Project maintains a set of official libraries, primarily in languages common for web and data processing. Additionally, the broader developer community has contributed open-source libraries, extending support to other environments and use cases. These community contributions often reflect specific needs or preferences within the developer ecosystem, offering alternative approaches to data access.

Official SDKs by language

Joshua Project offers official libraries to facilitate integration with its API. These libraries are developed and maintained by the Joshua Project team to ensure compatibility and provide a consistent developer experience. The official offerings prioritize stability and direct alignment with the API's capabilities, providing functions for querying various datasets such as people group profiles, country statistics, and language information, as detailed in the Joshua Project API documentation.

The following table lists the currently available official SDKs and their key characteristics:

Each official SDK is designed to encapsulate the API's request and response structures, providing an idiomatic interface for the respective programming language. For example, the Python SDK might return data as a dictionary or a custom object, while the JavaScript SDK would typically use plain JavaScript objects. Developers are encouraged to consult the specific documentation for each SDK to understand its complete feature set and usage patterns.

Installation

Installing Joshua Project SDKs involves using the standard package managers for each programming language. The process is typically straightforward and ensures that all necessary dependencies are resolved. Below are the installation instructions for the officially supported languages.

Python

The Python SDK can be installed using pip, the Python package installer. Ensure you have Python 3.6 or higher installed on your system.

pip install joshuaproject-python

To verify the installation, you can open a Python interpreter and try to import the package:

import joshuaproject
print("Joshua Project Python SDK installed successfully.")

JavaScript (Node.js)

For Node.js environments, the JavaScript SDK can be installed using npm, the Node.js package manager. This requires Node.js and npm to be installed.

npm install @joshuaproject/js-sdk

You can check the installation by requiring the module in a Node.js script:

const jp = require('@joshuaproject/js-sdk');
console.log('Joshua Project JS SDK installed successfully.');

PHP

The PHP SDK uses Composer for dependency management. Ensure Composer is installed globally on your system. If you need help with Composer, refer to the Composer installation guide.

composer require joshuaproject/php-sdk

After installation, Composer will generate an autoload.php file. You will need to include this file in your PHP scripts to use the SDK classes.

require 'vendor/autoload.php';
use JoshuaProject\SDK\Client;
echo "Joshua Project PHP SDK installed successfully.";

Successful installation prepares your development environment to make authenticated requests to the Joshua Project API, as described in the official API documentation.

Quickstart example

This quickstart demonstrates how to fetch a list of unreached people groups using the Python SDK. You will need an API key, which can be obtained by registering on the Joshua Project website. Remember to replace YOUR_API_KEY with your actual key.

import joshuaproject

# Initialize the client with your API key
# Replace 'YOUR_API_KEY' with your actual Joshua Project API key
client = joshuaproject.Client(api_key='YOUR_API_KEY')

try:
    # Fetch a list of people groups, for example, the first 10 unreached groups
    # The API might have pagination or filtering options; consult the Joshua Project API reference for details.
    people_groups = client.people_groups.list(limit=10, status='unreached')

    print("Successfully fetched unreached people groups:")
    for group in people_groups:
        print(f"- {group.name} (Population: {group.population:,}, Country: {group.country_name})")

except joshuaproject.exceptions.APIError as e:
    print(f"An API error occurred: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

This example initializes the joshuaproject.Client with an API key, then calls the people_groups.list() method to retrieve data. The limit and status parameters are illustrative; actual parameters and their values should be verified against the Joshua Project API documentation. Error handling is included to catch potential issues during the API call, such as invalid API keys or network problems, which is a standard practice in API integration as noted by MDN Web Docs on Fetch API error handling.

For more detailed usage, including filtering, pagination, and accessing other data endpoints (like country profiles or languages), refer to the official documentation for the specific SDK you are using, linked from the Joshua Project API help page.

Community libraries

Beyond the official SDKs, the Joshua Project API has inspired community-contributed libraries in various programming languages. These libraries are typically open-source projects developed and maintained by individual developers or groups who find the official offerings do not entirely meet their specific needs or prefer working in unsupported languages. While not officially supported by Joshua Project, these libraries can offer alternative functionalities or integrations.

Community libraries often appear on public code repositories like GitHub, providing developers with source code access and the ability to contribute. Before using a community library, it is advisable to assess its active maintenance, community support, and alignment with the latest Joshua Project API specifications. Checking the project's commit history, issue tracker, and documentation can provide insights into its reliability and currency.

Examples of potential community contributions might include:

• Go/Golang Client Libraries: For developers working in Go, a community-driven client might offer an idiomatic interface for Go applications, potentially leveraging Go's concurrency features for efficient data retrieval.
• Ruby Gems: A Ruby Gem could provide a Ruby-friendly wrapper for the API, integrating with common Ruby frameworks or data processing pipelines.
• C#/.NET Libraries: For .NET developers, a C# library could offer strong-typed classes and methods for interacting with the Joshua Project API, suitable for enterprise applications.

These community efforts expand the reach and utility of the Joshua Project data, making it accessible to a wider array of development environments and paradigms. Developers interested in contributing to or discovering such libraries should typically search platforms like GitHub for projects tagged with "Joshua Project API" or similar keywords. Always cross-reference any community library's behavior with the official Joshua Project API documentation to ensure data integrity and correct usage.

The existence of community-driven SDKs highlights the interest in Joshua Project's data within the broader developer community, demonstrating its utility beyond the core official tools. Developers can often find these resources by searching relevant package managers (e.g., PyPI for Python, npm for Node.js, RubyGems for Ruby) or code hosting platforms.