Introduction

This guide will walk you through the entire process of getting started with the Ubiq Data Security platform – from creating an account to encrypting your first piece of data. We’ll cover setting up your Ubiq account, configuring a dataset and group (to define what data you want to protect), obtaining API key credentials, installing the Ubiq SDK, and performing encryption/decryption in a sample application. The goal is to provide a useful quickstart for prospective users to test Ubiq, filling in the gaps left by the current documentation. Let’s get started!

Step 1: Sign Up for a Ubiq Account

Begin by creating a Ubiq account here: https://dashboard.ubiqsecurity.com/register

You’ll be prompted to register with a valid email address and a strong password. Complete the sign-up form and submit – congratulations, your account is created and you should be logged into the Ubiq Dashboard.

Verify Your Email: Ubiq will send a verification email to the address you provided. You must verify your email before you can create any datasets or API keys. Click the Verify Email link in that email. (If you don’t see it within a few minutes, check your spam/junk folder.) Once verified, you’re ready to use the Ubiq Dashboard to configure your data security settings.

Step 2: Create a Dataset (and Group) Using the Wizard

With your account set up, the next step is to define a Dataset – essentially, the data you want to encrypt. Ubiq supports two types of datasets: Structured (for things like text fields, database columns, etc.) and Unstructured (for files, binaries, etc.). In this quickstart, we’ll walk through creating a structured dataset using Ubiq’s dataset creation wizard. This wizard also allows you to create a Dataset Group and a Primary Encryption Key as part of the process (no need to create those separately beforehand).

After logging into the Ubiq Dashboard, navigate to the Datasets section in the left-hand menu. The Datasets panel (shown above) will list your datasets (it will be empty for new users). Click on the + New Dataset button to launch the Dataset Creation Wizard. This wizard will guide you through configuring your dataset and associated settings.Follow these steps in the Dataset Creation Wizard:

Dataset Details: Provide a Dataset Name and an optional Description to help identify the data you’ll be protecting. For example, if you plan to encrypt Social Security numbers, you might name the dataset “SSN” and describe it as “Social Security Numbers – format-preserving encryption”.
Dataset Group: Select an existing dataset group or create a new one for this dataset. Dataset Groups are a way to organize datasets; if you’re just starting, you can create a new group (e.g. “Testing” or “Demo Group”). Note: A dataset must belong to a group in order to be linked to an API key, so this step is important.
Primary Key: Choose an existing primary encryption key or create a new one. For a first dataset, you will likely create a new Primary Key – this is the master key that will be used (under the hood) to derive data encryption keys for this dataset. You don’t need to supply any key material yourself; Ubiq will generate it for you.
Data Type: Specify whether your dataset is Structured or Unstructured, and select a storage vendor if applicable (this is optional and just for reference, e.g. “Amazon RDS”, “Snowflake”, etc.). For our example, choose Structured (since we are protecting a text field). Click Continue.
Structured Data Definition: (This step appears only if you chose Structured.) Define the parameters for format-preserving encryption. You’ll be asked to set an Input Character Set and Output Character Set – which characters are allowed in the plaintext versus ciphertext – and optionally enable Partial Encryption. Partial encryption (masking) lets you leave part of the data in plaintext (for example, showing the last 4 digits of an SSN). For this quickstart, you can skip partial encryption unless you have a specific masking need. Ubiq provides sensible defaults for character sets (for example, digits for input if your data is numeric, and alphanumeric for output) and you can accept those or adjust as needed.
Review and Create: The wizard will show a summary of your settings. Double-check the dataset name, group, and type. Then click Create to create the dataset. Ubiq will now generate the cryptographic keys (API credentials) for your application.

Step 3: Copy Your API Key Credentials

Once you click Create, the Ubiq Dashboard will display your newly generated API Key Credentials for this dataset. These credentials consist of three values: an Access Key ID, a Secret Signing Key, and a Secret Crypto Access Key (you can think of these collectively as your “API key”). This is a critical step: you will only be shown these credentials once, immediately after creation.

After creating the dataset, Ubiq shows your API credentials (Access Key ID, Secret Signing Key, Secret Crypto Access Key) and prompts you to copy them. These values are needed to authenticate your application to Ubiq for encryption and decryption.

Copy the credentials from the dashboard and store them in a secure location (such as a secrets vault). Do not skip this! If you lose these API keys, Ubiq cannot show them to you again. If you did misplace them, you would have to create a new API key.

To recap, at this stage you have: an active Ubiq account (email verified), a configured dataset (in a dataset group, with a primary key), and a set of API key credentials (copied to a safe place). You are now ready to integrate Ubiq into an application or database to actually encrypt and decrypt data.

Step 4: Install the Ubiq SDK or Integration

Ubiq provides client libraries for multiple programming languages (Python, Java, C#/.NET, JavaScript/Node.js, Go, C/C++, PHP, Ruby) as well as integrations for databases and platforms (Snowflake, BigQuery, Postgres, etc.).

Most of our installation guides are located on our public documentation page under the “Libraries and Integrations” menu header here: https://dev.ubiqsecurity.com/docs/

Step 5: Encrypt and Decrypt Data with Ubiq

With the SDK installed, you can now write a small script or modify your application to use Ubiq for encryption. The general steps are: load your API credentials, then call the library’s encrypt/decrypt functions. Below is a simple Python example demonstrating encryption and decryption of a string using the structured dataset you created:

import ubiq_security as ubiq
import ubiq_security.structured as ubiq_structured

# 1. Provide your API credentials (from Step 3).
#    (For demo purposes, we're hardcoding them. In production, use environment variables or a secure vault!)
credentials = ubiq.credentials(
    access_key_id="<YOUR_ACCESS_KEY_ID>",
    secret_signing_key="<YOUR_SECRET_SIGNING_KEY>",
    secret_crypto_access_key="<YOUR_SECRET_CRYPTO_ACCESS_KEY>"
)

# 2. Specify the dataset name you created, and some sample plaintext data to encrypt.
dataset_name = "<Your Dataset Name>"    # e.g., "SSN" or whatever name you chose
plain_text   = "123-45-6789"            # sample data (e.g., an SSN format)

# 3. Encrypt the data using Ubiq's structured encryption function.
cipher_text = ubiq_structured.Encrypt(credentials, dataset_name, plain_text)
print("Encrypted data: " + cipher_text)

# 4. Decrypt the data back to plaintext to verify it works.
decrypted_text = ubiq_structured.Decrypt(credentials, dataset_name, cipher_text)
print("Decrypted data: " + decrypted_text)

Let’s break down what this does: we initialize a credentials object with our API keys (for a real application, you’d likely load these from a secure source rather than code). Then we call ubiq_structured.Encrypt, passing in the credentials, the dataset name, and the plaintext string. Ubiq returns an encrypted string (cipher_text). We print it out to see the result. Finally, we use ubiq_structured.Decrypt with the same credentials, dataset name, and the cipher text to get back the original plaintext. If everything is set up correctly, the decrypted text should match the original input.

Behind the scenes, the Ubiq client library is using your API credentials to authenticate to Ubiq’s cloud, retrieving the appropriate encryption key (the primary key you created, or a data key derived from it) and performing the encryption. For structured data, the encryption is format-preserving by default – meaning the output cipher_text should have the same character set and length as defined in your dataset policy. In our example, since we treated the data as an SSN with digits and dashes, the encrypted output might look similar in format (e.g., still containing digits and maybe dashes) so that it can fit back into the same database field or application form. (If you had configured partial masking, some parts of the plaintext would remain visible in the ciphertext as per your settings.)

This simple test confirms that your Ubiq integration works: you have successfully encrypted (or tokenized) and decrypted (de-tokenized) data using the Ubiq platform! 🎉

Note: In the example above, we used the structured encryption methods tied to a dataset name. Ubiq also offers unstructured encryption (via ubiq.encrypt() / ubiq.decrypt() functions) for binary or free-form data. The usage is similar (you pass the credentials and data), but for structured data and format-preservation, using the dataset-specific calls as shown is recommended.

Next Steps: Application and Database Integration

We focused on a Python example for simplicity, but you can integrate Ubiq into your actual application or data pipeline using the language of your choice. Ubiq’s documentation provides step-by-step guides for other languages (Java, C#, JavaScript, etc.) and even direct database integrations. For instance, Ubiq offers a Snowflake integration that uses UDFs (user-defined functions) to perform encryption/decryption within Snowflake’s SQL environment. Similar integration guides exist for PostgreSQL, Google BigQuery, Apache Hive, and others.

Depending on your use case:

Application Integration: Include the Ubiq client library in your application and use it in the code (as we did above) to encrypt sensitive data before storing it, and to decrypt when needed for processing. The patterns will be analogous to the Python example in whatever language you use. Be sure to handle your API keys securely (e.g., via environment variables, config files, or key management systems, rather than hardcoding). Ubiq’s client libraries support multiple ways to supply credentials for this purpose.
Database Integration: If you want to encrypt data directly in a database, consider using Ubiq’s integrations. For example, with Snowflake you can deploy Ubiq’s pre-built Python UDFs to call the encryption functions within SQL. For PostgreSQL/Greenplum, Ubiq provides a mechanism to leverage the Python library in SQL queries. These integrations typically involve installing an extension or running a setup script, and then using SQL functions (provided by Ubiq) to encrypt/decrypt data as needed. Refer to the specific integration docs for detailed instructions on setup and usage.

Conclusion

By following this guide, you’ve gone through an end-to-end journey: creating a Ubiq account, configuring a dataset (and understanding dataset groups and keys), obtaining your API credentials, and using the Ubiq SDK to encrypt and decrypt data. You now have a basic Ubiq environment up and running. From here, you can expand on this quickstart by integrating Ubiq into your larger application or database workflow, knowing that the core pieces are in place. Always remember to keep your API keys safe, and consider additional best practices (like key rotation policies, logging, and monitoring) as you move toward production. For any further questions or advanced use cases, check out Ubiq’s documentation or reach out at [email protected].