SDKs overview

Chainpoint provides software development kits (SDKs) and libraries designed to facilitate the integration of its blockchain-based timestamping services into various applications. These tools abstract the complexities of interacting directly with the Chainpoint API and the underlying Bitcoin blockchain, allowing developers to focus on their application logic. The primary official SDK is a JavaScript client, intended for Node.js environments, which supports the core functionalities of submitting data hashes for timestamping and retrieving/verifying Chainpoint proofs Chainpoint developer documentation.

Integrating with Chainpoint enables developers to establish an immutable, verifiable record of data at a specific point in time. This is achieved by anchoring hashes of data onto the Bitcoin blockchain. The provided SDKs streamline this process, from preparing data to generating and validating Chainpoint proofs. The architecture is designed to be developer-friendly, offering command-line interfaces (CLIs) and programmatic access for common operations.

The Chainpoint ecosystem includes:

  • Chainpoint API: The core service endpoint for submitting and retrieving proofs.
  • Chainpoint Client (Node.js): An official JavaScript library for programmatic interaction.
  • Chainpoint CLI: A command-line tool built on the client library for direct developer use and scripting.

These tools collectively support use cases such as proving document integrity, timestamping digital assets, and ensuring data immutability across various industries. The use of a decentralized ledger like Bitcoin for timestamping provides a robust and tamper-evident mechanism for establishing data provenance Mozilla's blockchain glossary.

Official SDKs by language

Chainpoint primarily offers an official SDK for JavaScript environments, specifically tailored for Node.js. This client library encapsulates the functionality needed to interact with the Chainpoint network, from hashing data to submitting it for timestamping and verifying the resulting proofs. The design prioritizes ease of use and integrates well within existing Node.js projects.

Language Package Name Install Command Maturity
JavaScript (Node.js) chainpoint-client npm install chainpoint-client Stable

This official client is actively maintained and serves as the recommended method for developers to integrate Chainpoint's timestamping capabilities into their applications. It provides a structured way to handle the cryptographic operations and network requests required for interacting with the Chainpoint API.

Installation

The installation of the official Chainpoint SDK is straightforward, leveraging standard package managers for Node.js projects.

Prerequisites

  • Node.js (version 12 or higher recommended)
  • npm (Node Package Manager) or yarn

Installing the Chainpoint Client

To install the chainpoint-client package, navigate to your project directory in the terminal and execute one of the following commands:

Using npm:

npm install chainpoint-client

Using yarn:

yarn add chainpoint-client

This command downloads the latest stable version of the Chainpoint client library and adds it as a dependency to your project's package.json file. Once installed, the library can be imported and used within your Node.js application.

Installing the Chainpoint CLI

For command-line usage, the Chainpoint CLI can be installed globally:

Using npm:

npm install -g chainpoint-cli

This allows you to access Chainpoint functionalities directly from your terminal, which can be useful for testing, scripting, or manual operations without writing a full application. The CLI offers commands for submitting hashes, getting proofs, and verifying them. For a complete list of CLI commands and their usage, refer to the Chainpoint CLI guide in the developer documentation.

Quickstart example

This quickstart example demonstrates how to use the official Chainpoint JavaScript client to submit a data hash for timestamping and then retrieve and verify its proof. This process involves generating a hash, submitting it to the Chainpoint network, waiting for the proof to be anchored on the blockchain, and finally verifying its integrity.

Step 1: Create a simple Node.js project

First, create a new directory for your project and initialize a Node.js project:

mkdir chainpoint-quickstart
cd chainpoint-quickstart
npm init -y

Step 2: Install the Chainpoint Client

Install the chainpoint-client in your project:

npm install chainpoint-client

Step 3: Write the quickstart code

Create a file named index.js and add the following code. This example will hash a simple string, submit it, and then attempt to retrieve and verify the proof.

const chainpoint = require('chainpoint-client');

async function quickstart() {
  const data = 'My important document content ' + new Date().toISOString();
  const hash = chainpoint.utils.get             Sha256Hash(data);
  console.log(`Original Data: "${data}"`);
  console.log(`SHA256 Hash to submit: ${hash}`);

  try {
    // Submit the hash to Chainpoint
    const submitResponse = await chainpoint.submitHashes([hash]);
    const submitId = submitResponse.hashes[0].id;
    console.log(`Hash submitted. Chainpoint ID: ${submitId}`);
    console.log('Waiting for proof to be anchored... (this may take a few minutes)');

    // Poll for the proof. Production applications should use webhooks or a more robust polling mechanism.
    let proof = null;
    while (!proof) {
      await new Promise(resolve => setTimeout(resolve, 30 * 1000)); // Wait 30 seconds
      console.log('Attempting to get proof...');
      const getProofResponse = await chainpoint.getProofs([submitId]);
      if (getProofResponse.proofs.length > 0) {
        proof = getProofResponse.proofs[0];
        console.log('Proof retrieved!');
      }
    }

    // Verify the proof
    const verifyResponse = await chainpoint.verifyProofs([proof]);
    const verificationResult = verifyResponse.proofs[0];

    if (verificationResult.verified) {
      console.log('Proof successfully verified!');
      console.log(`Anchor ID: ${verificationResult.anchor_id}`);
      console.log(`Blockchain: ${verificationResult.hash_id_node.substring(0,2) === 'bc' ? 'Bitcoin' : 'Unknown'}`);
    } else {
      console.error('Proof verification failed.');
      console.error(verificationResult.message || 'Unknown error during verification.');
    }

  } catch (error) {
    console.error('An error occurred:', error.message);
  }
}

quickstart();

Step 4: Run the quickstart example

Execute the script from your terminal:

node index.js

The script will output the submitted hash, the Chainpoint ID, and then poll for the proof until it is available and verified. This process can take several minutes as it depends on the Chainpoint network's anchoring schedule and blockchain confirmation times Chainpoint API reference.

Community libraries

While Chainpoint provides an official JavaScript client and CLI, the open-source nature of the Chainpoint protocol and the underlying blockchain technology encourages community contributions. Over time, developers have created libraries and integrations in various programming languages to interact with the Chainpoint network, although these may not always be officially maintained or supported by the Chainpoint project itself.

As of late 2026, the primary focus for official development remains with the JavaScript ecosystem, given its prevalence in web and server-side applications. However, the Chainpoint API is a standard RESTful API, which means it can be consumed by any programming language capable of making HTTP requests. Developers often build wrappers or direct API integrations in languages like Python, Go, and Java to suit their specific project needs.

When considering community-developed libraries, it is important for developers to evaluate several factors:

  • Maintenance Status: Is the library actively maintained and compatible with the latest Chainpoint API versions?
  • Documentation: Is there clear and comprehensive documentation for usage and integration?
  • Community Support: Is there an active community or repository where issues are addressed?
  • Security Audit: For critical applications, has the library undergone any security review or audit?

Developers who require Chainpoint integration in languages other than JavaScript may need to consult community forums, GitHub repositories, or develop custom clients based on the official Chainpoint API specifications. This approach ensures maximum flexibility and control over the implementation, while adhering to the core principles of the Chainpoint protocol for data integrity and immutability.

The decentralization aspect of blockchain technology, as utilized by Chainpoint, means that the core verification logic can often be reimplemented independently, as long as it correctly interprets the Chainpoint proof structure and the underlying blockchain transactions IETF RFC 6962 on Certificate Transparency (which uses similar Merkle tree concepts). This allows for bespoke solutions in environments where an official SDK is not available.