stampd.io - Blockchain Stamping and Non-fungible Tokens (NFT)

Using public blockchains to
timestamp and own your digital creations
with indelible proof.

Drop any file here

Select a file from your device

Your files will not be uploaded
but only processed by your browser

Non-fungible Tokens

Digital

Mint NFT

Create (mint) an NFT and tokenize your digital creations.

Physical

Mint NFT with NFC tag

Create (mint) an NFT and tokenize any physical object using near field communication physical tags.
NFC tag example The cryptocurrency transaction ID is the unique identifier of your transaction on the blockchain.

Blockchain timestamping and NFT creation

Document issuance history certification

Timestamping and NFT creation of issued documents can allow a public verification of the issue history which is permanently recorded on the public blockchains. There is absolutely no method of potential malicious amendment at a later stage.

Blockchain stamping as well as NFT minting allows a public verification of the document’s date, authenticity, origin, integrity & content without publicly exposing the content itself.

Certify possession of original content

Content signed by the user before timestamping, can be undeniably claimed to have been in the user’s possession & knowledge at the time of the blockchain time stamping. A simple reference to the respective public blockchain ledger transaction ID can undeniably prove this with absolutely no doubt.

NFT linked with the original content is owned by the originator (the one in control of the address initially receiving the NFT). The owner can transfer their rights to someone else by sending the NFT to a different address.

Blockchain based intellectual property

If the timestamped signed content is original, authentic, non-stolen, non-copied, unplagiarized work then the user has a very strong argument to support intellectual property.

The immutable blockchain timestamp or NFT can become proof of prior art existence to any subsequent claim of authenticity by others in the future for the same or similar content.

Serving all industries

Law

Lawyers and general notaries verify signatures in contracts and other legal documents. Blockchain timestamping offers an additional layer of trustless immutable verification of the exact time when these were verified.

Research

Timestamping of original research papers on the public blockchains allows the researchers to take credit of the pertinent work. Any later plagiarism attempt can easily be proven and discounted by the blockchain timestamping.

Media

Engineering work, design, reports & drawings can all be timestamped on the blockchain to allow subsequent trustless verification of their integrity, authenticity, authorship and date of issuance.

Engineering

Engineering work, design, reports & drawings can all be timestamped on the blockchain to allow subsequent trustless verification of their integrity, authenticity, authorship and date of issuance.

Academia

Academics, scientists and university students may use blockchain timestamping to allow public distribution of issues such as essays, papers, projects, exam questions with immutable integrity proof.

Design

Designers can now link their work with their name and a particular date & time. In this way they can share it with others without worrying for any third party presenting it as their own in the future.

Plugins Galore

WordPress plugin to notarize instantly any post content

Chrome extension to notarize page content or screenshot of visible area of active tab

Desktop applications for Windows and Linux to notarize any file on your file system

API Reference

Introduction

Apart from the web interface, stampd.io’s blockchain stamping functionality is also possible through an API interaction.

In order to get access to our API please create an account.

The stampd.io server endpoint provides functionality for the following:

Authentication with our service
It allows posting a SHA256 hash on Bitcoin’s, Bitcoin Cash’s, Dash’s Blockchain
It provides feedback on whether a SHA256 hash has been stamped on the selected blockcha through stampd.io and whether the pertinent transaction has been included in a block with the appropriate confirmations
It stores metadata for your stampings and can share the PDF certificates created with e-mail addresses specified in parameters

All of our endpoints return JSON objects or XML as per the following.

Authenticate

The following endpoint is used in order to authenticate with our service. For security reasons, the registered user will receive a client id and secret key which will be used in order to authenticate. Authentication is performed by maintaining this key in the request headers or by passing it as a parameter in each request. Use the response_format parameter to choose between JSON or XML formatter responses.

If you are already registered you can get your API credentials here.

URL	https://stampd.io/api/v2/init
Method	GET
Parameters	client_id, secret_key
Optional	response_format

Post a hash on the Blockchain

The POST hash API call will post a hash on the blockchain of your choice. This endpoint will also allow you to store metadata to your stamping: meta_filename, meta_emails, meta_notes, meta_category. The meta_emails parameter is used to share the stamping certificate with a comma-separated list of e-mail addresses.

You can pass your session id via the sess_id parameter if you don’t wish to use the default way of passing session_id through the headers.

URL	https://stampd.io/api/v2/hash
Method	POST
Parameters	hash, blockchain
Optional	sess_id, response_format, meta_filename, meta_emails, meta_notes, meta_category

Check whether a hash has been stamped

The GET hash API call will check whether a hash has been posted on the selected blockchain. This endpoint can also be used to fetch the transaction ids, urls, or other metadata associated with the stamps that you have created.

URL	https://stampd.io/api/v2/hash
Method	GET
Parameters	hash, blockchain
Optional	sess_id

Responses

Success

{  
   "message":"Blockchain stamping confirmed with at least 2 blockchain confirmations",
   "type":"stampdAPISuccess",
   "code":302,
   "txid":"TRANSACTION_ID",
   "internal_id":"INTERNAL_ID",
   "url":"STAMPING_URL"
}

Success (user owns stamping)

{  
   "message":"Blockchain stamping confirmed with at least 2 blockchain confirmations",
   "type":"stampdAPISuccess",
   "code":302,
   "txid":"TRANSACTION_ID",
   "internal_id":"INTERNAL_ID",
   "url":"STAMPING_URL"
   "meta_filename":"FILENAME",
   "meta_category":"CATEGORY",
   "meta_notes":"NOTES",
   "meta_emails":"EMAILS",
}

Notice

{  
   "message":"Hash stamping confirmed to have been transmitted on the Bitcoin network through stampd.io but pertinent transaction is still pending to have 2 blockchain confirmations",
   "type":"stampdAPINotice",
   "code":201
}

Error

{  
   "message":"Hash has not been stamped on the blockchain through stampd.io",
   "type":"stampdAPIError",
   "code":107
}

Code samples

Below you will find sample codes to help you kick-start your project using our API.

Link to github

<?php

// Variables

$client_id  = ''; // Enter the client ID provided by stampd.io
$secret_key = ''; // Enter the secret key provided by stampd.io
$blockchain = ''; // BTC, ETH, BCH, DASH, FCT
$hash       = ''; // Enter your hash

// Functions

/*
 * Perform POST cURL
 *
 * $url string API URL
 * $fields array Fields that will be converted into URL params
 */
function stampd_perform_post_curl( $url, $fields = array() ) {
	$fields_string = '';

	foreach ( $fields as $key => $value ) {
		$fields_string .= $key . '=' . $value . '&';
	}
	$fields_string = rtrim( $fields_string, '&' );

	$ch = curl_init();
	curl_setopt( $ch, CURLOPT_URL, $url );
	curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
	curl_setopt( $ch, CURLOPT_POST, count( $fields ) );
	curl_setopt( $ch, CURLOPT_POSTFIELDS, $fields_string );
	$res = curl_exec( $ch );
	curl_close( $ch );

	return json_decode( $res );
}

/*
 * Perform plain get contents
 *
 * $url string API URL
 */
function stampd_perform_get_contents( $url ) {
	$res = file_get_contents( $url );

	return json_decode( $res );
}

/*
 * API Auth call
 *
 * $auth_url string API URL
 * $client_id string Client ID
 * $secret_key string Secret key
 */
function stampd_api_auth_call( $auth_url, $client_id, $secret_key ) {
	$url = $auth_url . '/init?client_id=' . $client_id . '&secret_key=' . $secret_key;

	return stampd_perform_get_contents( $url );
}

// Auth

$url           = 'https://stampd.io/api/v2';
$auth_response = stampd_api_auth_call( $url, $client_id, $secret_key );

// Check auth success

if ( is_object( $auth_response ) && property_exists( $auth_response, 'code' ) && $auth_response->code === 300 ) {
	// retrieve the session ID required for auth for other commands
	$session_id = $auth_response->session_id;

	// Post hash
	$fields = array(
		'requestedURL' => '/hash',
		'force_method' => 'POST', // method can also be forced via a parameter
		'sess_id'   => $session_id, // new param name: sess_id
		'blockchain'   => $blockchain,
		'hash'         => $hash,
//		'meta_emails'   => $email,
//		'meta_notes'    => $notes,
//		'meta_filename' => $filename,
//		'meta_category' => ! stampd_empty( $cat_obj ) ? $cat_obj->name : null,
	);

	$post_response = stampd_perform_post_curl( $url . '.php', $fields );

	var_dump( $post_response );

} else {
	die( 'API Authentication failed.' );
}

# Requirements
# - Have Ruby installed
# - Install json. Run gem install json
# - Run ruby _apitest.rb

require 'net/http'
require 'rubygems'
require 'uri'
require 'json'

# Variables

client_id = ''
secret_key = ''
blockchain = 'DASH'
hash = ''

# Statics

api_url_base = 'https://stampd.io/api/v2.php' # using direct script access in Ruby
# api_url_base = 'http://dev.stampd.io/api/v2.php'

# Login to API service

uri = URI.parse(api_url_base)
args = {requestedURL: '/init', client_id: client_id, secret_key: secret_key}
uri.query = URI.encode_www_form(args)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = api_url_base.match(/^https/)

login_request = Net::HTTP::Get.new(uri.request_uri)

login_response = http.request(login_request)
login_json = JSON.parse(login_response.body)
puts login_json
# login_json['message']
# login_json['type']
# login_json['code']
# login_json['session_id']

if login_json.key?('code') && login_json['code'] == 300
  puts 'Logged in successfully'
else
  puts 'Login failed, exiting'
  abort
end

# Post a hash

uri = URI.parse(api_url_base)
args = {requestedURL: '/hash',
        sess_id: login_json['session_id'],
        hash: hash,
        blockchain: blockchain,
        # meta_emails: '',
        # meta_notes: '',
        # meta_filename: '',
        # meta_category: '',
}
uri.query = URI.encode_www_form(args)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = api_url_base.match(/^https/)

post_request = Net::HTTP::Post.new(uri.request_uri)

post_response = http.request(post_request)
post_json = JSON.parse(post_response.body)
puts post_json
# post_json['message']
# post_json['type']
# post_json['code']
# post_json['stamps_remaining']

# Get a hash

uri = URI.parse(api_url_base)
args = {requestedURL: '/hash',
        sess_id: login_json['session_id'],
        hash: hash,
        blockchain: blockchain
}
uri.query = URI.encode_www_form(args)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = api_url_base.match(/^https/)

get_request = Net::HTTP::Get.new(uri.request_uri)

get_response = http.request(get_request)
get_json = JSON.parse(get_response.body)
puts get_json
# post_json['message']
# post_json['type']
# post_json['code']
# post_json['txid']

# Requirements
# - Have Python installed
# - Install pipenv
# - Install requests library. Run pipenv install requests
# - Run pipenv shell in order to use this env
# - Run py _apitest.py

import sys
import json
from collections import namedtuple
import requests

# Variables

client_id = ''
secret_key = ''
blockchain = ''
hash = ''

# Statics

api_url_base = 'https://stampd.io/api/v2'
# api_url_base = 'http://dev.stampd.io/api/v2'

# Login to API service

login_request = requests.get(api_url_base + '/init?client_id=' + client_id + '&secret_key=' + secret_key)
login_json = login_request.json()
print(login_json)
# login_json['message']
# login_json['type']
# login_json['code']
# login_json['session_id']

if 'code' in login_json and login_json['code'] == 300:
    print('Logged in successfully')
else:
    print('Login failed, exiting')
    sys.exit()

# Post a hash

post_request = requests.post(api_url_base + '/hash',
                             data={
                                 'sess_id': login_json['session_id'],
                                 'blockchain': blockchain,
                                 'hash': hash,
                                 # 'meta_emails': '',
                                 # 'meta_notes': '',
                                 # 'meta_filename': '',
                                 # 'meta_category': '',
                             })
post_json = post_request.json()
print(post_json)
# post_json['message']
# post_json['type']
# post_json['code']
# post_json['stamps_remaining']

# Get a hash

get_request = requests.get(
    api_url_base + '/hash?hash=' + hash + '&blockchain=' + blockchain + '&sess_id=' + login_json['session_id'])
get_json = get_request.json()
print(get_json)
# get_json['message']
# get_json['type']
# get_json['code']
# get_json['txid']

const qs = require('qs')
const axios = require('axios')

// const agent = new https.Agent({
//   rejectUnauthorized: false
// });

const API_URL = 'https://stampd.io/api/v2';
// const API_URL = 'http://localhost/stampd-v3/api/v2'

// config
const client_id = '' // get your API credentials at https://stampd.io
const secret_key = ''
const blockchain = ''
const hash = ''

// Auth call
axios.get(API_URL + '/init', {
  params: {
    client_id: client_id,
    secret_key: secret_key,
  }
})
  .then((response) => {

    if (response.data && response.data.code === 300) {
      console.log('login success')
      console.log(response.data)

      // Post call
      axios.post(API_URL + '/hash', qs.stringify({
        sess_id: response.data.session_id,
        hash: hash,
        blockchain: blockchain,
        // meta_emails: emails, // share the certificate of this stamping with a comma-separated list of emails
        // meta_notes: notes, // metadata notes
        // meta_filename: filename, // the name of the file
        // meta_category: category, // any category name
      }))
        .then((response) => {

          if (response.data && response.data.code === 301) {
            console.log('post hash success')
            console.log(response.data)
          } else {
            console.error('error in API call')
            console.error(response.data)
          }

        })
        .catch((error) => {
          console.error(error)
        })
    } else {
      console.error('error in API call')
      console.error(response.data)
    }

  })
  .catch((error) => {
    console.error(error)
  })

We've got you covered...

Consulting

I need advice

We have been developing our blockchain project since 2014. Please do contact us for any consulting you may require on blockchain technology.

Contact Us

Frequent Use

I plan to notarize often

Our members get access to the dashboard where you can manage your stampings more efficiently and get better rates.

Sign Up

Software

I require a custom solution

Contact us describing how you would envisage an implementation to your systems. Our blockchain experts will assist you to bring it to life.

Launch Wizard

Frequently asked questions

How does STAMPD work?

For simple blockchain stamping:

The user chooses a particular document or other electronic file for timestamping on a selected public blockchain.

The file is processed in the user’s browser to derive the SHA256 hash, which is essentially a one way conversion of the arbitrary large file to a fixed 32-byte data digest.

The hash is transmitted to STAMPD’s servers. A cryptocurrency transaction is then carried out in order to post this hash on the chosen blockchain.

In this way the hash is permanently recorded on the blockchain and linked to particular point in time. This hash can only be linked to the original content of the user’s electronic file, thus also linking that file with the particular timestamp.

It is noted that this link can be verified by anyone without reference to any centralized service or authority (the blockchain is maintained in a peer to peer network by an extremely large number of nodes and its data is readily available to anyone).

For NFT blockchain stamping:

The user chooses a particular document or other electronic file for NFT creation on the selected public blockchain (currently this is allowed for Cardano only).

The file is processed in the user’s browser to derive the SHA256 hash, which is essentially a one way conversion of the arbitrary large file to a fixed 32-byte data digest. The file is also uploaded on the InterPlanitary decentralized File System.

An Non-fungible Token (NFT) is created which will include:

the SHA256 hash of the file
the IPFS link to the file
a file description

The token will be send to the Blockchain address specified by the user. The one in control of this address will then be able to manage the NFT as he sees fit (e.g. to trade it, transfer it to someone else etc).

In this way the file is permanently recorded on the blockchain as linked to a particular point in time and as owned by the one in control of the receiving Cardano address. This can be verified by anyone without reference to any centralized service or authority (the blockchain is maintained in a peer to peer network by an extremely large number of nodes and its data is readily available to anyone). The file itself can be provided either by the originator of the transaction or through the IPFS link (specified in the NFT metadata).

Using public blockchains to timestamp and own your digital creations with indelible proof.

Non-fungible Tokens

Digital

Physical

Blockchain timestamping and NFT creation

Document issuance history certification

Certify possession of original content

Blockchain based intellectual property

Serving all industries

Law

Research

Media

Engineering

Academia

Design

Plugins Galore

API Reference

Introduction

Authenticate

Post a hash on the Blockchain

Check whether a hash has been stamped

Code samples

We've got you covered...

Consulting

Frequent Use

Software

Frequently asked questions

How does STAMPD work?

Will STAMPD have any access to my documents?

How can I use my Blockchain timestamp in the future?

Is it possible to derive the document or file contents using the SHA256 hash imprint?

How do I know that the public Blockchain ledgers will be online forever?

If I use the STAMPD app for a document, will I be able to prove authorship?

How would a blockchain timestamping stand in a Court of Law?

How long does STAMPD's Blockchain stamping take?

Choose Blockchains

We'd love to hear from you

What's your name?

Give us your e-mail address

What was it you wanted to say?

You are human, right?

Thank You! We'll review your request and be in touch.

Login

Using public blockchains to
timestamp and own your digital creations
with indelible proof.