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.

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.

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).

Will STAMPD have any access to my documents?

For Simple Blockchain stamping:

No, STAMPD will not have access to your documents. They are not uploaded on our servers. They are locally processed in your browser to derive the appropriate cryptographic SHA256 hash imprint.

For NFT blockchain stamping:

Yes, STAMPD will have access to the document and the file will also be uploaded on the IPFS.

How can I use my Blockchain timestamp in the future?

The user (you) keeps the original electronic file of the document together with STAMPD’s provided timestamp (and NFT where applicable) details included in the emailed PDF certificate. These details may be used in the future by the user in order to locate and refer to the appropriate transaction within the publicly available blockchain public ledgers.

There are currently various online services that provide easy access to the publicly available blockchains (some examples are blockchain.info, blockexplorer.com, insight.bitpay.com, biteasy.com, blocktrail.com). Direct links to these currently available online services will be included within the PDF certificate emailed to the user after the blockchain timestamping confirmation.

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

No, only the the hash imprint can be derived through a one way function from the original file but not the other way around. It is impossible to derive the original document or file contents using the cryptographic hash imprint.

For more information about the Cryptographic Hash please refer to this article on Wikipedia.

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

Given the current cryptocurrency capitalization it seems highly unlikely that the key public blockchains used by STAMPD will cease to exist.

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

Simple blockchain stamping can certify the existence of an electronic documents’s content at a particular point in time.

When a user stamps a document, the document’s imprint (i.e. the SHA256 hash of the document) is publicly linked with a certain date & time.

As the document’s hash digest can be easily derived from the document itself, the user is able to prove that his/her document existed at that point in time because its hash digest is publicly linked to that particular point in time. The publicly announced hash cannot be used to derive the document itself thus it depends on the user when to disclose the relation between his document and the publicly timestamped document hash imprint.

If the user blockchain timestamps the hash digest of authentic original work which includes a detailed ownership statement or signature, then this publicly timestamped statement can be used in the future by the user to justify that the content was in his possession at that particular time.

Therefore, if the blockchain stamped document is indeed original authentic non-stolen & non-copied work signed by the user and if no other previous public statement on the stamped content may be found anywhere (including mass media, public authorities, agencies, companies etc) then the user has a very strong argument to support being the author/creator of the content. Of course, if a third party can actually prove theft of the content prior to the time of stamping, then the ownership justification is discounted.

Thus, blockchain timestamp certification of ownership may be justified for content which is properly signed and is the result of original authentic work not having previously existed.

Especially for the case of NFT, the ownership can be simply validated by the one in control of the receiving blockchain address.

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

As the blockchain technology concept is relatively new, there is no experience on how the above would stand in a court of law. Despite that, any experienced IT/Computer science expert witness could testify to confirm the blockchain timestamping and NFT immutability and certify any pertinent timestaping (or ownership in case of NFT) proof against court.

How long does STAMPD's Blockchain stamping take?

The process should not take more than a few minutes.

After the user has finalized this procedure, it normally takes 15 minutes to 1 hour for the blockchain posting to be confirmed with the appropriate number of confirmations.

STAMPD will then email you with a pdf certificate showing all the details of the timestamping and NFT where applicable.