SDK Examples

import hirebase

client = hirebase.Client()

result = client.jobs.search({
    "job_titles": ["Software Engineer", "Backend Engineer"],
    "location_types": ["Remote", "Hybrid"],
    "geo_locations": [
        {"city": "San Francisco", "region": "California", "country": "United States"}
    ],
    "days_ago": 30,
    "limit": 5,
})

print(f"{result.total_count:,} matches | page {result.page}/{result.total_pages}")
for job in result:  # JobSearchResult is iterable
    print(f"• {job.job_title} @ {job.company_name}")

# Detail page: fetch one job by id
if result.jobs:
    detail = client.jobs.get(result.jobs[0].id)
    print(detail.job_title, "—", (detail.technologies or [])[:6])

client.close()

import hirebase
from hirebase import NeuralVectorQuery

client = hirebase.Client()

# Natural-language query + lexical filters
result = client.jobs.neural_search(
    vector=NeuralVectorQuery(
        query="senior backend engineer building APIs with Python and distributed systems"
    ),
    lexical={
        "location_types": ["Remote", "Hybrid"],
        "experience": ["Senior"],
        "days_ago": 45,
        "limit": 5,
    },
)
for job in result:
    print(f"• {job.job_title} @ {job.company_name}")

# "Similar jobs" rail — reuse a posting's title as the semantic query
top = result.jobs[0]
similar = client.jobs.neural_search(
    vector=NeuralVectorQuery(query=top.job_title),
    lexical={"limit": 3},
)
for job in similar:
    print(f"  ↳ {job.job_title} @ {job.company_name}")

client.close()

import hirebase

client = hirebase.Client()

# `query` runs full-text search across name, description, products, tech stack, and culture
companies = client.companies.search({
    "query": "large language models, generative AI, computer vision, foundation models, AI agents",
    "limit": 5,
})
print(f"{companies.total_count:,} companies match")

for company in companies.companies:
    profile = client.companies.get(company.company_slug, return_jobs=False)
    insights = client.companies.insights(
        company.company_slug, query={"days_ago": 90}
    )
    techs = [t["key"] for t in (insights.top_technologies or [])[:3]]
    skills = [s["key"] for s in (insights.top_skills or [])[:3]]
    print(f"\n{company.company_name} ({company.company_slug})")
    print(f"  website:      {profile.company_link or '—'}")
    print(f"  technologies: {', '.join(techs) or '—'}")
    print(f"  skills:       {', '.join(skills) or '—'}")

client.close()

import hirebase

client = hirebase.Client()

insights = client.jobs.insights({
    "job_titles": ["Data Scientist", "Machine Learning Engineer"],
    "location_types": ["Remote"],
    "geo_locations": [{"country": "United States"}],
    "days_ago": 30,
    "hide_recruiting_agencies": True,
})

h = insights.headline
print(f"Cohort size:    {h.total_count:,}")
print(f"Median salary:  ${h.median_salary:,.0f}" if h.median_salary else "Median salary: n/a")
print(f"% remote:       {h.pct_remote:.1f}%")
print(f"Top technology: {h.top_technology or '—'}")

s = insights.salary
print(f"\nSalary p25/p50/p75: {s.p25} / {s.p50} / {s.p75}")

print("\nTop technologies:")
for item in insights.top_technologies[:8]:
    print(f"  • {item['key']}: {item['count']} ({item.get('percent', 0):.1f}%)")

client.close()

import hirebase

client = hirebase.Client()

# Keep limit small while testing — exports are metered by job count.
query = {
    "job_titles": ["Software Engineer"],
    "location_types": ["Remote"],
    "days_ago": 3,
    "return_raw_description": True,
}

# 1. Start the export → returns a Task
task = client.jobs.export(query, format="json")  # NDJSON (one job per line)
print("task:", task.id, task.state.value)

# 2. Poll until finished
def on_progress(t):
    print(f"  … {t.state.value} {t.progress:.0%}")

success, result = client.tasks.poll(task, interval=2, timeout=300, on_progress=on_progress)
if not success:
    raise RuntimeError(f"Export failed: {result.error}")

# 3. Download to disk (streamed)
client.stream_file(result["download_url"], file_path="./jobs.jsonl")

# 4. Stream-parse with constant memory
for job in client.jobs.stream_file("./jobs.jsonl"):
    print(job.job_title)

client.close()

import hirebase
from hirebase import NeuralVectorQuery

client = hirebase.Client()

# Parse + embed in one call (accepts a path or raw bytes); nothing is stored server-side
embed = client.resumes.embed("candidate-resume.pdf")
embedding = embed.result.embedding

# Match jobs using the resume embedding as the vector signal
matches = client.jobs.neural_search(
    vector=NeuralVectorQuery(vectors=[embedding]),
    lexical={"location_types": ["Remote", "Hybrid"], "days_ago": 30, "limit": 8},
)
for job in matches:
    print(f"• {job.job_title} @ {job.company_name}")

# Tighten with lexical filters on top of the resume signal
focused = client.jobs.neural_search(
    vector=NeuralVectorQuery(vectors=[embedding]),
    lexical={"job_titles": ["Software Engineer", "Machine Learning Engineer"], "limit": 5},
)
for job in focused:
    print(f"  ↳ {job.job_title} @ {job.company_name}")

client.close()

import hirebase
from hirebase import NeuralVectorQuery
from hirebase.exceptions import APIError

client = hirebase.Client()

try:
    embed = client.resumes.embed("candidate-resume.pdf")
except APIError as e:
    # Enterprise embed needs commercial embed permission on your key (else 403)
    print("Permission:", e.message)
    raise

embedding = embed.result.embedding
print("dim:", embed.result.dim, "| model:", embed.result.model_name, embed.result.model_version)

# Search with explicit vectors — keep the embedding in your own systems
matches = client.jobs.neural_search(
    vector=NeuralVectorQuery(vectors=[embedding]),
    lexical={"job_titles": ["Software Engineer", "Research Engineer"],
             "location_types": ["Remote"], "limit": 6},
)
for job in matches:
    print(f"• {job.job_title} @ {job.company_name}")

# Optional: blend a text query alongside the vector
blended = client.jobs.neural_search(
    vector=NeuralVectorQuery(
        query="computer vision and deep learning research",
        vectors=[embedding],
    ),
    lexical={"limit": 4},
)

client.close()

import hirebase

client = hirebase.Client()

# Resolve the company slug
hits = client.companies.search({"company_name": "OpenAI", "limit": 3})
slug = hits.companies[0].company_slug if hits.companies else "openai"

# Company-scoped insights
insights = client.companies.insights(slug, query={"days_ago": 90})
h = insights.headline
print(f"Median salary:  ${h.median_salary:,.0f}" if h.median_salary else "Median salary: n/a")
print(f"% remote:       {h.pct_remote:.1f}%")
print(f"Dominant level: {h.dominant_experience_level or '—'}")
for item in insights.top_technologies[:6]:
    print(f"  • {item['key']}: {item['count']}")

# Profile + bundled insights + recent openings
profile = client.companies.get(slug, return_jobs=True, return_insights=True)
print(f"\n{profile.company_name} — founded {profile.founded or '—'}")
for job in (profile.jobs or [])[:6]:
    print(f"  • {job.job_title}")

client.close()

import asyncio
import hirebase
from hirebase import NeuralVectorQuery

async def main():
    async with hirebase.AsyncClient() as client:
        result = await client.jobs.search(
            {"job_titles": ["Platform Engineer"], "location_types": ["Remote"], "limit": 3}
        )
        for job in result:
            print(job.job_title, "@", job.company_name)

        neural = await client.jobs.neural_search(
            vector=NeuralVectorQuery(query="kubernetes platform engineer infrastructure"),
            lexical={"location_types": ["Remote"], "limit": 3},
        )
        for job in neural:
            print(job.job_title, "@", job.company_name)

asyncio.run(main())