JavaScript / Node.js Integration

Use fetch (Node.js 18+) or axios to integrate with Questa Anonymizer.

Using Fetch

Text Anonymization

const API_URL = "https://demo.questa-ai.online";
const API_TOKEN = "YOUR_API_TOKEN";

async function anonymizeText(text, options = {}) {
  const payload = {
    text,
    start_index: options.startIndex ?? 0,
  };

  if (options.entities) payload.entities = options.entities;
  if (options.customEntities) payload.custom_entities = options.customEntities;

  const response = await fetch(`${API_URL}/anonymize/text`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${API_TOKEN}`,
    },
    body: JSON.stringify(payload),
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }

  return response.json();
}

const result = await anonymizeText(
  "My name is John Doe and my email is john@example.com."
);

console.log(result.anonymized_text);
// My name is [PERSON_NAME_1] and my email is [EMAIL_ADDRESS_2].
console.log(`Found ${result.entities} entities`);

File Anonymization

import { Buffer } from "node:buffer";
import fs from "node:fs";

async function anonymizeFile(filePath, fileType, options = {}) {
  const formData = new FormData();
  const fileBuffer = fs.readFileSync(filePath);
  const blob = new Blob([fileBuffer]);
  formData.append("file", blob, filePath);

  if (options.entities) formData.append("entities", options.entities);
  if (options.customEntities) {
    formData.append("custom_entities", JSON.stringify(options.customEntities));
  }

  const uploadResponse = await fetch(
    `${API_URL}/anonymize/${fileType}`,
    {
      method: "POST",
      headers: { Authorization: `Bearer ${API_TOKEN}` },
      body: formData,
    }
  );

  if (!uploadResponse.ok) {
    throw new Error(`Upload failed: ${await uploadResponse.text()}`);
  }

  const { job_id } = await uploadResponse.json();
  console.log(`Job started: ${job_id}`);

  // Poll for completion
  while (true) {
    const statusResponse = await fetch(
      `${API_URL}/anonymize/status/${job_id}`,
      { headers: { Authorization: `Bearer ${API_TOKEN}` } }
    );

    const result = await statusResponse.json();

    if (result.status === "completed") {
      const buffer = Buffer.from(result.result, "base64");
      const outputPath = `anonymized_${filePath}`;
      fs.writeFileSync(outputPath, buffer);
      console.log(`Saved to: ${outputPath}`);
      return result;
    }

    if (result.status === "failed") {
      throw new Error(`Job failed: ${result.error}`);
    }

    console.log(`Status: ${result.status} (${result.progress ?? 0}%)`);
    await new Promise((r) => setTimeout(r, 1000));
  }
}

Using Axios

npm install axios

import axios from "axios";
import FormData from "form-data";
import fs from "fs";

const client = axios.create({
  baseURL: "https://demo.questa-ai.online",
  headers: { Authorization: "Bearer YOUR_API_TOKEN" },
});

// Text
const { data } = await client.post("/anonymize/text", {
  text: "My name is John Doe.",
});
console.log(data.anonymized_text);

// File
const form = new FormData();
form.append("file", fs.createReadStream("document.pdf"));

const { data: job } = await client.post("/anonymize/pdf", form, {
  headers: form.getHeaders(),
});
console.log(`Job ID: ${job.job_id}`);

TypeScript

interface AnonymizeTextResponse {
  anonymized_text: string;
  map: Record<string, string>;
  entities: number;
}

interface CustomEntity {
  original: string;
  placeholder: string;
}

class AnonymizerClient {
  private baseUrl: string;
  private token?: string;

  constructor(baseUrl: string, token?: string) {
    this.baseUrl = baseUrl.replace(/\/$/, "");
    this.token = token;
  }

  private getHeaders(): Record<string, string> {
    const headers: Record<string, string> = {
      "Content-Type": "application/json",
    };
    if (this.token) headers["Authorization"] = `Bearer ${this.token}`;
    return headers;
  }

  async anonymizeText(
    text: string,
    options?: {
      entities?: string;
      customEntities?: CustomEntity[];
      startIndex?: number;
    }
  ): Promise<AnonymizeTextResponse> {
    const payload: Record<string, unknown> = {
      text,
      start_index: options?.startIndex ?? 0,
    };
    if (options?.entities) payload.entities = options.entities;
    if (options?.customEntities) payload.custom_entities = options.customEntities;

    const response = await fetch(`${this.baseUrl}/anonymize/text`, {
      method: "POST",
      headers: this.getHeaders(),
      body: JSON.stringify(payload),
    });
    return response.json();
  }
}

---

Next: Best Practices