File Metadata Extraction API

curl -X GET "https://api.synvo.ai/metadata/search_by_id/doc_abc123xyz/" \
  -H "X-API-Key: ${API_TOKEN}" \
  -H "Content-Type: application/json"

import requests

api_token = "<API_TOKEN>"
file_id = "doc_abc123xyz"
url = f"https://api.synvo.ai/metadata/search_by_id/{file_id}/"
headers = {
    "X-API-Key": api_token,
    "Content-Type": "application/json"
}

response = requests.get(url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const apiToken = "<API_TOKEN>";
const fileId = "doc_abc123xyz";

const response = await fetch(
  `https://api.synvo.ai/metadata/search_by_id/${fileId}/`,
  {
    method: "GET",
    headers: {
      "X-API-Key": apiToken,
      "Content-Type": "application/json"
    }
  }
);

if (!response.ok) {
  throw new Error(`Request failed: ${response.status}`);
}

console.log(await response.json());

# Note: File path should be URL-encoded
curl -X GET "https://api.synvo.ai/metadata/search_by_path/%2Fdocuments%2Fresearch%2FRAG_paper.pdf/" \
  -H "X-API-Key: ${API_TOKEN}" \
  -H "Content-Type: application/json"

import requests
from urllib.parse import quote

api_token = "<API_TOKEN>"
file_path = "/documents/research/RAG_paper.pdf"
encoded_path = quote(file_path, safe="/")
url = f"https://api.synvo.ai/metadata/search_by_path/{encoded_path}/"
headers = {
    "X-API-Key": api_token,
    "Content-Type": "application/json"
}

response = requests.get(url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const apiToken = "<API_TOKEN>";
const filePath = "/documents/research/RAG_paper.pdf";
const encodedPath = encodeURIComponent(filePath);

const response = await fetch(
  `https://api.synvo.ai/metadata/search_by_path/${encodedPath}/`,
  {
    method: "GET",
    headers: {
      "X-API-Key": apiToken,
      "Content-Type": "application/json"
    }
  }
);

if (!response.ok) {
  throw new Error(`Request failed: ${response.status}`);
}

console.log(await response.json());

import requests
import time

api_token = "<API_TOKEN>"
BASE_URL = "https://api.synvo.ai"

# Step 1: Upload a document
print("📤 Uploading document...")
with open("/path/to/research_paper.pdf", "rb") as f:
    files = {"file": f}
    upload_response = requests.post(
        f"{BASE_URL}/file/upload",
        files=files,
        headers={"X-API-Key": api_token},
        timeout=60
    )
    upload_result = upload_response.json()
    file_id = upload_result["file_id"]
    file_path = upload_result["path"] + upload_result["filename"]
    print(f"✓ Uploaded: {upload_result['filename']} (ID: {file_id})")

# Step 2: Wait for processing to complete
print("\n⏳ Processing document...")
max_attempts = 30
for attempt in range(max_attempts):
    status_response = requests.get(
        f"{BASE_URL}/file/status/{file_id}",
        headers={"X-API-Key": api_token},
        timeout=10
    )
    status = status_response.json()["status"]
    
    if status == "COMPLETED":
        print("✅ Processing complete!")
        break
    elif status == "FAILED":
        print("❌ Processing failed!")
        exit(1)
    
    time.sleep(2)

# Step 3: Retrieve metadata using file ID
print("\n📊 Fetching metadata by ID...")
metadata_response = requests.get(
    f"{BASE_URL}/metadata/search_by_id/{file_id}/",
    headers={"X-API-Key": api_token},
    timeout=30
)
metadata = metadata_response.json()

print("\n✨ Metadata Summary:")
print(f"\n📝 Summary:\n{metadata['summary'][:500]}...")
print(f"\n📑 Content Preview:\n{metadata['content'][:500]}...")
print(f"\n🏷️ Hashtags: {', '.join(metadata['hash_tags'])}")

# Step 4: Alternative - Retrieve metadata using file path
print(f"\n📁 Fetching metadata by path: {file_path}")
from urllib.parse import quote
encoded_path = quote(file_path, safe="/")

path_response = requests.get(
    f"{BASE_URL}/metadata/search_by_path/{encoded_path}/",
    headers={"X-API-Key": api_token},
    timeout=30
)
path_metadata = path_response.json()

# Both methods return the same metadata
assert metadata == path_metadata
print("✓ Metadata retrieved successfully via both methods!")

const apiToken = "<API_TOKEN>";
const BASE_URL = "https://api.synvo.ai";

async function metadataWorkflow() {
  // Step 1: Upload a document
  console.log("📤 Uploading document...");
  const fileInput = document.querySelector('input[type="file"]');
  const file = fileInput.files[0];
  
  const formData = new FormData();
  formData.append("file", file);
  
  const uploadResponse = await fetch(`${BASE_URL}/file/upload`, {
    method: "POST",
      headers: { "X-API-Key": apiToken },
    body: formData
  });
  
  const uploadResult = await uploadResponse.json();
  const fileId = uploadResult.file_id;
  const filePath = uploadResult.path + uploadResult.filename;
  console.log(`✓ Uploaded: ${uploadResult.filename} (ID: ${fileId})`);
  
  // Step 2: Wait for processing to complete
  console.log("\n⏳ Processing document...");
  let status = "PENDING";
  const maxAttempts = 30;
  
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const statusResponse = await fetch(
      `${BASE_URL}/file/status/${fileId}`,
      {
        headers: { "X-API-Key": apiToken }
      }
    );
    
    const statusData = await statusResponse.json();
    status = statusData.status;
    
    if (status === "COMPLETED") {
      console.log("✅ Processing complete!");
      break;
    } else if (status === "FAILED") {
      console.log("❌ Processing failed!");
      return;
    }
    
    await new Promise(resolve => setTimeout(resolve, 2000));
  }
  
  // Step 3: Retrieve metadata using file ID
  console.log("\n📊 Fetching metadata by ID...");
  const metadataResponse = await fetch(
    `${BASE_URL}/metadata/search_by_id/${fileId}/`,
    {
      headers: { "X-API-Key": apiToken }
    }
  );
  
  const metadata = await metadataResponse.json();
  
  console.log("\n✨ Metadata Summary:");
  console.log(`\n📝 Summary:\n${metadata.summary.substring(0, 500)}...`);
  console.log(`\n📑 Content Preview:\n${metadata.content.substring(0, 500)}...`);
  console.log(`\n🏷️ Hashtags: ${metadata.hash_tags.join(", ")}`);
  
  // Step 4: Alternative - Retrieve metadata using file path
  console.log(`\n📁 Fetching metadata by path: ${filePath}`);
  const encodedPath = encodeURIComponent(filePath);
  
  const pathResponse = await fetch(
    `${BASE_URL}/metadata/search_by_path/${encodedPath}/`,
    {
      headers: { "X-API-Key": apiToken }
    }
  );
  
  const pathMetadata = await pathResponse.json();
  
  // Both methods return the same metadata
  console.log("✓ Metadata retrieved successfully via both methods!");
}

// Execute workflow
metadataWorkflow();