Job description to recruiter briefing document automation

Recruiting teams waste hours on repetitive work. A job description arrives, someone reads it carefully, and then they rewrite the same information into a recruiter briefing document. The content is identical; only the format changes. The recruiter might summarise key points, highlight critical requirements, and reorganise sections for quick scanning. This takes thirty minutes to an hour per job, and most teams do this manually for every single opening.

What if this entire process ran automatically the moment a job description landed in your inbox? The right tools, connected in sequence, can transform a raw job posting into a polished recruiter briefing document without anyone touching a keyboard after the initial trigger. No copy-pasting. No reformatting. Just a briefing document ready to send to your recruitment team.

This Alchemy workflow combines three focused AI tools through a simple orchestration layer. Copy.ai generates initial structure and tone customisation, Quillbot refines the language for clarity, and Resoomer.ai condenses information into concise summary sections. The result: a workflow that takes five minutes to set up and handles job descriptions of any length automatically.

The Automated Workflow

This workflow works best with one of four orchestration platforms. We'll use Zapier for the initial example because its interface is most accessible for beginners; we'll also show how to adapt this for n8n, Make, and Claude Code at the end.

Architecture Overview

The workflow follows this sequence:

1. Job description enters the system (via email, form submission, or API call)
2. Copy.ai restructures content into recruiter-friendly sections
3. Quillbot polishes language for readability and tone
4. Resoomer.ai creates executive-level summaries
5. Final document is compiled and delivered

Setting Up in Zapier

Start by creating a new Zapier Zap. Set your trigger as Gmail or your email provider of choice.

Copy
Trigger: Gmail - New Email Matching Search
Search Query: subject:"Job Description" OR subject:"JD"

This captures incoming job descriptions. You can refine the search query based on how your team labels emails.

Connect your first action to Copy.ai. You'll need a Copy.ai account with API access enabled.

Copy
Action 1: Copy.ai API Call
Method: POST
URL: https://api.copy.ai/api/v1/write
Headers:
  Authorization: Bearer YOUR_COPY_AI_API_KEY
  Content-Type: application/json

Body (JSON):
{
  "prompt": "Convert this job description into a structured recruiter briefing document with these sections: Position Overview, Key Responsibilities (as bullet points), Required Skills, Preferred Qualifications, Compensation Details (if available), Team Structure. Job Description: {{email_body}}",
  "model": "gpt-4",
  "max_tokens": 2000
}

Replace YOUR_COPY_AI_API_KEY with your actual API key from the Copy.ai dashboard. The {{email_body}} placeholder pulls the email content automatically from your trigger.

For the second action, connect Quillbot to refine the Copy.ai output.

Copy
Action 2: Quillbot API Call
Method: POST
URL: https://api.quillbot.com/v2/paraphrase
Headers:
  Authorization: Bearer YOUR_QUILLBOT_API_KEY
  Content-Type: application/json

Body (JSON):
{
  "text": "{{step_1_response}}",
  "tone": "professional",
  "fluency": "advanced",
  "intensity": 3
}

Here, {{step_1_response}} refers to the output from the Copy.ai step. Quillbot's tone setting "professional" keeps language suitable for recruitment contexts. The fluency level "advanced" ensures the output reads polished without sounding robotic.

Add Resoomer.ai as your third action to create summary sections.

Copy
Action 3: Resoomer.ai API Call
Method: POST
URL: https://api.resoomer.com/api/summarize
Headers:
  Authorization: Bearer YOUR_RESOOMER_API_KEY
  Content-Type: application/json

Body (JSON):
{
  "text": "{{step_2_response}}",
  "length": 30,
  "mode": "key_points"
}

The length parameter (30) means the summary will be roughly thirty percent of the original briefing. This creates a one-page at-a-glance version for busy recruiters.

Now create the final output document. Use Gmail's Send Email action to deliver the complete briefing.

Copy
Action 4: Gmail - Send Email
To: {{recruiter_email}}
Subject: Recruiter Briefing - {{job_title}} Position
Body:

FULL RECRUITER BRIEFING
{{step_2_response}}

EXECUTIVE SUMMARY
{{step_3_response}}

Original Job Description Submitted: {{email_date}}
Processed Automatically via Alchemy Workflow

The body combines both the polished full briefing (from Quillbot) and the condensed summary (from Resoomer.ai) in a single email. Recruiters see the detailed version first, then a quick reference summary.

Test your Zap with a sample job description. Send yourself an email with "Job Description" in the subject line and watch the workflow execute. Check that each step completes successfully and that API responses appear in Zapier's log.

Alternative:

Using n8n for More Control

If you prefer running this locally or need more customisation, n8n offers a visual node-based editor with stronger automation capabilities.

Create a new workflow in n8n and start with an Email Trigger node.

Copy
Email Trigger Configuration:
- Protocol: IMAP
- Host: imap.gmail.com
- Port: 993
- User: your-email@gmail.com
- Password: your-app-password (not your regular password)
- Mailbox: INBOX
- Only attachments: false

Add an HTTP Request node to call Copy.ai.

Copy
HTTP Request Node 1 (Copy.ai):
Method: POST
URL: https://api.copy.ai/api/v1/write
Authentication: Bearer Token
Token: YOUR_COPY_AI_API_KEY

Headers:
Content-Type: application/json

Body:
{
  "prompt": "Convert this job description into a structured recruiter briefing...",
  "text": "{{ $node.emailTrigger.json.body }}",
  "model": "gpt-4",
  "max_tokens": 2000
}

Chain a second HTTP Request node for Quillbot.

Copy
HTTP Request Node 2 (Quillbot):
Method: POST
URL: https://api.quillbot.com/v2/paraphrase
Authentication: Bearer Token
Token: YOUR_QUILLBOT_API_KEY

Body:
{
  "text": "{{ $node.copy_ai.json.output }}",
  "tone": "professional",
  "fluency": "advanced"
}

Add a third HTTP Request node for Resoomer.ai.

Copy
HTTP Request Node 3 (Resoomer):
Method: POST
URL: https://api.resoomer.com/api/summarize
Authentication: Bearer Token
Token: YOUR_RESOOMER_API_KEY

Body:
{
  "text": "{{ $node.quillbot.json.result }}",
  "length": 30,
  "mode": "key_points"
}

Finally, add an Email node to send the completed document.

Copy
Email Node:
To: recipient@company.com
Subject: Recruiter Briefing - {{ $node.emailTrigger.json.subject }}
Text:
Full Briefing:
{{ $node.quillbot.json.result }}

Summary:
{{ $node.resoomer.json.summary }}

Deploy this workflow and it runs continuously, checking for new emails matching your criteria.

Using Make (formerly Integromat)

In Make, create a new scenario. Add a Gmail module as the trigger.

Copy
Gmail Module (Trigger):
Account: Your Gmail
Watch Emails:
Search Query: "from:jobs@company.com" or subject contains "Job Description"

Add an HTTP module to call Copy.ai.

Copy
HTTP Module 1:
URL: https://api.copy.ai/api/v1/write
Method: POST
Headers:
Authorization: Bearer YOUR_COPY_AI_API_KEY
Content-Type: application/json

Body:
{
  "prompt": "Restructure this job description...",
  "text": "{{ 2.body }}",
  "model": "gpt-4",
  "max_tokens": 2000
}

Reference module outputs using the format {{ 2.body }} where 2 is your module number.

Continue with HTTP modules for Quillbot and Resoomer.ai, then add a Gmail Send module for the final output. Make's visual interface makes it easy to see data flow between steps.

Using Claude Code for Advanced Customisation

If you're comfortable with Python and want to run this entirely in code, Claude Code (via Claude API) can orchestrate all three tools.

Copyimport requests
import json
from datetime import datetime

COPY_AI_KEY = "your_copy_ai_key"
QUILLBOT_KEY = "your_quillbot_key"
RESOOMER_KEY = "your_resoomer_key"

def process_job_description(job_description: str) -> dict:
    """
    Process a job description through the complete Alchemy workflow.
    Returns a dictionary with full briefing and summary.
    """
    
    # Step 1: Copy.ai - Restructure
    print("Step 1: Restructuring with Copy.ai...")
    copy_ai_prompt = """Convert this job description into a structured recruiter briefing document.

Include these sections:
- Position Overview
- Key Responsibilities (bullet points)
- Required Skills
- Preferred Qualifications
- Compensation Details
- Team Structure
- Next Steps for Candidates

Job Description:
""" + job_description
    
    copy_ai_response = requests.post(
        "https://api.copy.ai/api/v1/write",
        headers={"Authorization": f"Bearer {COPY_AI_KEY}", "Content-Type": "application/json"},
        json={"prompt": copy_ai_prompt, "model": "gpt-4", "max_tokens": 2000}
    )
    
    if copy_ai_response.status_code != 200:
        raise Exception(f"Copy.ai error: {copy_ai_response.text}")
    
    restructured = copy_ai_response.json()["output"]
    
    # Step 2: Quillbot - Polish
    print("Step 2: Polishing with Quillbot...")
    quillbot_response = requests.post(
        "https://api.quillbot.com/v2/paraphrase",
        headers={"Authorization": f"Bearer {QUILLBOT_KEY}", "Content-Type": "application/json"},
        json={
            "text": restructured,
            "tone": "professional",
            "fluency": "advanced",
            "intensity": 3
        }
    )
    
    if quillbot_response.status_code != 200:
        raise Exception(f"Quillbot error: {quillbot_response.text}")
    
    polished = quillbot_response.json()["result"]
    
    # Step 3: Resoomer - Summarise
    print("Step 3: Summarising with Resoomer...")
    resoomer_response = requests.post(
        "https://api.resoomer.com/api/summarize",
        headers={"Authorization": f"Bearer {RESOOMER_KEY}", "Content-Type": "application/json"},
        json={
            "text": polished,
            "length": 30,
            "mode": "key_points"
        }
    )
    
    if resoomer_response.status_code != 200:
        raise Exception(f"Resoomer error: {resoomer_response.text}")
    
    summary = resoomer_response.json()["summary"]
    
    return {
        "full_briefing": polished,
        "summary": summary,
        "processed_at": datetime.now().isoformat()
    }

# Example usage
sample_job_description = """
We are seeking a Senior Python Developer...
[rest of job description]
"""

result = process_job_description(sample_job_description)
print("\n=== FULL RECRUITER BRIEFING ===")
print(result["full_briefing"])
print("\n=== EXECUTIVE SUMMARY ===")
print(result["summary"])

This Python script handles all orchestration. You can wrap it in a Flask API endpoint and trigger it via webhooks, making it compatible with your existing recruitment systems.

The Manual Alternative

Some teams prefer keeping parts of this process manual for quality control or customisation. You might use this approach:

1. Copy.ai generates the initial structure, but you manually review and edit before sending to Quillbot.

2. You use Quillbot's web interface instead of the API, giving you immediate feedback on tone and fluency adjustments.

3. You decide which sections need summary treatment, rather than automatically summarising everything.

This hybrid approach takes fifteen minutes instead of five, but offers greater oversight. For smaller recruitment teams or organisations with unusual job structures, this slower pace might suit you better. Start with full automation and dial back to manual steps only where needed.

Pro Tips

Error handling with API rate limits: Copy.ai, Quillbot, and Resoomer.ai all enforce rate limits. In Zapier, add a Delay action between steps (30 seconds minimum) to prevent throttling. In n8n, use the built-in rate limiting feature under node settings. Monitor your API usage monthly to avoid surprise overage charges.

Copy
Zapier Delay Action:
Action: Delay
Delay: 30 seconds (or longer for high volume)

Handling edge cases in job descriptions: Some job descriptions include poorly formatted text, tables, or embedded images. Your orchestration tool might struggle with these. Preprocess the content with a simple text-cleaning step. In Zapier, use a Code by Zapier action before Copy.ai to strip special characters and normalise line breaks.

Copy// Code by Zapier action
const jobDesc = inputData.email_body;
const cleaned = jobDesc
  .replace(/[^\w\s.,!?()-]/g, '') // Remove special characters
  .replace(/\n{3,}/g, '\n\n')      // Normalise line breaks
  .trim();

return { cleaned_text: cleaned };

Customising tone per recruiter level: Different recruitment stakeholders need different tones. Hiring managers want conciseness; recruiters want completeness. Use Quillbot's tone parameter flexibly. For manager-level summaries, set tone to "formal" and intensity to 5. For recruiter briefings, keep tone as "professional" with intensity 3.

Cost optimisation: If your team processes more than fifty job descriptions monthly, consider Copy.ai's higher-tier API plan (usually more cost-effective than pay-per-call). Resoomer.ai offers annual subscriptions that save 30 percent versus monthly billing. Budget accordingly and review actual usage quarterly.

Testing with sample data: Before deploying to your entire team, test with five real job descriptions. Adjust API parameters based on output quality. If summaries are too brief, increase Resoomer's length parameter from 30 to 40. If language feels stiff, tweak Quillbot's fluency setting.

Cost Breakdown

Total estimated monthly cost: £53–£73 for Zapier approach; £20–£50 for n8n self-hosted.

This workflow becomes cost-effective after processing just ten job descriptions, since each one would otherwise require thirty to sixty minutes of manual work.