Chainpoint

Overview

Chainpoint offers an API and client-side tools for creating a timestamp proof of data using the Bitcoin blockchain. The core function of Chainpoint is to cryptographically link a piece of data to specific blocks in a blockchain, thereby establishing an immutable record of its existence at a particular time. This process, known as 'anchoring', allows users to prove that data existed at a certain point without revealing the data itself.

The service is designed for developers and organizations that require verifiable proof of data integrity and immutability. Typical use cases include legal document timestamping, intellectual property protection, audit trail generation, and digital asset management. Chainpoint utilizes a two-step process: first, a hash of the data is generated, and then this hash is embedded into the Bitcoin blockchain. This method leverages the decentralized and tamper-resistant nature of blockchain technology to provide a high degree of confidence in the timestamp's validity.

Chainpoint provides a developer experience that includes a straightforward API and a Node.js client library. The documentation offers practical examples for common integration scenarios, making it accessible for developers to incorporate blockchain-based timestamping into their applications. This approach addresses the need for non-repudiation in digital transactions and records, where proving the exact time of creation or modification is critical. The architecture is designed to scale, allowing for the processing of numerous anchors efficiently by aggregating multiple data hashes into a single blockchain transaction.

The concept of using blockchain for timestamping is supported by various industry discussions on data integrity and digital trust. For instance, the World Wide Web Consortium (W3C) has explored similar concepts related to Decentralized Identifiers (DIDs), which often rely on verifiable credentials and immutable ledgers to establish trust in digital interactions. Chainpoint's method aligns with these principles by providing a verifiable, timestamped proof of data existence.

Chainpoint is suitable for a range of applications where data immutability is paramount. Examples include verifying the integrity of journalistic content, proving the existence of scientific research prior to publication, or creating an unalterable record of contractual agreements. The service eliminates reliance on centralized timestamping authorities by leveraging the public and transparent nature of the Bitcoin blockchain, providing an auditable and globally verifiable proof.

Key features

• Blockchain Anchoring: Generates cryptographic proofs by embedding data hashes into the Bitcoin blockchain, ensuring data immutability and verifiable timestamps (Chainpoint architecture details).
• Data Integrity Verification: Allows users to cryptographically verify if a piece of data has been altered since it was timestamped by comparing its current hash with the anchored hash.
• Proof Generation: Creates Chainpoint Proofs, which are JSON-LD documents containing the necessary cryptographic data to independently verify a timestamp on the Bitcoin blockchain (Proof specification).
• Client Libraries: Offers client libraries (e.g., Node.js) to simplify integration for developers, providing functions to submit data for timestamping and retrieve proofs.
• Command Line Interface (CLI): Provides a command-line tool for direct interaction with the Chainpoint network, enabling users to anchor files and verify proofs without custom code.
• Scalable Timestamping: Aggregates multiple data hashes into a single transaction on the blockchain, optimizing transaction costs and throughput for high-volume timestamping.

Pricing

Chainpoint offers a free tier for initial usage and structured plans based on the volume of anchors required. As of May 28, 2026, pricing is as follows:

For detailed and up-to-date pricing information, refer to the official Chainpoint pricing page.

Common integrations

• Document Management Systems: Integrate to timestamp critical documents like contracts, legal filings, or intellectual property records, ensuring their integrity over time.
• Content Management Platforms: Apply timestamps to digital content such as articles, images, or videos to establish proof of creation and protect against unauthorized alterations.
• Audit Trails and Logging: Use Chainpoint to create immutable audit trails for system logs, financial transactions, or regulatory compliance data.
• IoT Device Data: Timestamp data streams from IoT devices to ensure the integrity and authenticity of sensor readings or operational data.
• Digital Asset Management (DAM): Timestamp digital assets to prove ownership history and content integrity, particularly for NFTs or other unique digital items.

Alternatives

• OpenTimestamps: An open-source, provably secure timestamping system that uses the Bitcoin blockchain without requiring a centralized service.
• Guardtime: Provides blockchain-based data integrity and security solutions for various industries, often focusing on enterprise-level data provenance.
• OriginStamp: Offers a timestamping service that uses multiple public blockchains to generate immutable proofs for digital content and data.

Getting started

To begin using Chainpoint, you can install the Chainpoint client for Node.js and submit your first data hash for timestamping. This example demonstrates how to create a hash of a string, submit it to the Chainpoint network, and retrieve the proof. Ensure Node.js is installed before proceeding.

// Install the Chainpoint client library
npm install chainpoint-client

// hello-chainpoint.js
const chainpoint = require('chainpoint-client')
const crypto = require('crypto')

async function anchorData() {
  // 1. Define the data to be timestamped
  const dataToAnchor = 'This is a test data string for Chainpoint timestamping.'

  // 2. Hash the data (SHA256 is commonly used)
  const dataHash = crypto.createHash('sha256').update(dataToAnchor).digest('hex')
  console.log(`Data Hash: ${dataHash}`)

  // 3. Submit the hash to the Chainpoint network
  console.log('Submitting hash for timestamping...')
  const submitResponse = await chainpoint.submitHashes([dataHash])
  const anchorId = submitResponse[0].anchorId
  console.log(`Anchor ID: ${anchorId}`)

  // 4. Poll for the Chainpoint proof (may take some time)
  console.log('Polling for Chainpoint proof...')
  let proof = null
  while (!proof) {
    await new Promise(resolve => setTimeout(resolve, 30000)) // Wait 30 seconds
    const proofResponse = await chainpoint.getProofs([anchorId])
    if (proofResponse && proofResponse[0].proof) {
      proof = proofResponse[0].proof
      console.log('Proof received!')
    } else {
      console.log('Proof not yet available, waiting...')
    }
  }

  // 5. Verify the proof
  console.log('Verifying proof...')
  const verifyResponse = await chainpoint.verifyProofs([proof])
  if (verifyResponse[0].verified) {
    console.log('Proof successfully verified!')
  } else {
    console.error('Proof verification failed.')
  }

  console.log('Full Proof Object:')
  console.log(JSON.stringify(proof, null, 2))
}

anchorData().catch(console.error)

To run this example:

1. Save the code above as hello-chainpoint.js.
2. Open your terminal or command prompt in the directory where you saved the file.
3. Run node hello-chainpoint.js.

The script will output the data hash, the anchor ID, and then poll until the proof is available and verified. This process involves waiting for the Bitcoin blockchain to confirm the transaction containing the aggregated hash, which can take several minutes to an hour or more depending on network conditions.