> ## Documentation Index
> Fetch the complete documentation index at: https://docs.blindfold.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Start protecting PII before sending to OpenAI, Anthropic Claude, Google Gemini, or any LLM

Start detecting PII in under 5 minutes. Local mode is **free forever** — no signup, no API key, no network calls.

## Try It Instantly (Free, No API Key)

All SDKs include **local mode** with 86 regex-based entity types and all 8 operations (detect, tokenize, redact, mask, hash, encrypt, synthesize, detokenize). Your data never leaves your infrastructure. You only need an API key if you want NLP-powered detection via the Cloud API.

> [tab] Python
>
> ```bash theme={null}
> pip install blindfold-sdk
> ```
>
> ```python theme={null}
> from blindfold import Blindfold
>
> # No API key needed — runs entirely in-process
> client = Blindfold()
>
> result = client.tokenize("Contact john@example.com or call +1-555-1234")
> print(result.text)
> # "Contact <Email Address_1> or call <Phone Number_1>"
> ```

> [tab] JavaScript
>
> ```bash theme={null}
> npm install @blindfold/sdk
> ```
>
> ```javascript theme={null}
> import { Blindfold } from '@blindfold/sdk';
>
> // No API key needed — runs entirely in-process
> const client = new Blindfold();
>
> const result = await client.tokenize("Contact john@example.com or call +1-555-1234");
> console.log(result.text);
> // "Contact <Email Address_1> or call <Phone Number_1>"
> ```

> [tab] Java
>
> ```xml theme={null}
> <dependency>
>     <groupId>dev.blindfold</groupId>
>     <artifactId>blindfold-sdk</artifactId>
>     <version>1.0.0</version>
> </dependency>
> ```
>
> ```java theme={null}
> import dev.blindfold.sdk.Blindfold;
>
> // No API key needed — runs entirely in-process
> Blindfold client = new Blindfold();
>
> var result = client.tokenize("Contact john@example.com or call +1-555-1234");
> System.out.println(result.getText());
> // "Contact <Email Address_1> or call <Phone Number_1>"
> ```

> [tab] Go
>
> ```bash theme={null}
> go get github.com/blindfold-dev/Blindfold/packages/go-sdk
> ```
>
> ```go theme={null}
> import blindfold "github.com/blindfold-dev/Blindfold/packages/go-sdk"
>
> // No API key needed — runs entirely in-process
> client := blindfold.New()
>
> result, _ := client.Tokenize(ctx, "Contact john@example.com or call +1-555-1234")
> fmt.Println(result.Text)
> // "Contact <Email Address_1> or call <Phone Number_1>"
> ```

> [tab] .NET
>
> ```bash theme={null}
> dotnet add package Blindfold.Sdk
> ```
>
> ```csharp theme={null}
> using Blindfold.Sdk;
>
> // No API key needed — runs entirely in-process
> using var client = new BlindfoldClient();
>
> var result = await client.TokenizeAsync("Contact john@example.com or call +1-555-1234");
> Console.WriteLine(result.Text);
> // "Contact <Email Address_1> or call <Phone Number_1>"
> ```

> [!NOTE]
>
> **Local mode is free forever.** No data leaves your infrastructure — everything runs in-process with zero network calls. Supports 86 regex-based entity types (emails, phones, credit cards, SSNs, IBANs, and more) and all 8 privacy operations.

Need NLP-powered detection (names, addresses, organizations), compliance policies, or audit logs? Continue below to set up the optional Cloud API.

***

## Step 1: Create an Account

Sign up for a Blindfold account to get started.

> [card] [Create Account](https://app.blindfold.dev)
>
> Create your free account at app.blindfold.dev

After signing up, you will be automatically logged into the dashboard.

## Step 2: Generate an API Key

Once logged in, navigate to the API Keys section to create your first API key.

**1. Go to API Keys**

In the dashboard, click on **API Keys** in the sidebar navigation.

**2. Create New Key**

Click the **Create API Key** button.

**3. Name Your Key**

Give your API key a descriptive name (e.g., "Development", "Production App").

**4. Copy Your Key**

Copy the generated API key and store it securely. You will not be able to see it again.

> [!WARNING]
>
> Keep your API key secure and never commit it to version control. Use environment variables to store your keys.

## Step 3: Make Your First API Call

Choose your preferred integration method and make your first request.

> [tab] Python
>
> Install the Python SDK and tokenize your first text.
>
> ```bash theme={null}
> pip install blindfold-sdk
> ```
>
> ```python theme={null}
> from blindfold import Blindfold
>
> # Initialize the client
> client = Blindfold(api_key="your-api-key-here")
>
> # Tokenize text with sensitive data
> response = client.tokenize(
>     "My email is john@example.com and phone is +1-555-1234"
> )
>
> print(response.text)
> # Output: "My email is <EMAIL_ADDRESS_1> and phone is <PHONE_NUMBER_1>"
>
> print(response.mapping)
> # Output: {'<EMAIL_ADDRESS_1>': 'john@example.com', '<PHONE_NUMBER_1>': '+1-555-1234'}
> ```
>
> > [!TIP]
> >
> > The SDK automatically handles API authentication and request formatting.

> [tab] JavaScript
>
> Install the JavaScript SDK and tokenize your first text.
>
> ```bash theme={null}
> npm install @blindfold/sdk
> ```
>
> ```javascript theme={null}
> import { Blindfold } from '@blindfold/sdk';
>
> // Initialize the client
> const client = new Blindfold({
>   apiKey: 'your-api-key-here'
> });
>
> // Tokenize text with sensitive data
> const response = await client.tokenize(
>   "My email is john@example.com and phone is +1-555-1234"
> );
>
> console.log(response.text);
> // Output: "My email is <EMAIL_ADDRESS_1> and phone is <PHONE_NUMBER_1>"
>
> console.log(response.mapping);
> // Output: {'<EMAIL_ADDRESS_1>': 'john@example.com', '<PHONE_NUMBER_1>': '+1-555-1234'}
> ```
>
> > [!TIP]
> >
> > The SDK works in both Node.js and browser environments.

> [tab] Java
>
> Install the Java SDK and tokenize your first text.
>
> ```xml theme={null}
> <dependency>
>     <groupId>dev.blindfold</groupId>
>     <artifactId>blindfold-sdk</artifactId>
>     <version>1.0.0</version>
> </dependency>
> ```
>
> ```java theme={null}
> import dev.blindfold.sdk.Blindfold;
>
> // Initialize the client
> Blindfold client = new Blindfold("your-api-key-here");
>
> // Tokenize text with sensitive data
> var response = client.tokenize(
>     "My email is john@example.com and phone is +1-555-1234"
> );
>
> System.out.println(response.getText());
> // Output: "My email is <EMAIL_ADDRESS_1> and phone is <PHONE_NUMBER_1>"
>
> System.out.println(response.getMapping());
> // Output: {<EMAIL_ADDRESS_1>=john@example.com, <PHONE_NUMBER_1>=+1-555-1234}
> ```
>
> > [!TIP]
> >
> > The SDK works with Java 11+ and has no external HTTP dependencies.

> [tab] Go
>
> Install the Go SDK and tokenize your first text.
>
> ```bash theme={null}
> go get github.com/blindfold-dev/Blindfold/packages/go-sdk
> ```
>
> ```go theme={null}
> import blindfold "github.com/blindfold-dev/Blindfold/packages/go-sdk"
>
> // Initialize the client
> client := blindfold.New(blindfold.WithAPIKey("your-api-key-here"))
>
> // Tokenize text with sensitive data
> result, err := client.Tokenize(ctx,
>     "My email is john@example.com and phone is +1-555-1234",
> )
>
> fmt.Println(result.Text)
> // Output: "My email is <EMAIL_ADDRESS_1> and phone is <PHONE_NUMBER_1>"
>
> fmt.Println(result.Mapping)
> // Output: map[<EMAIL_ADDRESS_1>:john@example.com <PHONE_NUMBER_1>:+1-555-1234]
> ```
>
> > [!TIP]
> >
> > The SDK has zero external dependencies — uses only the Go standard library.

> [tab] .NET
>
> Install the .NET SDK and tokenize your first text.
>
> ```bash theme={null}
> dotnet add package Blindfold.Sdk
> ```
>
> ```csharp theme={null}
> using Blindfold.Sdk;
>
> // Initialize the client
> using var client = new BlindfoldClient("your-api-key-here");
>
> // Tokenize text with sensitive data
> var result = await client.TokenizeAsync(
>     "My email is john@example.com and phone is +1-555-1234"
> );
>
> Console.WriteLine(result.Text);
> // Output: "My email is <EMAIL_ADDRESS_1> and phone is <PHONE_NUMBER_1>"
>
> Console.WriteLine(result.Mapping);
> // Output: {<EMAIL_ADDRESS_1>: john@example.com, <PHONE_NUMBER_1>: +1-555-1234}
> ```
>
> > [!TIP]
> >
> > The SDK targets net6.0, net8.0, and netstandard2.1. Zero external dependencies.

> [tab] cURL
>
> Make a direct API call using cURL or any HTTP client.
>
> ```bash theme={null}
> curl -X POST https://api.blindfold.dev/api/public/v1/tokenize \
>   -H "X-API-Key: your-api-key-here" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "text": "My email is john@example.com and phone is +1-555-1234"
>   }'
> ```
>
> **Response:**
>
> ```json theme={null}
> {
>   "text": "My email is <EMAIL_ADDRESS_1> and phone is <PHONE_NUMBER_1>",
>   "mapping": {
>     "<EMAIL_ADDRESS_1>": "john@example.com",
>     "<PHONE_NUMBER_1>": "+1-555-1234"
>   },
>   "entities_count": 2,
>   "detected_entities": [
>     {
>       "type": "EMAIL_ADDRESS",
>       "text": "john@example.com",
>       "start": 12,
>       "end": 28,
>       "score": 1.0
>     },
>     {
>       "type": "PHONE_NUMBER",
>       "text": "+1-555-1234",
>       "start": 42,
>       "end": 53,
>       "score": 0.85
>     }
>   ]
> }
> ```
>
> > [!TIP]
> >
> > Replace `your-api-key-here` with your actual API key from Step 2.

> [!TIP]
>
> **Data Residency**: Need your data processed in a specific region? Use `region="eu"` or `region="us"` when initializing the client. See [Regions](https://docs.blindfold.dev/essentials/regions.md) for details.

## Step 4: Restore Original Data (Detokenize)

After sending tokenized data to AI or processing, you can restore the original values using the mapping.

> [tab] Python
>
> ```python theme={null}
> from blindfold import Blindfold
>
> client = Blindfold(api_key="your-api-key-here")
>
> # Step 1: Tokenize sensitive data
> protected = client.tokenize(
>     "Contact John Doe at john@example.com or call +1-555-1234"
> )
>
> print(protected.text)
> # "Contact <PERSON_1> at <EMAIL_ADDRESS_1> or call <PHONE_NUMBER_1>"
>
> # Step 2: Send to AI (protected data only)
> ai_response = f"We received your request: {protected.text}"
> # AI never sees real PII!
>
> # Step 3: Restore original data
> original = client.detokenize(
>     text=ai_response,
>     mapping=protected.mapping
> )
>
> print(original)
> # "We received your request: Contact John Doe at john@example.com or call +1-555-1234"
> ```
>
> > [!TIP]
> >
> > Store the mapping securely. Without it, you cannot restore original values.

> [tab] JavaScript
>
> ```javascript theme={null}
> import { Blindfold } from '@blindfold/sdk';
>
> const client = new Blindfold({ apiKey: 'your-api-key-here' });
>
> // Step 1: Tokenize sensitive data
> const protected = await client.tokenize(
>   "Contact John Doe at john@example.com or call +1-555-1234"
> );
>
> console.log(protected.text);
> // "Contact <PERSON_1> at <EMAIL_ADDRESS_1> or call <PHONE_NUMBER_1>"
>
> // Step 2: Send to AI (protected data only)
> const aiResponse = `We received your request: ${protected.text}`;
> // AI never sees real PII!
>
> // Step 3: Restore original data
> const original = await client.detokenize(
>   aiResponse,
>   protected.mapping
> );
>
> console.log(original);
> // "We received your request: Contact John Doe at john@example.com or call +1-555-1234"
> ```

> [tab] Java
>
> ```java theme={null}
> import dev.blindfold.sdk.Blindfold;
>
> Blindfold client = new Blindfold("your-api-key-here");
>
> // Step 1: Tokenize sensitive data
> var protected_ = client.tokenize(
>     "Contact John Doe at john@example.com or call +1-555-1234"
> );
>
> System.out.println(protected_.getText());
> // "Contact <PERSON_1> at <EMAIL_ADDRESS_1> or call <PHONE_NUMBER_1>"
>
> // Step 2: Send to AI (protected data only)
> String aiResponse = "We received your request: " + protected_.getText();
> // AI never sees real PII!
>
> // Step 3: Restore original data
> var original = client.detokenize(aiResponse, protected_.getMapping());
>
> System.out.println(original.getText());
> // "We received your request: Contact John Doe at john@example.com or call +1-555-1234"
> ```

> [tab] Go
>
> ```go theme={null}
> import blindfold "github.com/blindfold-dev/Blindfold/packages/go-sdk"
>
> client := blindfold.New(blindfold.WithAPIKey("your-api-key-here"))
>
> // Step 1: Tokenize sensitive data
> protected, _ := client.Tokenize(ctx,
>     "Contact John Doe at john@example.com or call +1-555-1234",
> )
>
> fmt.Println(protected.Text)
> // "Contact <PERSON_1> at <EMAIL_ADDRESS_1> or call <PHONE_NUMBER_1>"
>
> // Step 2: Send to AI (protected data only)
> aiResponse := fmt.Sprintf("We received your request: %s", protected.Text)
>
> // Step 3: Restore original data
> original := client.Detokenize(aiResponse, protected.Mapping)
>
> fmt.Println(original.Text)
> // "We received your request: Contact John Doe at john@example.com or call +1-555-1234"
> ```

> [tab] .NET
>
> ```csharp theme={null}
> using Blindfold.Sdk;
>
> using var client = new BlindfoldClient("your-api-key-here");
>
> // Step 1: Tokenize sensitive data
> var safe = await client.TokenizeAsync(
>     "Contact John Doe at john@example.com or call +1-555-1234"
> );
>
> Console.WriteLine(safe.Text);
> // "Contact <PERSON_1> at <EMAIL_ADDRESS_1> or call <PHONE_NUMBER_1>"
>
> // Step 2: Send to AI (protected data only)
> var aiResponse = $"We received your request: {safe.Text}";
>
> // Step 3: Restore original data
> var original = client.Detokenize(aiResponse, safe.Mapping);
>
> Console.WriteLine(original.Text);
> // "We received your request: Contact John Doe at john@example.com or call +1-555-1234"
> ```

> [tab] cURL
>
> ```bash theme={null}
> # Step 1: Tokenize
> curl -X POST https://api.blindfold.dev/api/public/v1/tokenize \
>   -H "X-API-Key: your-api-key-here" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "text": "Contact John Doe at john@example.com or call +1-555-1234"
>   }'
>
> # Save the mapping from response
> # {
> #   "text": "Contact <PERSON_1> at <EMAIL_ADDRESS_1> or call <PHONE_NUMBER_1>",
> #   "mapping": {
> #     "<PERSON_1>": "John Doe",
> #     "<EMAIL_ADDRESS_1>": "john@example.com",
> #     "<PHONE_NUMBER_1>": "+1-555-1234"
> #   }
> # }
>
> # Step 2: Send tokenized text to AI (not shown)
>
> # Step 3: Detokenize to restore original
> curl -X POST https://api.blindfold.dev/api/public/v1/detokenize \
>   -H "X-API-Key: your-api-key-here" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "text": "We received: Contact <PERSON_1> at <EMAIL_ADDRESS_1>",
>     "mapping": {
>       "<PERSON_1>": "John Doe",
>       "<EMAIL_ADDRESS_1>": "john@example.com"
>     }
>   }'
>
> # Response:
> # {
> #   "text": "We received: Contact John Doe at john@example.com"
> # }
> ```

> [!NOTE]
>
> **Complete Privacy Flow**: Tokenize → Process with AI → Detokenize
>
> This ensures AI providers never see real PII, meeting GDPR and EU AI Act requirements.

## Response Format

All responses include:

* `text` - Protected text
* `entities_count` - Number of PII items found
* `detected_entities` - Details about what was found
* `mapping` - Token mapping (tokenize only)

## Use Policies for Easy Compliance

Instead of specifying entities manually, use pre-configured compliance policies:

> [tab] Python
>
> ```python theme={null}
> # GDPR compliance (European data)
> response = client.tokenize(
>     "Contact: John Doe, john@example.com, +49 30 12345",
>     policy="gdpr_eu"
> )
>
> # HIPAA compliance (Healthcare data)
> response = client.tokenize(
>     "Patient: Jane Smith, SSN: 123-45-6789",
>     policy="hipaa_us"
> )
> ```

> [tab] JavaScript
>
> ```javascript theme={null}
> // GDPR compliance (European data)
> const response = await client.tokenize(
>   "Contact: John Doe, john@example.com, +49 30 12345",
>   { policy: "gdpr_eu" }
> );
>
> // HIPAA compliance (Healthcare data)
> const response2 = await client.tokenize(
>   "Patient: Jane Smith, SSN: 123-45-6789",
>   { policy: "hipaa_us" }
> );
> ```

> [tab] Java
>
> ```java theme={null}
> // GDPR compliance (European data)
> var response = client.tokenize(
>     "Contact: John Doe, john@example.com, +49 30 12345"
> );
>
> // HIPAA compliance (Healthcare data)
> var response2 = client.tokenize(
>     "Patient: Jane Smith, SSN: 123-45-6789"
> );
> ```

> [tab] Go
>
> ```go theme={null}
> // GDPR compliance (European data)
> result, _ := client.Tokenize(ctx,
>     "Contact: John Doe, john@example.com, +49 30 12345",
>     blindfold.WithCallPolicy("gdpr_eu"),
> )
>
> // HIPAA compliance (Healthcare data)
> result2, _ := client.Tokenize(ctx,
>     "Patient: Jane Smith, SSN: 123-45-6789",
>     blindfold.WithCallPolicy("hipaa_us"),
> )
> ```

> [tab] .NET
>
> ```csharp theme={null}
> // GDPR compliance (European data)
> var result = await client.TokenizeAsync(
>     "Contact: John Doe, john@example.com, +49 30 12345",
>     policy: "gdpr_eu"
> );
>
> // HIPAA compliance (Healthcare data)
> var result2 = await client.TokenizeAsync(
>     "Patient: Jane Smith, SSN: 123-45-6789",
>     policy: "hipaa_us"
> );
> ```

> [tab] cURL
>
> ```bash theme={null}
> # GDPR compliance
> curl -X POST https://api.blindfold.dev/api/public/v1/tokenize \
>   -H "X-API-Key: your-api-key-here" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "text": "Contact: John Doe, john@example.com",
>     "policy": "gdpr_eu"
>   }'
> ```

**Available Policies:**

* `basic` - Names, emails, phones
* `gdpr_eu` - GDPR compliance
* `hipaa_us` - Healthcare compliance
* `pci_dss` - Payment card compliance
* `strict` - Maximum protection

## Next Steps

Now that you have made your first API call, explore more features:

> [card] [Python SDK Guide](https://docs.blindfold.dev/sdks/python-sdk.md)
>
> Learn about all Python SDK features and methods.

> [card] [JavaScript SDK Guide](https://docs.blindfold.dev/sdks/javascript-sdk.md)
>
> Explore JavaScript/TypeScript SDK capabilities.

> [card] [Java SDK Guide](https://docs.blindfold.dev/sdks/java-sdk.md)
>
> Sync and async clients for Java 11+.

> [card] [Go SDK Guide](https://docs.blindfold.dev/sdks/go-sdk.md)
>
> Zero-dependency SDK with context support.

> [card] [.NET SDK Guide](https://docs.blindfold.dev/sdks/dotnet-sdk.md)
>
> async/await for .NET 6, 8, and Standard 2.1.

> [card] [REST API Reference](https://docs.blindfold.dev/api-reference/rest-api.md)
>
> Complete API endpoint documentation.

> [card] [AI Integrations](https://docs.blindfold.dev/integrations.md)
>
> OpenAI, Anthropic Claude, Gemini, LangChain, and more.

> [card] [See Examples](https://docs.blindfold.dev/examples.md)
>
> Real-world use cases and integration patterns.

## Need Help?

> [card] [Support](mailto:support@blindfold.dev)
>
> Contact us at [support@blindfold.dev](mailto:support@blindfold.dev) for support and questions.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.