Building AI Agents with Laddro

Use the Laddro Career API to build autonomous agents that manage career tasks — from resume tailoring to bulk job applications.

What Agents Can Do

Agent Type	Description
Resume Tailor Agent	Takes a resume and a list of job URLs, tailors the resume for each, exports PDFs
Job Application Bot	Parses a resume, matches to job boards, tailors + generates cover letters for each
Career Coach Agent	Analyzes a resume, suggests improvements, rewrites weak sections
Batch Export Agent	Renders a resume across all 22 templates, compares layouts
Interview Prep Agent	Reads a tailored resume + job description, generates likely interview questions

Architecture


User → Agent (Claude Code / LangChain / Custom) → Laddro Career API
                                                    ├── Parse resume
                                                    ├── Tailor for job
                                                    ├── Generate cover letter
                                                    └── Export PDF

Your agent calls the API endpoints directly (REST) or uses the MCP server (for Claude-based agents). The API handles AI processing, PDF rendering, and data storage.

Option 1: MCP-Based Agent (Claude Code)

The fastest way. Configure the MCP server and Claude calls the tools automatically.


{
  "mcpServers": {
    "laddro": {
      "command": "npx",
      "args": ["-y", "@laddro/career-mcp"],
      "env": {
        "LADDRO_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Then ask Claude:


"Parse my resume from resume.pdf, tailor it for this job posting
at https://example.com/senior-engineer, and generate a cover letter.
Export both as PDFs using the Graphite template."

Claude will chain the API calls: parse → tailor → generate cover letter → export.

Option 2: REST API Agent (Any Framework)

Build a custom agent using any framework — LangChain, CrewAI, AutoGen, or plain code.

Resume Tailor Agent (Python)


import requests
 
API_KEY = "YOUR_API_KEY"
BASE = "https://api.laddro.com/v1"
HEADERS = {"x-api-key": API_KEY, "Content-Type": "application/json"}
 
def tailor_for_jobs(resume_id, job_descriptions):
    results = []
    for jd in job_descriptions:
        # Tailor resume (3 credits)
        resp = requests.post(f"{BASE}/tailor", headers=HEADERS, json={
            "resumeId": resume_id,
            "jobDescription": jd
        })
        tailored = resp.json()
 
        # Generate cover letter (2 credits)
        resp = requests.post(f"{BASE}/cover-letters/generate", headers=HEADERS, json={
            "resumeId": resume_id,
            "jobDescription": jd
        })
        cover_letter = resp.json()
 
        # Export PDF (1 credit)
        resp = requests.post(f"{BASE}/export", headers=HEADERS, json={
            "resumeId": resume_id,
            "templateId": "graphite"
        })
 
        results.append({
            "job": jd[:50],
            "tailored": tailored,
            "coverLetter": cover_letter
        })
 
    return results

Streaming Agent (TypeScript)


const response = await fetch('https://api.laddro.com/v1/tailor', {
  method: 'POST',
  headers: {
    'x-api-key': API_KEY,
    'Content-Type': 'application/json',
    'Accept': 'text/event-stream'  // Enable streaming
  },
  body: JSON.stringify({ resumeId, jobDescription })
})
 
const reader = response.body.getReader()
const decoder = new TextDecoder()
 
while (true) {
  const { done, value } = await reader.read()
  if (done) break
 
  const lines = decoder.decode(value).split('\n')
  for (const line of lines) {
    if (line.startsWith('data: ')) {
      const event = JSON.parse(line.slice(6))
      if (event.type === 'done') return
      // Process each section as it streams in
      agent.process(event.section, event.content)
    }
  }
}

API Endpoints for Agents

These are the most useful endpoints for agent workflows:

Endpoint	Credits	Use Case
`POST /v1/resumes/parse`	2	Ingest a resume from PDF/DOCX
`POST /v1/tailor`	3	Tailor resume for a specific job
`POST /v1/cover-letters/generate`	2	Generate a targeted cover letter
`POST /v1/export`	1	Export resume as PDF
`PUT /v1/resumes/{id}/render`	1	Render with a specific template
`GET /v1/templates`	0	List available templates
`GET /v1/resumes`	0	List user’s resumes

Credit Planning for Agents

A typical “apply to one job” workflow:

Step	Credits
Parse resume (once)	2
Tailor for job	3
Generate cover letter	2
Export resume PDF	1
Export cover letter PDF	1
Total per job	9 (7 after first parse)

With the free tier (50 credits/month), you can apply to ~7 jobs. Subscribers (200/month) can do ~28. Buy credit packs for higher volume.

Best Practices

Parse once, tailor many — Parse the resume once and reuse the resumeId for all tailoring and cover letter generation.
Use streaming — For user-facing agents, use SSE streaming (Accept: text/event-stream) so users see results in real-time.
Handle 402 errors — Check credit balance before batch operations. The API returns 402 Payment Required when credits run out.
Use BYOK for volume — If you’re building a high-volume agent, use BYOK with your own AI provider key to avoid per-request AI costs.
Rate limit awareness — Public endpoints: 30 req/min. Protected: 100 req/min. Build in backoff for 429 responses.