API documentation

api_base_url="https://www.cvlens.ai"

response=$(curl -sS -X POST "$api_base_url/api/cv-parser/parses" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "cv=@resume.docx" \
  -F "features[]=analysis")

poll_url=$(printf "%s" "$response" | jq -r '.poll_url')
case "$poll_url" in
  http*) ;;
  *) poll_url="$api_base_url$poll_url" ;;
esac

status=$(printf "%s" "$response" | jq -r '.status')

while [ "$status" = "queued" ] || [ "$status" = "processing" ]; do
  sleep 2
  response=$(curl -sS -X GET "$poll_url" \
    -H "Authorization: Bearer YOUR_API_KEY")
  status=$(printf "%s" "$response" | jq -r '.status')
done

printf "%s\n" "$response"

<?php

$apiBaseUrl = 'https://www.cvlens.ai';
$apiKey = 'YOUR_API_KEY';
function sendRequest(string $url, string $apiKey, ?string $filePath = null): array
{
    $curl = curl_init($url);

    $headers = [
        'Authorization: Bearer '.$apiKey,
        'Accept: application/json',
    ];

    $options = [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_TIMEOUT => 60,
    ];

    if ($filePath !== null) {
        $options[CURLOPT_POST] = true;
        $options[CURLOPT_POSTFIELDS] = [
            'cv' => new CURLFile($filePath, 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', basename($filePath)),
            'features[]' => 'analysis',
        ];
    }

    curl_setopt_array($curl, $options);

    $rawResponse = curl_exec($curl);

    if ($rawResponse === false) {
        throw new RuntimeException(curl_error($curl));
    }

    $statusCode = curl_getinfo($curl, CURLINFO_RESPONSE_CODE);

    curl_close($curl);

    if ($statusCode >= 400) {
        throw new RuntimeException($rawResponse);
    }

    return json_decode($rawResponse, true, 512, JSON_THROW_ON_ERROR);
}

$response = sendRequest("{$apiBaseUrl}/api/cv-parser/parses", $apiKey, 'resume.docx');
$pollUrl = str_starts_with($response['poll_url'], 'http') ? $response['poll_url'] : $apiBaseUrl.$response['poll_url'];

while (in_array($response['status'], ['queued', 'processing'], true)) {
    sleep(2);

    $response = sendRequest($pollUrl, $apiKey);
}

echo json_encode($response, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR).PHP_EOL;

import { openAsBlob } from 'node:fs';

const apiBaseUrl = 'https://www.cvlens.ai';
const apiKey = 'YOUR_API_KEY';

const form = new FormData();
form.set('cv', await openAsBlob('resume.docx'), 'resume.docx');
form.append('features[]', 'analysis');

let response = await fetch(`${apiBaseUrl}/api/cv-parser/parses`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${apiKey}`,
  },
  body: form,
}).then(async (result) => {
  if (!result.ok) {
    throw new Error(await result.text());
  }

  return result.json();
});

let pollUrl = response.poll_url.startsWith('http')
  ? response.poll_url
  : `${apiBaseUrl}${response.poll_url}`;

while (response.status === 'queued' || response.status === 'processing') {
  await new Promise((resolve) => setTimeout(resolve, 2_000));

  response = await fetch(pollUrl, {
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
  }).then(async (result) => {
    if (!result.ok) {
      throw new Error(await result.text());
    }

    return result.json();
  });
}

console.log(JSON.stringify(response, null, 2));

import json
import time

import requests

api_base_url = "https://www.cvlens.ai"
api_key = "YOUR_API_KEY"

with open("resume.docx", "rb") as cv_file:
    response = requests.post(
        f"{api_base_url}/api/cv-parser/parses",
        headers={"Authorization": f"Bearer {api_key}"},
        files={"cv": ("resume.docx", cv_file)},
        data={"features[]": "analysis"},
        timeout=60,
    )
    response.raise_for_status()
    payload = response.json()

poll_url = payload["poll_url"]
if not poll_url.startswith("http"):
    poll_url = f"{api_base_url}{poll_url}"

while payload["status"] in {"queued", "processing"}:
    time.sleep(2)
    response = requests.get(
        poll_url,
        headers={"Authorization": f"Bearer {api_key}"},
        timeout=60,
    )
    response.raise_for_status()
    payload = response.json()

print(json.dumps(payload, indent=2))

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

HttpClient client = HttpClient.newHttpClient();
String apiBaseUrl = "https://www.cvlens.ai";
String apiKey = "YOUR_API_KEY";
String boundary = "----CVLensBoundary";
byte[] fileBytes = Files.readAllBytes(Path.of("resume.docx"));

String multipartBody =
    "--" + boundary + "\r\n"
    + "Content-Disposition: form-data; name=\"cv\"; filename=\"resume.docx\"\r\n"
    + "Content-Type: application/vnd.openxmlformats-officedocument.wordprocessingml.document\r\n\r\n"
    + new String(fileBytes, StandardCharsets.ISO_8859_1) + "\r\n"
    + "--" + boundary + "\r\n"
    + "Content-Disposition: form-data; name=\"features[]\"\r\n\r\n"
    + "analysis\r\n"
    + "--" + boundary + "--\r\n";

HttpRequest createRequest = HttpRequest.newBuilder()
    .uri(URI.create(apiBaseUrl + "/api/cv-parser/parses"))
    .timeout(Duration.ofSeconds(60))
    .header("Authorization", "Bearer " + apiKey)
    .header("Content-Type", "multipart/form-data; boundary=" + boundary)
    .POST(HttpRequest.BodyPublishers.ofString(multipartBody, StandardCharsets.ISO_8859_1))
    .build();

HttpResponse<String> response = client.send(createRequest, HttpResponse.BodyHandlers.ofString());
String payload = response.body();
Pattern pollUrlPattern = Pattern.compile("\"poll_url\"\\s*:\\s*\"([^\"]+)\"");
Pattern statusPattern = Pattern.compile("\"status\"\\s*:\\s*\"([^\"]+)\"");
Matcher pollUrlMatcher = pollUrlPattern.matcher(payload);

if (!pollUrlMatcher.find()) {
    throw new IllegalStateException("poll_url missing from response");
}

String pollUrl = pollUrlMatcher.group(1);
if (!pollUrl.startsWith("http")) {
    pollUrl = apiBaseUrl + pollUrl;
}

String status = extractStatus(statusPattern, payload);

while (status.equals("queued") || status.equals("processing")) {
    Thread.sleep(2000);

    HttpRequest pollRequest = HttpRequest.newBuilder()
        .uri(URI.create(pollUrl))
        .timeout(Duration.ofSeconds(60))
        .header("Authorization", "Bearer " + apiKey)
        .GET()
        .build();

    response = client.send(pollRequest, HttpResponse.BodyHandlers.ofString());
    payload = response.body();
    status = extractStatus(statusPattern, payload);
}

System.out.println(payload);

static String extractStatus(Pattern statusPattern, String payload) {
    Matcher statusMatcher = statusPattern.matcher(payload);

    if (!statusMatcher.find()) {
        throw new IllegalStateException("status missing from response");
    }

    return statusMatcher.group(1);
}