Barcode Encryption/Decryption

Description:

All barcode values will be encrypted using Fernet and should be decrypted using your API Credential Secret Token used to make the API call.

Example:

On the /v9/listings and /v9/orders endpoints you will see items with encrypted_barcode fields.

  ...
  "tickets": [
    {
      "ticket_seat": 10,
      "primary_ticket_id": "723917860",
      "verification_id": "TEAMNAME-REGULAR-13019-GF4YWMALQNI6QBLHVQFPUFUX",
      "encrypted_barcode": "gAAAAABmViEq_jVaAVu7YW3tlf2X1L1efbCSTIJT4IgzKDDUz_1BqCpp2qrGcPq7bHOEyXaJ8mu_iKy41AFfc6Xq4BsxAZZQGg=="
    },
    {
      "ticket_seat": 11,
      "primary_ticket_id": "723917861",
      "verification_id": "TEAMNAME-REGULAR-13019-6QBLHVQFPUFUXGF4YWMALQNI",
      "encrypted_barcode": "gAAAAABmViHkNkY0LYjzS3j6Alo2fGQB1oclwk8m4tlL2Kfmgvl2Ce4e6zZ_PrTC1GrblHzTP8XRxB73zpvZf6GNbk-SL38K1Q=="
    }
  ],
  ...

The barcode, if present, will be encrypted using Fernet and the key will be the first 32 characters of your ApiCredential secret key.

Examples

Ruby

require 'fernet'
require 'base64'

key = '32_CHARS_LONG_EXAMPLE_API_SECRET'
secret = Base64.urlsafe_encode64(key)
message = '1234567890'
encrypted = Fernet.generate(secret, message)
verifier = Fernet.verifier(secret, encrypted)
decrypted = verifier.message if verifier.valid?
puts "Encrypted: #{encrypted}"
puts "Decrypted: #{decrypted}"

Python

from cryptography.fernet import Fernet
import base64

key = b'32_CHARS_LONG_EXAMPLE_API_SECRET'
secret = base64.urlsafe_b64encode(key)
f = Fernet(secret)

message = b'1234567890'
encrypted = f.encrypt(message)
decrypted = f.decrypt(encrypted)

print('Encrypted:', encrypted)
print('Decrypted:', decrypted.decode())

C Sharp

using System;
using Fernet;

class Program
{
    static void Main()
    {
        var key = "32_CHARS_LONG_EXAMPLE_API_SECRET";
        var secret = Base64Url.Encode(System.Text.Encoding.UTF8.GetBytes(key));
        var fernet = new Fernet.Encryptor(secret);

        var message = "1234567890";
        var encrypted = fernet.Encrypt(message);
        var decrypted = fernet.Decrypt(encrypted);

        Console.WriteLine("Encrypted: " + encrypted);
        Console.WriteLine("Decrypted: " + decrypted);
    }
}

Javascript / Typescript

import * as fernet from 'fernet';

const key = Buffer.from('32_CHARS_LONG_EXAMPLE_API_SECRET').toString('base64url');
const secret = new fernet.Secret(key);
const token = new fernet.Token({ secret, time: Date.now() });

const message = '1234567890';
const encrypted = token.encode(message);

const verifier = new fernet.Token({ secret, token: encrypted, ttl: 0 });
const decrypted = verifier.decode();

console.log('Encrypted:', encrypted);
console.log('Decrypted:', decrypted);

Go

package main

import (
	"encoding/base64"
	"fmt"
	"github.com/fernet/fernet-go"
)

func main() {
	keyStr := "32_CHARS_LONG_EXAMPLE_API_SECRET"
	key := &fernet.Key{}
	copy(key[:], []byte(keyStr))

	message := []byte("1234567890")
	token := fernet.EncryptAndSign(message, key)

	verified := fernet.VerifyAndDecrypt(token, 0, []*fernet.Key{key})
	fmt.Println("Encrypted:", string(token))
	fmt.Println("Decrypted:", string(verified))
}

PHP

<?php
require 'vendor/autoload.php';

use Fernet\Fernet;

$key = '32_CHARS_LONG_EXAMPLE_API_SECRET';
$secret = base64_encode($key);
$fernet = new Fernet($secret);

$message = '1234567890';
$encrypted = $fernet->encode($message);
$decrypted = $fernet->decode($encrypted);

echo "Encrypted: $encrypted\n";
echo "Decrypted: $decrypted\n";

Java

import com.maciejkrasowski.Fernet;
import com.maciejkrasowski.Key;

public class FernetExample {
    public static void main(String[] args) {
        String keyString = "32_CHARS_LONG_EXAMPLE_API_SECRET";
        String secret = java.util.Base64.getUrlEncoder().encodeToString(keyString.getBytes());

        Key key = new Key(secret);
        Fernet fernet = new Fernet(key);

        String message = "1234567890";
        String token = fernet.encrypt(message);
        String decrypted = fernet.decrypt(token);

        System.out.println("Encrypted: " + token);
        System.out.println("Decrypted: " + decrypted);
    }
}

Rust

use fernet::Fernet;

fn main() {
    let key_str = "32_CHARS_LONG_EXAMPLE_API_SECRET";
    let secret = base64::encode_config(key_str, base64::URL_SAFE_NO_PAD);
    let fernet = Fernet::new(&secret).unwrap();

    let message = "1234567890";
    let token = fernet.encrypt(message.as_bytes());
    let decrypted = fernet.decrypt(&token).unwrap();

    println!("Encrypted: {}", token);
    println!("Decrypted: {}", String::from_utf8(decrypted).unwrap());
}