Fuzzy search

curl -X POST "https://your-databunker-instance/v2/UserSearch" \
  -H "Content-Type: application/json" \
  -H "X-Bunker-Token: YOUR_ACCESS_TOKEN" \
  -d '{
    "mode": "login",
    "identity": "user0",
    "unlockuuid": "your-unlock-uuid"
  }'

// ES Modules
import DatabunkerproAPI from "databunkerpro-js";

// CommonJS
// const { DatabunkerproAPI } = require('databunkerpro-js');

// Initialize the client
const client = new DatabunkerproAPI(
  "https://your-databunker-instance.com",
  "your-token"
);

// Step 1: Create bulk list unlock
const unlockResponse = await client.bulkListUnlock();
const unlockUUID = unlockResponse.unlockuuid;

// Step 2: Perform fuzzy search
const searchResponse = await client.userSearch({
  mode: "login",
  identity: "user0",
  unlockuuid: unlockUUID,
});

// Process results
if (searchResponse.status === "ok") {
  const users = searchResponse.rows;
  console.log(`Found ${users.length} matching users`);

  users.forEach((user) => {
    const profile = user.profile;
    console.log(`User: ${profile.login} - ${profile.email}`);
  });
}

from databunkerpro import DatabunkerproAPI

# Initialize the client
api = DatabunkerproAPI(
    base_url="https://your-databunker-instance",
    x_bunker_token="YOUR_ACCESS_TOKEN",
    x_bunker_tenant="your-tenant-name"  # Optional for multi-tenant setups
)

# Step 1: Create bulk list unlock
unlock_response = api.bulk_list_unlock()
unlock_uuid = unlock_response["unlockuuid"]

# Step 2: Perform fuzzy search
search_response = api.user_search(
    mode="login",
    identity="user0",
    unlockuuid=unlock_uuid
)

if search_response["status"] == "ok":
    users = search_response["rows"]
    print(f"Found {len(users)} matching users")

    for user in users:
        profile = user["profile"]
        print(f"User: {profile['login']} - {profile['email']}")

try {
  const searchResponse = await api.makeRequest("UserSearch", {
    mode: "login",
    identity: "nonexistent",
    unlockuuid: unlockUUID,
  });

  if (searchResponse.status === "error") {
    console.log("Search failed:", searchResponse.message);
  } else if (searchResponse.rows.length === 0) {
    console.log("No matching users found");
  }
} catch (error) {
  console.error("Search request failed:", error);
}

npm install databunkerpro-js

import DatabunkerproAPI from "databunkerpro-js";

class UserSearchService {
  private client: DatabunkerproAPI;
  private unlockUUID?: string;

  constructor(baseUrl: string, token: string) {
    this.client = new DatabunkerproAPI(baseUrl, token);
  }

  private async ensureUnlock(): Promise<string> {
    if (!this.unlockUUID) {
      const response = await this.client.bulkListUnlock();
      this.unlockUUID = response.unlockuuid;
    }
    return this.unlockUUID;
  }

  async searchUsers(mode: string, identity: string) {
    const unlockUUID = await this.ensureUnlock();

    const response = await this.client.userSearch({
      mode,
      identity,
      unlockuuid: unlockUUID,
    });

    if (response.status !== "ok") {
      throw new Error(`Search failed: ${response.message || "Unknown error"}`);
    }

    return response.rows;
  }

  async findUserByEmail(email: string) {
    return this.searchUsers("email", email);
  }

  async findUserByLogin(login: string) {
    return this.searchUsers("login", login);
  }

  async findUserByPhone(phone: string) {
    return this.searchUsers("phone", phone);
  }
}

// Usage example
const searchService = new UserSearchService(
  "https://your-databunker-instance.com",
  "your-token"
);

// Search for users with error handling
try {
  const users = await searchService.findUserByLogin("john");
  console.log(`Found ${users.length} matching users`);

  users.forEach((user) => {
    const profile = user.profile;
    console.log(`Found: ${profile.login} - ${profile.email}`);
  });
} catch (error) {
  console.error("Search failed:", error.message);
}

pip install databunkerpro

pip install git+https://github.com/securitybunker/databunkerpro-python.git

from databunkerpro import DatabunkerproAPI
from typing import List, Dict, Optional

class UserSearchService:
    def __init__(self, base_url: str, token: str, tenant: Optional[str] = None):
        self.api = DatabunkerproAPI(
            base_url=base_url,
            x_bunker_token=token,
            x_bunker_tenant=tenant
        )
        self._unlock_uuid: Optional[str] = None

    def _ensure_unlock(self) -> str:
        """Ensure we have a valid unlock UUID"""
        if not self._unlock_uuid:
            response = self.api.bulk_list_unlock()
            self._unlock_uuid = response["unlockuuid"]
        return self._unlock_uuid

    def search_users(self, mode: str, identity: str) -> List[Dict]:
        """Search for users using fuzzy matching"""
        unlock_uuid = self._ensure_unlock()

        response = self.api.user_search(
            mode=mode,
            identity=identity,
            unlockuuid=unlock_uuid
        )

        if response["status"] == "ok":
            return response["rows"]
        else:
            raise Exception(f"Search failed: {response.get('message', 'Unknown error')}")

    def find_user_by_email(self, email: str) -> List[Dict]:
        """Find users by email with fuzzy matching"""
        return self.search_users("email", email)

    def find_user_by_login(self, login: str) -> List[Dict]:
        """Find users by login with fuzzy matching"""
        return self.search_users("login", login)

# Usage example
search_service = UserSearchService(
    base_url="https://your-databunker-instance",
    token="YOUR_ACCESS_TOKEN",
    tenant="your-tenant-name"
)

# Search for users
users = search_service.find_user_by_login("john")
for user in users:
    profile = user["profile"]
    print(f"Found: {profile['login']} - {profile['email']}")