Lookalike Search

API_KEY="YOUR_API_KEY"
BASE_URL="https://api.sixtyfour.ai"

START_RESPONSE=$(curl -fsS --max-time 120 -X POST "$BASE_URL/search/lookalike" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "linkedin_urls": [
      "https://www.linkedin.com/in/ada-lovelace",
      "https://www.linkedin.com/in/grace-hopper"
    ],
    "guidance": "Only people in the United States"
  }')

TASK_ID=$(printf '%s' "$START_RESPONSE" | jq -r '.task_id')
DEADLINE=$(( $(date +%s) + 30 * 60 ))

while true; do
  if [ "$(date +%s)" -ge "$DEADLINE" ]; then
    printf '%s\n' "Search did not complete within 30 minutes"
    exit 1
  fi

  HTTP_CODE=$(curl -sS --connect-timeout 10 --max-time 30 \
    -o status.json -D headers.txt -w '%{http_code}' \
    "$BASE_URL/search/lookalike/$TASK_ID?include_filters=false" \
    -H "x-api-key: $API_KEY")

  if [ "$HTTP_CODE" = "429" ] || [ "$HTTP_CODE" = "503" ]; then
    RETRY_AFTER=$(awk 'tolower($1) == "retry-after:" {print $2}' headers.txt | tr -d '\r')
    sleep "${RETRY_AFTER:-10}"
    continue
  fi
  if [ "$HTTP_CODE" != "200" ]; then
    cat status.json
    exit 1
  fi

  STATUS=$(jq -r '.status' status.json)
  if [ "$STATUS" = "completed" ]; then
    SEARCH_ID=$(jq -r '.search_id' status.json)
    break
  fi
  if [ "$STATUS" != "running" ]; then
    cat status.json
    exit 1
  fi

  sleep 10
done

curl -fsS -X POST "$BASE_URL/search/query" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"search_id\":\"$SEARCH_ID\",\"page_size\":25}"

import time

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.sixtyfour.ai"
HEADERS = {
    "x-api-key": API_KEY,
    "Content-Type": "application/json",
}

start_response = requests.post(
    f"{BASE_URL}/search/lookalike",
    headers=HEADERS,
    json={
        "linkedin_urls": [
            "https://www.linkedin.com/in/ada-lovelace",
            "https://www.linkedin.com/in/grace-hopper",
        ],
        "guidance": "Only people in the United States",
    },
    timeout=(10, 120),
)
start_response.raise_for_status()
task_id = start_response.json()["task_id"]
deadline = time.monotonic() + 30 * 60

while True:
    if time.monotonic() >= deadline:
        raise TimeoutError("Search did not complete within 30 minutes")
    status_response = requests.get(
        f"{BASE_URL}/search/lookalike/{task_id}",
        headers=HEADERS,
        params={"include_filters": "false"},
        timeout=(10, 30),
    )
    if status_response.status_code in (429, 503):
        time.sleep(int(status_response.headers.get("Retry-After", "10")))
        continue
    status_response.raise_for_status()
    status_data = status_response.json()

    if status_data["status"] == "completed":
        search_id = status_data["search_id"]
        break
    if status_data["status"] != "running":
        raise RuntimeError(
            status_data.get("error") or f"Search {status_data['status']}"
        )

    time.sleep(10)

page_response = requests.post(
    f"{BASE_URL}/search/query",
    headers=HEADERS,
    json={"search_id": search_id, "page_size": 25},
)
page_response.raise_for_status()
page = page_response.json()

for person in page["results"]:
    print(
        person["raw_source"].get("fullName"),
        person["raw_source"].get("headline"),
        person["raw_score"],
    )

const API_KEY = "YOUR_API_KEY";
const BASE_URL = "https://api.sixtyfour.ai";
const headers = {
  "x-api-key": API_KEY,
  "Content-Type": "application/json",
};
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function requestJson(url, options = {}, timeoutMs = 30_000) {
  for (let attempt = 0; attempt < 5; attempt++) {
    const response = await fetch(url, {
      ...options,
      signal: AbortSignal.timeout(timeoutMs),
    });
    if (response.status === 429 || response.status === 503) {
      await sleep(Number(response.headers.get("Retry-After") ?? 10) * 1000);
      continue;
    }
    if (!response.ok) {
      throw new Error(`${response.status}: ${await response.text()}`);
    }
    return response.json();
  }
  throw new Error(`${url} kept returning 429 or 503`);
}

async function main() {
  const started = await requestJson(
    `${BASE_URL}/search/lookalike`,
    {
      method: "POST",
      headers,
      body: JSON.stringify({
        linkedin_urls: [
          "https://www.linkedin.com/in/ada-lovelace",
          "https://www.linkedin.com/in/grace-hopper",
        ],
        guidance: "Only people in the United States",
      }),
    },
    120_000,
  );

  let searchId;
  const deadline = Date.now() + 30 * 60_000;
  while (!searchId) {
    if (Date.now() >= deadline) {
      throw new Error("Search did not complete within 30 minutes");
    }
    const params = new URLSearchParams({
      include_filters: "false",
    });
    const status = await requestJson(
      `${BASE_URL}/search/lookalike/${started.task_id}?${params}`,
      { headers },
    );

    if (status.status === "completed") {
      searchId = status.search_id;
      break;
    }
    if (status.status !== "running") {
      throw new Error(status.error ?? `Search ${status.status}`);
    }

    await sleep(10_000);
  }

  const page = await requestJson(
    `${BASE_URL}/search/query`,
    {
      method: "POST",
      headers,
      body: JSON.stringify({ search_id: searchId, page_size: 25 }),
    },
    120_000,
  );

  for (const person of page.results) {
    console.log(
      person.raw_source?.fullName,
      person.raw_source?.headline,
      person.raw_score,
    );
  }
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

UPLOAD=$(curl -fsS -X POST "https://api.sixtyfour.ai/storage/csv/upload" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@lookalike-seeds.csv;type=text/csv")

HANDLE_ID=$(printf '%s' "$UPLOAD" | jq -r '.handle_id')

curl -fsS -X POST "https://api.sixtyfour.ai/search/lookalike" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"csv_resource_handle_id\":\"$HANDLE_ID\"}"

import requests

headers = {"x-api-key": "YOUR_API_KEY"}

with open("lookalike-seeds.csv", "rb") as csv_file:
    upload_response = requests.post(
        "https://api.sixtyfour.ai/storage/csv/upload",
        headers=headers,
        files={"file": ("lookalike-seeds.csv", csv_file, "text/csv")},
    )
upload_response.raise_for_status()
handle_id = upload_response.json()["handle_id"]

start_response = requests.post(
    "https://api.sixtyfour.ai/search/lookalike",
    headers={**headers, "Content-Type": "application/json"},
    json={"csv_resource_handle_id": handle_id},
)
start_response.raise_for_status()
print(start_response.json())

import { readFile } from "node:fs/promises";

const headers = { "x-api-key": "YOUR_API_KEY" };
const csv = await readFile("lookalike-seeds.csv");
const form = new FormData();
form.append(
  "file",
  new Blob([csv], { type: "text/csv" }),
  "lookalike-seeds.csv",
);

const uploadResponse = await fetch(
  "https://api.sixtyfour.ai/storage/csv/upload",
  { method: "POST", headers, body: form },
);
if (!uploadResponse.ok) throw new Error(await uploadResponse.text());
const { handle_id } = await uploadResponse.json();

const startResponse = await fetch(
  "https://api.sixtyfour.ai/search/lookalike",
  {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify({ csv_resource_handle_id: handle_id }),
  },
);
if (!startResponse.ok) throw new Error(await startResponse.text());
console.log(await startResponse.json());