Agentic AI + Python SDK

The Career API for AI Agents

Give your AI agents career superpowers. 220+ API endpoints for resume tailoring, job search, auto-apply, and interview prep. Works with LangChain, CrewAI, AutoGen, OpenClaw, and MCP.

pip install resumly
quickstart.py
from resumly import ResumlyClient

client = ResumlyClient(api_key="rly_...")

# Create a tailored resume in one call
result = client.create_resume(
    job_url="https://careers.acme.com/senior-engineer",
    cover_letter=True,
    interview_question=True,
)

print(f"Resume ready: {result['job_id']}")

Trusted by Professionals at Leading Companies

Join thousands of job seekers who have landed roles at top organizations with Resumly

220+API Endpoints
1M+Jobs Indexed Monthly
<200msMedian Latency
99.9%Uptime SLA
Built For You

Who Uses the Resumly API?

Whether you're a solo developer, a startup, or a global institution — the API scales to fit your use case.

🚀

Startup Founders

Build a career-tech startup without building career infrastructure. Launch a job board, resume optimizer, or career coaching platform using Resumly as your backend.

See Use Cases
🎓

Universities & Bootcamps

Embed AI resume reviews, job matching, and interview prep directly into your career services portal. Serve thousands of students at scale.

Contact Sales
🏛️

Career Centers & Workforce Agencies

Automate resume workshops, job placement pipelines, and outcome tracking. Help more clients land jobs with fewer staff hours.

Contact Sales
🌍

Immigration & Settlement NGOs

Help newcomers create locally-optimized resumes, navigate job markets, and auto-apply to relevant opportunities in their new country.

Contact Sales
🤖

AI Agent Developers

Give your autonomous agents career superpowers. Every SDK method is a tool call — ready for LangChain, CrewAI, AutoGen, OpenClaw, or MCP.

Read the Docs
🏢

Staffing & Recruiting Firms

Build ATS scoring, resume parsing, and candidate matching into your internal tools. Process candidates 10x faster through the API.

Contact Sales

What Will You Build?

From single-purpose scripts to fully autonomous career agents — the API adapts to your architecture.

🤖

Autonomous Career Agent

Build end-to-end career agents that search jobs, evaluate fit, tailor resumes, and auto-apply — all without human intervention.

🔌

MCP Tool Server

Expose Resumly as an MCP server so any AI assistant — Claude, GPT, Cursor, or custom — can use career tools natively.

👥

Multi-Agent Crew

Assign specialized roles: one agent researches companies, another tailors resumes, a third handles applications. CrewAI + Resumly.

Bulk Resume Pipeline

Process hundreds of job applications programmatically. Batch-create tailored resumes and cover letters at scale.

🏢

HR & Recruiting Automation

Build resume parsing, ATS scoring, and candidate matching into your recruiting workflows via API.

🔗

Career Platform Integration

Embed Resumly's intelligence into job boards, career coaches, EdTech platforms, and workforce tools.

Up and Running in Minutes

Three steps from zero to your first API call.

01

Get Your API Key

Create a free account and generate an API key from your dashboard in seconds.

# Dashboard → Settings → API Keys
02

Install the SDK

One command. Python 3.8+, zero config.

pip install resumly
03

Build

220+ methods covering every feature. Ship in minutes, not weeks.

client = ResumlyClient(api_key="rly_...")

220+ Endpoints. One SDK.

Every feature in Resumly is accessible through the API. No UI required.

Resume Intelligence

  • Upload & parse resumes (PDF/DOCX)
  • AI-tailored resumes per job
  • Cover letter generation
  • ATS optimization & scoring
  • Resume comparison & insights
  • Template rendering & PDF export

Job Search & Matching

  • AI-powered job discovery
  • Vector-based match scoring
  • Save, skip, and block jobs
  • Search agent management
  • Real-time job status tracking

Auto-Apply & Automation

  • Queue jobs for auto-apply
  • Application form autofill
  • Status tracking & retry
  • Batch resume processing
  • Email inbox (compose & reply)

Career Growth

  • Interview question generation
  • Answer evaluation & scoring
  • Personalized learning courses
  • LinkedIn profile optimization
  • 11 career calculator tools
  • Company research

Code That Speaks for Itself

Clean, Pythonic methods. No boilerplate. Every operation is a single function call with full type hints and docstrings.

  • Automatic rate-limit retry with backoff
  • File upload helpers for PDF/DOCX/audio
  • Two-step resume creation handled in one call
  • Full Pydantic models for type safety
quickstart.py
from resumly import ResumlyClient

client = ResumlyClient(api_key="rly_...")

# Create a tailored resume in one call
result = client.create_resume(
    job_url="https://careers.acme.com/senior-engineer",
    cover_letter=True,
    interview_question=True,
)

print(f"Resume ready: {result['job_id']}")
Agentic Workflow

How AI Agents Use Resumly

Your agent handles the entire career pipeline through a sequence of API calls.

📩Agent receives task
🔍Searches jobs via API
🎯Evaluates match scores
📝Tailors resume + cover letter
Queues auto-apply
Reports results back
Save Months of Work

Build It Yourself vs. One API Call

Every feature you'd spend weeks building is already a single endpoint.

FeatureBuild from ScratchWith Resumly API
Job search + matching2-4 weeks1 API call
Resume tailoring (ATS-optimized)3-6 weeks1 API call
Cover letter generation1-2 weeks1 API call
Auto-apply pipeline4-8 weeks3 API calls
Interview question generation1-3 weeks1 API call
ATS scoring + analysis2-4 weeks1 API call
LinkedIn profile optimization1-2 weeks1 API call
Email inbox management2-3 weeks1 API call
Framework Integrations

Works With Every Agentic Framework

Resumly is designed for the agentic era. Every SDK method is a stateless, atomic API call — a natural fit as a tool in any agent framework.

LangChain

Wrap SDK methods as @tool-decorated functions for any LangChain agent.

CrewAI

Create BaseTool subclasses with typed Pydantic schemas for role-based crews.

AutoGen

Register tools on ConversableAgent for multi-agent conversations.

OpenClaw

Add career tools to your OpenClaw character with async tool functions.

MCP

Expose Resumly as an MCP server — works with Claude, GPT, Cursor, and more.

OpenAI Agents

Use function tools with the OpenAI Agents SDK for GPT-powered workflows.

langchain_tools.py
from langchain_core.tools import tool
from resumly import ResumlyClient

client = ResumlyClient(api_key="rly_...")

@tool
def search_jobs(query: str) -> str:
    """Search for jobs matching a query and return top matches."""
    client.generate_and_run_search()
    jobs = client.get_relevant_jobs()
    return str(jobs["jobs"][:5])

@tool
def tailor_resume(job_description: str) -> str:
    """Create an ATS-optimized resume tailored to a job description."""
    result = client.create_resume(
        job_description=job_description,
        cover_letter=True,
    )
    return f"Resume created: {result['job_id']}"

@tool
def get_match_score(job_description: str) -> str:
    """Score how well the candidate matches a job."""
    score = client.get_job_match_score(
        job_description=job_description
    )
    return f"Match: {score['score']}%"
Built for Agents

Why Agents Choose Resumly

Every design decision in the API was made with autonomous agents in mind.

Tool-ready — Each method is an atomic operation agents call independently.
Stateless — API-key auth on every request. Perfect for serverless agents.
Composable — Chain search, tailor, apply, and track in any order.
MCP-native — Expose as an MCP server for any AI assistant.
career_agent.py
from resumly import ResumlyClient

client = ResumlyClient(api_key="rly_...")

# Full autonomous pipeline in 5 calls
client.embed_base_resume()
client.generate_and_run_search()

jobs = client.get_relevant_jobs()
for job in jobs["jobs"][:3]:
    resume = client.create_resume(
        job_description=job["description"],
        cover_letter=True,
    )
    client.queue_auto_apply(
        job_id=job["job_id"],
        resume_id=resume["job_id"],
    )
    print(f"Applied to {job['title']}")
Enterprise Ready

Security & Reliability

Production-grade infrastructure you can trust with your users' career data.

🔑

API Key Authentication

Scoped API keys with per-key permissions. Rotate or revoke instantly from your dashboard.

🔒

HTTPS Everywhere

All API traffic encrypted in transit with TLS 1.3. No plaintext endpoints.

🛡️

Rate Limiting & DDoS Protection

Built-in rate limits with automatic backoff. SDK handles retries transparently.

📋

SOC 2 Aligned

Enterprise-grade data handling practices. Your users' data stays private and secure.

Pricing

Simple, Transparent API Pricing

Start free. Scale when you're ready. Enterprise plans for organizations that need SLAs, dedicated support, and unlimited volume.

Developer

For individual developers building prototypes and side projects.

Free
  • 100 API calls / month
  • All 220+ endpoints
  • Python SDK access
  • Community support
  • Rate limit: 10 req/min
Most Popular

Startup

For startups and small teams shipping career automation products.

$99/mo
  • 10,000 API calls / month
  • All 220+ endpoints
  • Priority rate limits
  • Email support
  • Webhook notifications
  • Batch processing

Enterprise

For universities, agencies, and organizations needing scale, SLAs, and dedicated support.

Custom
  • Unlimited API calls
  • Dedicated account manager
  • Custom SLA & uptime guarantee
  • SSO & team management
  • On-premise deployment option
  • White-label available
  • Priority phone & Slack support

Start Building Your Career Agent Today

Free tier available. No credit card required. Get your API key, install the SDK, and ship your first agentic integration in minutes.

Developer FAQ

Common questions about the Resumly API, Python SDK, and agentic framework integrations.

All requests use an API key passed via the X-API-Key header. Generate keys from your Resumly dashboard under Settings. The Python SDK handles this automatically when you pass your key to ResumlyClient.

Yes. The API enforces rate limits that vary by plan. The SDK automatically retries on 429 responses with exponential backoff (configurable via max_retries).

Resumly works with any framework that supports function/tool calling. We have tested integrations with LangChain, CrewAI, AutoGen, OpenClaw, the OpenAI Agents SDK, and the Model Context Protocol (MCP). Every SDK method is a single stateless call, making it trivial to wrap as a tool.

Import ResumlyClient and wrap any method with LangChain's @tool decorator. The SDK methods accept simple arguments and return JSON, which is exactly what LangChain agents expect. See the LangChain code example on this page.

Create a BaseTool subclass with a Pydantic input schema, then call ResumlyClient methods inside _run(). You can assign Resumly tools to specialized agents like a Resume Writer or Job Searcher in your crew. See the CrewAI code example on this page.

Yes. You can build an MCP server that exposes Resumly's capabilities as typed tools. Any MCP-compatible AI assistant — Claude, GPT, Cursor, Windsurf, or custom agents — can then use career tools like job search, resume tailoring, and auto-apply natively.

Define async tool functions that call ResumlyClient methods and register them in your OpenClaw character configuration. OpenClaw agents can then autonomously search for jobs, create tailored resumes, and submit applications.

Absolutely. An agent can call embed_base_resume(), generate_and_run_search(), get_relevant_jobs(), create_resume(), and queue_auto_apply() in sequence — fully autonomously. The API is stateless and composable, so agents can chain calls in any order.

PDF and DOCX. The API parses the document, extracts structured data, and makes it available as JSON for all downstream operations including tailoring, matching, and ATS scoring.

Use init_batch() with a list of job URLs or descriptions, then process_batch() to create tailored resumes for all of them in parallel. Track progress with get_batch().

Yes. Free accounts get a set number of credits per month. Each API operation consumes credits. Upgrade for higher limits and additional features like auto-apply and priority processing.