---
title: "JobScore vs Teamtailor: Architecture, TCO & Migration Guide"
slug: jobscore-vs-teamtailor-architecture-tco-migration-guide
date: 2026-08-28
author: Roopendra Talekar
categories: [JobScore, Teamtailor, ATS]
excerpt: "A technical comparison of JobScore vs Teamtailor covering architecture, pricing, API constraints, data models, and step-by-step migration guidance."
tldr: "JobScore wins on transparent pricing, US compliance, and webhook reliability. Teamtailor wins on employer branding, API accessibility, and candidate-CRM flexibility. Migration requires careful resume extraction, per-job stage mapping, and custom field translation."
canonical: https://clonepartner.com/blog/jobscore-vs-teamtailor-architecture-tco-migration-guide
---

# JobScore vs Teamtailor: Architecture, TCO & Migration Guide


# JobScore vs Teamtailor: Architecture, TCO & Migration Guide

> **Disclosure:** This guide was written by ClonePartner, an ATS migration vendor. We have a direct financial interest in this topic. All pricing, API behavior, and feature claims should be verified directly with JobScore and Teamtailor before making a procurement or migration decision. Where possible, we cite primary documentation. **Last verified: June 2025 against JobScore Hire API v2 documentation and Teamtailor API with X-Api-Version header.**

---

**JobScore** is a US-centric ATS that prices by open jobs and is built around rigid, requisition-based workflows with deep compliance enforcement. **Teamtailor** is a Stockholm-born recruitment marketing platform that treats the career site and employer brand as first-class product surfaces, with a candidate-CRM data model underneath.

If you're choosing between them — or migrating from one to the other — the decision comes down to your pricing model tolerance, API access tier, employer branding ambitions, and the operational cost of moving structured and unstructured data between two [architecturally incompatible systems](https://clonepartner.com/blog/blog/ektron-vs-coremedia-architecture-tco-migration-guide).

This guide covers data models, API constraints with exact rate limits, total cost of ownership with contract-risk factors, GDPR/data residency considerations, and the practical realities of moving data between these two systems.

---

## Platform Positioning

JobScore is a cloud-based ATS founded in 2004 — one of the oldest independently operating platforms in the market. It targets companies with 2–2,000 employees and is heavily US-weighted: approximately 74.84% of its customer base is US-based, with concentrations in Internet, IT services, computer software, staffing, and events. Core capabilities include one-click posting to 50+ job boards, resume parsing and scoring, LinkedIn Recruiter System Connect (two-way sync between JobScore candidates and LinkedIn Recruiter profiles), built-in EEO/OFCCP compliance reporting, and email/calendar sync.

Teamtailor is a bootstrapped recruiting platform founded in Stockholm in 2013. It has reached $41.8M in annual revenue without venture capital. Its target market is primarily 50–400 employee companies; the largest customer cohort by headcount is 100–249 employees (6,133 companies), followed by 20–49 employees (4,602 companies). Core capabilities include an AI Co-pilot, workflow automation, structured interviews, analytics, onboarding, 400+ marketplace integrations, DEI features (anonymous hiring, EEO surveys), a drag-and-drop career site editor, and a candidate CRM with nurture campaigns.

**What each vendor's customer stories reveal about positioning:**
- Teamtailor highlights: Colonies cutting hiring time from 45 to 28 days; Liseberg running high-volume hiring with a branded candidate experience
- JobScore highlights: Edmunds saving 2,000+ hours per year; Avispa cutting talent acquisition costs by 40%

This is not proof of performance — it is evidence of what each vendor believes it wins on in competitive evaluations.

---

## Architecture and Data Models

The most consequential difference between these platforms is not a feature list — it is the entity that sits at the center of the database schema.

### JobScore: Requisition-First

JobScore uses a hierarchical data model where the **Job Requisition** is the primary organizing entity. Candidates are bound to specific job applications. Every action, note, status change, and disposition code is linked to an approved requisition record. This structure is not incidental — it is the mechanism that makes OFCCP compliance enforcement enforceable as a system property rather than a process convention.

**OFCCP compliance mechanics:** JobScore maintains per-requisition audit trails that include EEO self-identification data (race, gender, veteran status, disability), disposition codes for every candidate, and timestamped status changes. These are the artifacts required under 41 CFR Part 60 for federal contractors. The audit trail is inextricable from the requisition record by design — you cannot retroactively reassign it.

**Operational consequences:**
- Moving a candidate between roles requires duplicating the application record — there is no native "transfer" function
- Candidate pooling is rigid; a candidate not tied to a requisition has limited system presence
- Workflow stages are customizable per job (not global) — a significant implication for migration, since any stage map must be built job by job, not as a single global mapping

**Trade-offs:** Enforces structured process; prevents informal hiring; excellent for audit trails. Users consistently report a non-intuitive, dated UI that creates friction for non-technical hiring managers.

**API surface split:** JobScore separates its public and private API surfaces. The **Hire API** handles back-office data and integrations. The **Job Feed API** (JSON, JSONP, XML, deprecated ATOM) handles career site integration — only published jobs appear, and polling more frequently than once per hour may result in feed access being disabled. These are distinct systems with separate access requirements. ([developer.jobscore.com](https://developer.jobscore.com/))

### Teamtailor: Candidate-First

Teamtailor treats the **Candidate Profile** as the primary entity, functioning like a B2B CRM. A candidate can exist in the system without being tied to any specific job — sitting in a "Connect" pool or talent community. Jobs and campaigns are nodes attached to the candidate profile, not the inverse.

**Smart Move** is Teamtailor's rule-based candidate routing engine. It fires automatically when a candidate enters a stage and can route candidates to different pipeline stages, reject them, move them to talent pools, or trigger external actions based on configurable conditions: screening question answers, resume text content, tags, location, referral status, or current job-offer status. Smart Move is attached to stages within specific jobs or job templates — not to a global workflow — which means migrated stage names that appear correctly mapped can still produce incorrect automation behavior if the trigger logic is not rebuilt explicitly.

**Triggers** are a related but distinct concept: individual automated actions (send email, add tag, move to stage, notify recruiter) that fire on stage entry or exit. Smart Move is the routing decision layer; triggers are the action execution layer.

**Operational consequences:**
- Fluid talent pooling; easy to remarket to past applicants; natively supports passive candidate nurturing
- Less rigid enforcement of step-by-step compliance — requires deliberate configuration for structured interview adherence
- Career site builder is architecturally central: it was one of the original core features the platform was built around, not an afterthought added post-launch

**Headless career site option:** Teamtailor offers a fully headless career site configuration — host your frontend on Vercel or Netlify, use Teamtailor as the backend. **Critical caveat:** if you use the API for your career site, collecting and managing candidate GDPR consent/permissions is not handled by Teamtailor. You own that compliance layer entirely. ([support.teamtailor.com](https://support.teamtailor.com/en/articles/118549-integrate-teamtailor-on-your-website))

### Architectural Summary

| Dimension | JobScore | Teamtailor |
|-----------|----------|------------|
| Central entity | Job Requisition | Candidate Profile |
| Compliance model | Structural (per-requisition audit trail) | Configurable (requires process discipline) |
| Stage configuration | Per-job (not global) | Per-job + job templates |
| Talent pooling | Rigid (application-bound) | Native (CRM-style, job-optional) |
| Career site | Iframe/widget, separate Job Feed API | Core product surface, headless option |
| Automation engine | Basic triggers | Smart Move (routing) + Triggers (actions) |

---

## API Capabilities

The API determines how well a platform integrates into existing HRIS, identity management, and analytics stacks. For migrations, it determines whether automation is possible at all.

### JobScore Hire API

The JobScore Hire API v2 is a REST API at `https://api.jobscore.com/v2`.

**⚠️ Access is restricted to Enterprise customers and select partners.** If you are not on an Enterprise plan, the Hire API is unavailable — the Job Feed API is your only programmatic option.

- **Auth:** Personal Access Token via HTTP header
- **Format:** JSON responses, UTF-8 strings, ISO 8601 timestamps (non-UTC inputs are rejected by the API)
- **Rate limits:**
  - GET: 3,600 requests/hour
  - POST/PATCH/DELETE: 400 requests/hour
  - Burst limit: 20 write requests/minute (enforced separately from the hourly cap)
- **Pagination:** Max 100 records per page, offset-based
- **Webhooks:** Six event types — `candidate_applied`, `candidate_hired`, `job_added`, `job_status_changed`, `task_added`, `candidate_stage_changed`. Signed with HMAC. Retry policy: up to 5 retries with exponential backoff over approximately 10 hours. Webhooks are disabled after prolonged failure or a 410 HTTP response from the destination.
- **Endpoints:** Candidates, applications, jobs, notes, documents, offers, tasks, tags, departments, locations, users, EEO data
- **Duplicate handling:** No uniqueness validation at write time. Duplicates are flagged asynchronously for manual merge — the API will not block duplicate creation. Migration scripts must handle deduplication on the source side before ingestion.
- **Custom job fields:** Not self-service in the Hire API. Custom job field changes require coordination with JobScore support.

**Security and identity:** SOC 2 Type II certified, hosted on AWS. SSO via Google, Microsoft, OpenID, and SAML. HRIS integrations: ADP Workforce Now, BambooHR, Namely, Paylocity, Paycom, Paychex, Rippling, UKG. ([jobscore.com](https://www.jobscore.com/))

> [!NOTE]
> The Hire API and the Job Feed API are separate systems. The Job Feed API (JSON, JSONP, XML) is available on paid plans for career site integration. The Hire API — required for programmatic migration or deep integration — is Enterprise-only and not accessible via plan upgrade alone; it requires a consultative sales conversation.

### Teamtailor API

The Teamtailor API follows the **JSON:API specification** (`application/vnd.api+json`), which differs structurally from a standard REST JSON API. JSON:API allows developers to fetch related resources in a single request using the `include` query parameter, reducing round-trips on reads. However, writes are more granular — each related object (custom field value, answer, comment) requires a separate POST request.

- **Auth:** API keys generated in Settings → Integrations → API keys. Keys cannot be edited after creation — they must be deleted and recreated to change permissions.
- **Key types:**
  - **Public:** Career site data only (published jobs, public content)
  - **Internal:** Includes unlisted jobs and internal data
  - **Admin:** Full account access (required for migration and HRIS integration)
- **Region-aware base URLs:** Separate endpoints for Europe, North America, and Asia-Pacific. This is directly relevant for GDPR data residency — data processed via the EU endpoint stays within EU infrastructure.
- **Versioning:** `X-Api-Version` header required on every request
- **Rate limits:** 50 write requests per 10 seconds (approximately 1,800/hour — higher than JobScore's 400/hour, which partially offsets the chatty write pattern)
- **Access tier:** Available to all customers (Admin-level account access required to generate Admin keys)
- **Webhooks:** Company and Partner webhooks support HTTPS delivery and signature verification. **As of June 2025, failed deliveries are not retried.** This is documented behavior but subject to change; verify current behavior in Teamtailor's changelog before building reliability-critical integrations.

```json
// Teamtailor JSON:API: fetching candidate with related applications and answers
GET /v1/candidates?include=applications,answers
{
  "data": [
    {
      "type": "candidates",
      "id": "12345",
      "attributes": { "first-name": "Jane", "last-name": "Doe", "email": "jane@example.com" },
      "relationships": {
        "applications": { "data": [{ "type": "applications", "id": "9876" }] }
      }
    }
  ],
  "included": [
    {
      "type": "applications",
      "id": "9876",
      "attributes": { "status": "active" }
    }
  ]
}
```

**Implementation support:** Teamtailor does not offer API implementation support. If an endpoint is not listed in the documentation, it does not exist. Custom extraction and transformation scripts are the customer's responsibility.

### API Import Patterns: Request Shape Comparison

The number of API calls required to create a complete candidate record differs significantly between platforms:

```text
Teamtailor import pattern (chatty writes):
POST /candidates                    → 1 call
POST /custom-field-values           → 1 call per custom field
POST /answers                       → 1 call per screening answer
POST /comments                      → 1 call per note/comment
Total per candidate: 4–15+ calls depending on field count

JobScore import pattern (flatter initial write):
POST /candidates (with tags, job applications)  → 1 call
POST /documents (resume binary)                 → 1 call per attachment
POST /notes                                     → 1 call per note
Total per candidate: 3–8 calls depending on attachments
```

Teamtailor's higher write rate limit (50/10s vs. JobScore's ~6.7/10s) partially compensates for the additional calls. For a 10,000-candidate migration, Teamtailor's chatty pattern means roughly 60,000–150,000 API calls at ingestion; the rate limit allows completion in approximately 3–8 hours of write-only throughput, not accounting for read calls or error handling.

### API Comparison Table

| Capability | JobScore | Teamtailor |
|-----------|----------|------------|
| API spec | REST + JSON | JSON:API (`application/vnd.api+json`) |
| Auth method | Personal Access Token (header) | API key (header) |
| Access tier | Enterprise only (Hire API) | All plans (Admin key required) |
| Key types | Single token | Public / Internal / Admin |
| Region-aware endpoints | No | Yes (EU, NA, APAC) |
| Webhooks | 6 event types, HMAC signed, retries ≤5× over ~10h | Company + Partner, signed, **no retries (as of June 2025)** |
| Write rate limit | 400/hr (burst: 20/min) | 50/10s (~1,800/hr) |
| Read rate limit | 3,600/hr | Not separately published |
| Duplicate detection | Async flag, no write-time block | Manual merge, no automatic detection |
| Custom field API | Not self-service | API-only fields supported |
| GDPR data residency | US-hosted (AWS) | Region-aware (EU endpoint = EU infrastructure) |

**The webhook reliability gap is operationally significant.** JobScore's exponential backoff retry policy (up to 5 attempts over ~10 hours) provides a meaningful reliability buffer for downstream integrations — HRIS sync, BI pipelines, revops workflows. Teamtailor's fire-and-forget delivery means any webhook consumer must implement its own reliability layer: idempotent endpoints, a dead-letter queue, or periodic reconciliation polling.

---

## GDPR and Data Residency

This section is critical for European buyers and any US company with EU candidate data.

**Teamtailor (EU-origin):** Region-aware API URLs mean that API calls routed to the EU endpoint process and store data within EU infrastructure. Teamtailor is headquartered in Sweden and subject to GDPR as a data controller for its own operations and as a data processor for customer data. Candidate consent management is built into the native career site product. **However:** if you use Teamtailor's API to build a headless career site or import candidates programmatically, candidate consent collection and management is entirely your responsibility. Teamtailor does not provide consent infrastructure for API-sourced candidates.

**JobScore (US-origin):** Hosted on AWS, SOC 2 Type II certified, US-centric architecture with no documented EU data residency option. For EU candidates, data processed through JobScore flows through US infrastructure. Buyers subject to GDPR must evaluate whether their DPA with JobScore adequately covers EU-to-US data transfers under current SCCs (Standard Contractual Clauses).

**Migration-specific GDPR risk:** During a migration from either platform, candidate data is extracted, transformed, and re-ingested. This constitutes a new processing event. If you are migrating EU candidate data, you need documented legal basis for processing during the migration window, and you must ensure the destination system's DPA is in place before ingestion begins — not after.

---

## Pricing and Total Cost of Ownership

### JobScore Pricing

JobScore prices by concurrently open jobs rather than user seats — an unusual model in the ATS market.

| Plan | Monthly Cost | Open Jobs |
|------|-------------|-----------|
| LITE | $69 | 2 |
| START | $129–$759 | 5–20 |
| SCALE | $399–$1,199 | 10–20 |
| Enterprise | Custom | 25+ |

All plans include unlimited users, candidates, notes, and tags. Month-to-month plans can be changed or canceled without penalties.

**Critical constraints by tier:**
- Integration with tools like Adobe Sign requires the highest-tier plan
- The Hire API (required for programmatic migration or HRIS integration) is **Enterprise-only**
- If you need API access and are not on Enterprise, you must either upgrade or accept CSV-only data workflows

**The per-job model economics:** If your company runs 10 concurrent jobs consistently, the START plan at $759/month ($9,108/year) is your floor. If you regularly spike to 25+ concurrent jobs during growth phases, you'll need Enterprise pricing. The model rewards predictable, low-volume hiring and penalizes aggressive hiring ramps.

### Teamtailor Pricing

Teamtailor uses custom, quote-based pricing that adjusts by company size, hiring volume, and selected features. No pricing is published on the vendor's website.

**Third-party aggregated data (treat as directional, not contractual):**
- Minimum: approximately $2,750/year
- Maximum: approximately $72,000/year
- Average: approximately $17,000/year

*Source: third-party SaaS pricing aggregators, not Teamtailor's own published pricing. Verify directly with Teamtailor.*

**Contract risk factors to negotiate before signing:**
- 12-month minimum contract term (no month-to-month option)
- Annual price escalators reported at 3–8% (community/reviewer-sourced; request contractual cap language)
- SMS credits for candidate texting sold in bundles, not included in base price
- AI Co-pilot and advanced Nurture campaign features gated behind higher tiers
- Implementation fees range from $0 (self-service) to $5,000+ (managed migration)

> [!WARNING]
> **Escalator math:** A $16,500 annual contract at 5% compounding becomes approximately $18,176 by year three. At 8%, it reaches $19,159. Always negotiate a contractual cap or flat renewal rate before signing — and get it in writing, not as a verbal commitment from a sales rep.

### TCO Comparison

| Factor | JobScore | Teamtailor |
|--------|----------|------------|
| Pricing model | Per concurrent open job | Custom quote |
| Entry cost (annual) | ~$828 (LITE) | ~$2,750 |
| Mid-market cost (est.) | $4,788–$14,388/yr | ~$17,000/yr average |
| User seats | Unlimited on all plans | Unlimited |
| Free tier | Yes (limited) | No |
| Contract minimum | Month-to-month available | 12 months |
| Annual escalators | Not published | 3–8% (community-reported) |
| API access cost | Enterprise tier only | Included (Admin key) |
| Onboarding module | Not available | Add-on |
| SSO | All plans (Google, Microsoft, SAML) | Enterprise tier |

**Hidden migration cost:** The cheapest subscription is not always the cheapest migration path. If the target system requires flattening custom objects into comments, rebuilding permissions logic, or implementing a webhook reliability layer from scratch, first-year total cost can swing significantly even when headline license fees appear similar. A $5,000 implementation fee on a $2,750/year contract doubles year-one cost.

### SSO and Identity Management

**JobScore:** SSO via Google, Microsoft, OpenID, and SAML is available across plans. No SCIM provisioning documented in public materials — verify with vendor for automated user lifecycle management.

**Teamtailor:** SSO is documented as an Enterprise-tier feature. SCIM provisioning availability should be verified directly with Teamtailor. For enterprise buyers requiring automated user provisioning and deprovisioning, the tier requirement for SSO is a material cost factor.

---

## Feature Comparison

| Category | JobScore | Teamtailor |
|----------|----------|------------|
| Career site builder | Template-based, iframe/widget embed | Drag-and-drop, headless API option, core product |
| Employer branding | Basic | Core differentiator |
| Job board distribution | 50+ boards, one-click | Multi-posting + SEO optimization |
| AI features | Resume scoring | AI Co-pilot (descriptions, questions, emails) |
| Compliance (EEO/OFCCP) | Structural (per-requisition audit trail, disposition codes, 41 CFR Part 60 artifacts) | Configurable (EEO surveys, anonymous hiring) |
| Onboarding | Not available | Add-on module |
| HRIS integrations | ADP, BambooHR, Gusto, Namely, Paylocity, Paycom, Paychex, Rippling, UKG | 400+ via marketplace |
| LinkedIn integration | Recruiter System Connect (two-way sync) | LinkedIn integration available |
| Reporting | Built-in analytics, one-click list exports to CSV | Custom reports, career-site analytics |
| SSO | All plans (Google, Microsoft, OpenID, SAML) | Enterprise tier |
| Automation | Basic triggers | Smart Move (routing engine) + Triggers (actions) |

**Analytics gap:** Cost-per-hire, source-of-hire attribution, and custom reporting are not natively available on Teamtailor's lower tiers. Enterprise clients report requiring BI connector integrations for anything beyond standard pipeline metrics. JobScore's approach is simpler but more accessible — every list view includes a direct CSV download link.

---

## Migration: Moving Data Between Systems

ATS migrations look straightforward in a vendor demo and become operationally complex in execution. The root cause is that JobScore and Teamtailor have [incompatible data models](https://clonepartner.com/blog/blog/desk365-to-jira-service-management-migration-guide). Before committing to a direction, you need four artifacts: a field map, a stage map (per job, not global), a duplicate policy, and a cutover plan.

### What Migrates Cleanly vs. What Doesn't

Both platforms separate the **Candidate** (the person) from the **Application** (their candidacy for a specific role). A single candidate can have multiple applications. This structural similarity creates a false sense of migration simplicity — the details diverge substantially.

- **JobScore** application status values: `new`, `active`, `declined`, `withdrawn`, `hired`. Workflow stages are customizable per job. Disposition code is a separate field on the application record.
- **Teamtailor** uses visual pipeline stages within jobs, with Smart Move routing rules and Triggers attached to specific stages within specific jobs or job templates.

| Data Type | Migration Difficulty | Notes |
|-----------|---------------------|-------|
| Candidate profiles (name, email, phone) | Low | Direct field mapping |
| Job records (title, description, location, department) | Low | Direct field mapping |
| Applications / pipeline stage | Medium | Stage names must be remapped per job — no global map |
| Resumes and file attachments | High | Binary files require per-candidate API calls; no bulk export |
| Notes and activity history | High | HTML formatting, author attribution, threading differ |
| Interview feedback and structured scores | High | Rating structures are incompatible — data typically flattens to text |
| Custom fields | Medium | Must be mapped source-to-target field by field; check for API-only fields |
| EEO and compliance data | Medium | Requires careful handling; verify legal basis for re-processing |
| Source attribution | Medium | Source taxonomy differs between platforms; many sources map to "other" |
| Smart Move / trigger logic | High | Cannot be migrated; must be rebuilt manually in the target system |

### The Resume Extraction Problem

This is the single most underestimated bottleneck in any ATS migration.

**Extracting from JobScore via Hire API:**

1. List all candidates (paginated, max 100 per page) — 100 pages for 10,000 candidates = 100 GET calls
2. For each candidate, list their documents — 10,000 GET calls
3. For each document, call the download endpoint to retrieve the binary file — up to 15,000 GET calls (assuming 1.5 docs/candidate average)
4. Total: ~25,100 GET calls against a 3,600/hour limit = approximately 7 hours of continuous API usage at maximum throughput
5. Add pagination overhead, error retries, and network latency: realistic estimate is 9–11 hours for 10,000 candidates

**Extracting from Teamtailor via API:**

1. List all candidates with applications included (JSON:API `include` parameter reduces round-trips) — estimated 100–200 calls for 10,000 candidates
2. For each candidate, fetch document download URLs — approximately 10,000 calls
3. Fetch binary files from returned URLs — approximately 15,000 calls
4. Total GET calls: ~25,200 — similar volume to JobScore, but at higher read throughput
5. Realistic estimate: 6–9 hours for 10,000 candidates

**UI export limitations:** Both platforms offer UI-based CSV exports for structured data. Neither includes resume binary files in UI exports. CSV exports give you names, emails, and structured fields — not attachments.

**Teamtailor API resume import requirement:** When importing resumes into Teamtailor via API, the resume file must be hosted on a publicly accessible URL for a minimum of 30 seconds during the import call. Teamtailor fetches it asynchronously. Files hosted behind authentication or on temporary signed URLs that expire before Teamtailor fetches them will fail silently. ([support.teamtailor.com](https://support.teamtailor.com/en/articles/8890189-self-import-via-api))

> [!CAUTION]
> **Silent failure mode:** If your migration script doesn't account for API rate limits during the binary download phase, the source ATS will throttle connections — resulting in candidate profiles created without their attached resumes. These failures are typically not surfaced as errors; they appear as successful candidate records with no documents. The only detection method is a post-migration document count reconciliation.

### JobScore → Teamtailor Migration

This is the more common direction. Teams typically move toward Teamtailor for employer branding, career site control, or EU-facing candidate experience.

**Step 1: Audit your data scope.** Before extracting anything, define what actually needs to migrate:
- Active candidates in open pipelines (required)
- Historical candidates from closed requisitions (evaluate ROI — these are expensive to migrate and rarely accessed)
- Resumes and file attachments (high value, high cost)
- Interview feedback and scorecard data (typically lost fidelity regardless; capture as text comments)
- Smart Move / trigger logic (cannot be migrated; must be rebuilt)

**Step 2: Assess your JobScore API access.** If you're on Enterprise, you can use the Hire API v2 for full programmatic extraction. If you're not on Enterprise, you're limited to UI-based CSV exports and manual resume downloads. This is where most DIY migrations stop.

**Step 3: Extract from JobScore.** For Enterprise accounts:
- Script extraction of: candidates, applications, documents (with binary download), notes, jobs, EEO data
- Handle pagination at max 100 records per page
- Respect the 3,600 GET/hour and 400 write/hour limits
- Implement deduplication logic before extraction (JobScore won't catch it during import)

**Step 4: Transform the data.** Required mapping operations:
- JobScore workflow stages (per-job) → Teamtailor pipeline stages (per-job)
- JobScore `disposition_code` → Teamtailor reject reasons
- JobScore `source` taxonomy → Teamtailor `origin` field values
- Custom field values (1:1 manual mapping)
- JobScore `active`/`declined`/`withdrawn` → Teamtailor application status

**Step 5: Load into Teamtailor.** Use an Admin API key. Account for Teamtailor's chatty write pattern: each custom field value, answer, and comment is a separate POST. Stage resumes on a public server before ingestion.

**Managed import option:** Teamtailor offers a standard CSV import (free, fixed-format, ~2 weeks) and a custom import (quote-based, ~4 weeks). Both are CSV-only and do not migrate binary attachments. ([support.teamtailor.com](https://support.teamtailor.com/en/articles/8304568-import-existing-data-into-teamtailor))

**Step 6: Run a delta sync.** In the window between bulk migration completion and cutover, changes accumulate in JobScore. Run a secondary extraction to capture new applications, status changes, and notes added during the migration window.

**Step 7: Validate.** Compare record counts (candidates, applications, documents), spot-check resume attachments by sampling 50–100 records, verify stage assignments, and confirm custom field values match source data.

**Post-import behavior in Teamtailor:**
- Imported jobs are automatically set to **Archived** status and tagged `import`
- Imported job creation date reflects import completion date, not original source-system date — this distorts time-series reporting if you don't snapshot historical analytics before cutover
- Imported candidates default to **Sourced** status with an `import` tag
- If imported candidates match existing Teamtailor candidates, duplicates are created as separate profiles; manual merge is required
- Smart Move rules and triggers attached to migrated stages must be rebuilt manually

### Teamtailor → JobScore Migration

Less common, but occurs when teams want simpler pricing, US-centric OFCCP compliance, or recruiter-ops-focused workflows without a carrier-grade career site.

**Extraction advantage:** Teamtailor API access is not gated by plan tier. All customers with Admin access can generate Admin API keys and begin extraction immediately.

**Loading challenge:** JobScore's Hire API requires Enterprise plan access. If your target JobScore account is not on Enterprise, you must upgrade before programmatic import is possible — or accept CSV-only import with its limitations.

**JobScore CSV import constraints:**
- Maximum: 10,000 rows per upload
- Minimum required columns: First Name, Last Name, Email
- One job, one tag set, and one source per CSV upload
- Duplicate detection: exact email match or LinkedIn URL match. On match: contact info is updated, overwritten values are preserved in candidate history, tags are added, but candidate source is not updated
- Structured notes, attachments, and stage history cannot be imported via CSV

For full fidelity migration of Teamtailor notes, attachments, and stage history, you need programmatic extraction plus JobScore's Enterprise Hire API for ingestion.

### Edge Cases Teams Miss

1. **Historical analytics distortion:** Teamtailor's managed import resets imported job creation dates to the import completion date. Any time-series reporting (time-to-fill by quarter, source-of-hire trends) will be broken for historical periods. Snapshot all historical analytics in the source system before cutover.

2. **Candidate consent and GDPR:** Teamtailor requires that you configure permissions handling for sourced and imported candidates. For EU candidates, imported records without documented consent create compliance risk. If you used a headless Teamtailor career site, consent was never collected through Teamtailor's infrastructure — you must produce your own consent records.

3. **Custom field asymmetry:** Teamtailor supports API-only custom fields hidden from the UI (useful for system metadata). JobScore custom job fields are not self-service in the Hire API. Asymmetric field availability often forces data to be flattened into note text, losing queryability in the destination system.

4. **Webhook reliability during cutover:** JobScore retries failed webhook deliveries up to 5 times over ~10 hours. Teamtailor company webhooks (as of June 2025) do not retry. If your HRIS or BI pipeline consumes ATS events via webhook, plan for a reconciliation pass after cutover rather than assuming event-driven sync is sufficient.

5. **Attachment limits:** In JobScore, note attachments are limited to 5 MB each, with a maximum of three attachments per note. Attachments exceeding these limits must be re-hosted or summarized before import. ([developer.jobscore.com](https://developer.jobscore.com/))

6. **Stage-to-automation coupling:** In Teamtailor, Smart Move rules and Triggers are attached to specific stages within specific jobs or templates. A stage name that matches the source system does not carry automation logic. Every stage with downstream automation must be explicitly rebuilt in the target system. Failure to do this is how migrations create silent process breakdowns — candidates enter stages and no actions fire.

7. **Job Feed API polling limits:** If you use JobScore's Job Feed API to power an external career site during the migration window, polling more frequently than once per hour may result in feed access being suspended, taking your careers page offline.

---

## When to Pick JobScore

- **US regulatory compliance is a hard requirement:** OFCCP/EEO reporting with per-requisition audit trails and disposition codes is structurally enforced — not bolted on
- **Your hiring volume is low and predictable:** The per-job pricing model rewards steady-state hiring below ~20 concurrent open roles
- **Budget is constrained:** The $69/month LITE entry point and month-to-month flexibility are materially cheaper than Teamtailor's 12-month minimum
- **Webhook reliability matters for downstream integrations:** The exponential backoff retry policy reduces operational risk for HRIS and BI sync pipelines
- **Your team works primarily in the US:** 74.84% US customer base reflects platform-native assumptions about compliance, geography, and workflows
- **Simple, flat data structures:** JobScore is a more forgiving CSV import destination for straightforward candidate datasets

## When to Pick Teamtailor

- **Employer branding is a strategic differentiator:** The career site builder is architecturally central, not an afterthought — and the headless option gives full frontend control
- **You're hiring in Europe or globally:** Region-aware API endpoints, EU data residency, and GDPR-aware candidate consent infrastructure are natively built in; 21% UK and 21% Sweden customer share reflects real EU operational maturity
- **Passive talent pooling is part of your recruiting strategy:** The candidate-CRM model with Smart Move routing and nurture campaigns is built for this; JobScore's requisition-first model is not
- **You need API access without an Enterprise contract:** All Teamtailor customers can generate Admin API keys; JobScore's Hire API requires Enterprise
- **Onboarding workflows are required:** Teamtailor offers this as an add-on; JobScore does not offer it at any tier
- **Modern UX matters for hiring manager adoption:** Teamtailor consistently rates higher for ease of use in third-party reviews; JobScore's UI is frequently cited as dated and non-intuitive

---

## What to Validate Before You Sign

Do not let the vendor demo decide this. Export real records, rebuild one integration, and test failure scenarios before committing.

1. **Export real records, not sample data.** Your test dataset should include: one hired candidate, one rejected candidate with a disposition code, one duplicate, one internal-only job, one record with file attachments, and one record with custom fields populated. These edge cases are where migration fidelity breaks.

2. **Build the stage map job by job, not globally.** JobScore customizes stages per job. Teamtailor attaches Smart Move rules and Triggers to stages. A global stage-name match is insufficient and will produce broken automations in the target system.

3. **Test permissions and consent before importing EU candidate data.** Especially critical if Teamtailor is the target and you'll use sourced candidates or an API-driven headless career site.

4. **Rebuild one live integration end to end, including failure scenarios.** Webhook delivery behavior (retry policy, payload shape, HMAC signature verification) matters more than the vendor's integration logo wall. Test what happens when your endpoint returns a 500 — does the source system retry?

5. **Confirm API tier access on both sides before starting.** JobScore Hire API requires Enterprise. If your source or destination account is not on the right tier, your migration window extends by however long vendor procurement takes.

6. **Plan a delta sync and a rollback state.** The source ATS must remain readable and queryable until you have validated record counts, attachment presence, and stage assignments in the destination. Migration windows are typically measured in weeks; plan accordingly.

7. **Snapshot historical analytics before cutover.** Teamtailor's managed import resets job creation dates. Any time-series reporting on hiring velocity, source performance, or stage conversion will be inaccurate for historical periods unless you export it from the source system before migration.

---

## Getting the Migration Right

Switching your ATS affects every active candidate, hiring manager, and recruiter in flight. As in [most platform migrations](https://clonepartner.com/blog/blog/wix-to-webflow-migration-a-complete-technical-guide), structured data — names, emails, job titles — transfers predictably. The complexity concentrates in four areas: resume extraction behind per-record API calls with rate-limited throughput, activity history that loses fidelity regardless of effort, stage mapping that must be rebuilt job by job rather than globally, and automation logic (Smart Move rules, triggers) that cannot be migrated at all and must be reconstructed.

The total elapsed time for a 10,000-candidate migration — including extraction, transformation, resume staging, load, delta sync, and validation — is typically 3–6 weeks for an experienced team with API access on both sides. For non-Enterprise JobScore accounts limited to CSV exports, the timeline is shorter but fidelity is substantially lower.

At ClonePartner, we handle ATS migrations, including between JobScore and Teamtailor in both directions. Our process includes API rate-limit-aware extraction scripts, per-job stage mapping, resume staging infrastructure, post-load validation with record count reconciliation, and delta sync before cutover.

> Need to migrate between JobScore and Teamtailor? Book a 30-minute call to scope your migration, review your data model, and get a timeline and cost estimate.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)

## Frequently asked questions

### Is JobScore or Teamtailor cheaper for small businesses?

JobScore starts at $69/month (LITE, 2 open jobs) with published pricing and month-to-month contracts. Teamtailor starts around $229/month but requires a custom quote and a 12-month commitment. For small teams with low hiring volume, JobScore is significantly cheaper.

### Can I access the JobScore API on all plans?

No. The JobScore Hire API — the full REST API for candidates, applications, and documents — is restricted to Enterprise customers and select partners. The Job Feed API for careers site integration is available on all paid plans.

### Does Teamtailor have an open API?

Yes. Teamtailor's API follows the JSON:API spec, uses regional base URLs (EU, NA, APAC), and supports Public, Internal, and Admin keys with Read, Write, or Read/Write access. It's available to all customers.

### How long does a JobScore to Teamtailor migration take?

It depends on data volume. Under 1,000 candidates without resume migration takes a few days. For 5,000–10,000+ candidates with resumes and activity history, expect 2–4 weeks including extraction, transformation, loading, and validation.

### What data is hardest to migrate between JobScore and Teamtailor?

Resume and attachment files are the hardest — they require per-candidate API calls and careful binary file handling. Interview feedback, custom field values, and workflow stage mappings also require significant transformation work. Pipeline stages must be remapped per job, not globally.