Jobber Duplicate Client Handling: Stop Creating Messy Records from WordPress Forms

Ever noticed your Jobber client list getting bloated with duplicate entries? “John Smith” appears five times. “Sarah’s Plumbing Repair” shows up three different ways. Your reporting metrics go haywire because revenue gets split across ghost records nobody’s actually managing.

Here’s the frustrating part: it’s not always obvious where duplicates come from. A customer books through your WordPress form on mobile, then fills it out again on desktop. They use their phone number once, email the next time. Your WordPress form doesn’t talk to Jobber’s existing database, so it just keeps creating fresh client records.

That’s where duplicate client handling comes in. And honestly, once you understand how it works, it’s a game-changer for keeping your Jobber database clean.

The Duplicate Client Problem in Action

Let me paint a realistic scenario. You’re running a home service business in Florida. A customer named Mike books through your WordPress contact form for a plumbing job. Jobber creates a client record: Mike with email [email protected].

Three weeks later, Mike calls and wants another job. Your scheduler directs him to the online form. Mike fills it out again—same name, same email. Without duplicate handling, Jobber creates Mike again. Now you’ve got duplicate revenue records, duplicate service history, and your pipeline reporting is unreliable.

Make it worse: Mike uses his phone number the first time but his email the second time. Different data, same person. Your CRM is officially a mess.

This isn’t a Jobber bug—it’s a reality of distributed data collection. WordPress forms live outside Jobber. They don’t have real-time access to your client database. So they can’t automatically prevent what’s been submitted before.

That’s what Jobber Integration Pro solves. It adds intelligence between your WordPress form and Jobber’s API, checking for existing clients before creating new ones.

Understanding the Three Duplicate Handling Modes

Jobber Integration Pro gives you three distinct strategies for handling duplicates. Each one is appropriate for different business scenarios. Here’s the breakdown:

Mode 1: Always Create (No Deduplication)

This is the default. Every form submission creates a new client record in Jobber, regardless of whether similar clients exist.

When to use this:

• You’re just starting out and want raw lead volume without worrying about cleanup
• You have a high-volume, low-repeat business (event rentals, one-time services)
• You’re running A/B tests or promotions and intentionally collecting multiple submissions per customer
• Your team manually reconciles duplicates weekly as part of CRM maintenance

Pros:

• Captures every lead attempt—you won’t miss anyone
• Zero performance overhead
• Simple to understand and troubleshoot

Cons:

• Database bloat over time
• Skewed reporting metrics
• Time wasted merging duplicates later
• Revenue appears fragmented across ghost records

Mode 2: Skip If Email Matches

This is the sweet spot for most service businesses. Before creating a client, Jobber checks if a client already exists with the same email address. If it finds one, it skips creating a new record and updates the existing client instead.

When to use this:

• You’re a contractor, plumber, electrician, or home service pro with repeat customers
• Email is your reliable customer identifier (most people remember email better than phone)
• You want automatic deduplication without too much strictness
• Your customers use consistent email addresses across touchpoints

How it works:

Form submission arrives with:
- firstName: "Sarah"
- lastName: "Martinez"
- email: "[email protected]"
- phone: "(555) 123-4567"

Jobber searches its database:
→ Is there a client with email "[email protected]"?
→ YES, found one (created 3 months ago)
→ Update that existing client instead of creating new one

Pros:

• Automatically consolidates repeat customers
• Improves reporting accuracy
• Reduces manual cleanup burden
• Most WordPress form fills include email

Cons:

• What if a customer changes email address? New record gets created
• Multiple people from same company using shared email might merge incorrectly
• Phone-only submissions bypass deduplication

Mode 3: Skip If Email and Phone Match

This is the strictest option. Jobber only reuses an existing client if both email and phone number match an existing record.

When to use this:

• You serve high-value, high-touch customers (home renovations, commercial contracts)
• You want maximum confidence that you’re updating the correct person
• Your industry tracks phone as a primary identifier (construction crews, field services)
• You need to prevent accidental merges of similarly-named clients
• You have team members with shared business email addresses

How it works:

Form submission arrives with:
- firstName: "David"
- lastName: "Chen"
- email: "[email protected]"
- phone: "(555) 987-6543"

Jobber searches its database:
→ Is there a client with email "[email protected]" AND phone "(555) 987-6543"?
→ YES, found one
→ Update that existing client

Alternative scenario:
→ Email "[email protected]" exists, but phone doesn't match
→ Create a NEW client record (safe approach)

Pros:

• Highest accuracy for matching the right customer
• Prevents accidental merges across similar names
• Works well when you collect both fields consistently
• Best for high-value transactions

Cons:

• More new records get created (not a pure dedup)
• Customers who change phone number appear as new clients
• Requires both email and phone for matching to work
• More conservative approach means more manual cleanup

Configuring Duplicate Handling in Integration Pro

Let’s walk through the actual setup. This is where the power lives.

Log into your WordPress admin dashboard and navigate to Jobber Integration Pro settings. You’ll see a section called Duplicate Client Handling.

Settings → Jobber Integration Pro → Advanced Settings

Here’s what you see:

Duplicate Client Handling Mode
○ Always create new clients
● Skip if email matches (RECOMMENDED)
○ Skip if email and phone match

[Save Settings]

The default is “Skip if email matches.” That’s the recommendation for most home service businesses because:

1. Most customers provide email reliably
2. Email changes less frequently than phone numbers
3. It dramatically reduces duplicate noise without being paranoid
4. It’s the fastest option (Jobber only searches one field)

To change modes:

1. Click the radio button for your desired mode
2. Scroll down and click [Save Settings]
3. The setting applies to all future form submissions immediately (no code restart needed)
4. Existing clients in your database remain unchanged

Important note: This setting is global across your entire WordPress site. If you’re running multiple Jobber booking forms with different clients, they all share this deduplication rule. If you need different dedup modes per form, that requires custom development (we can discuss that separately).

How the REST API Handles Duplicates Under the Hood

Here’s where it gets interesting. Understanding the mechanics helps you troubleshoot when things don’t work as expected.

When you submit a form using the Jobber Integration Pro shortcode, the plugin makes a REST API call to Jobber. Here’s the exact request:

// POST /jobber/v1/book - Booking form submission
{
  "firstName": "Sarah",
  "lastName": "Martinez",
  "email": "[email protected]",
  "phone": "(555) 123-4567",
  "company": "Martinez Properties",
  "address": "123 Oak Street, Orlando, FL 32801",
  "service": "Plumbing Inspection",
  "notes": "Needs pressure test on main line"
}

Jobber’s API receives this payload. Here’s what happens next (this is the critical part):

Step 1: Client Search

Jobber queries its database:
SELECT * FROM clients WHERE email = "[email protected]"
(assuming "skip if email matches" mode is active)

Step 2: Client Exists?

If YES → Update Existing:

// Found matching client
UPDATE clients SET
  firstName = "Sarah",
  lastName = "Martinez",
  phone = "(555) 123-4567",
  company = "Martinez Properties",
  address = "123 Oak Street, Orlando, FL 32801"
WHERE email = "[email protected]"

The API returns the existing client_id in the response:

{
  "success": true,
  "jobber_id": "c_9a7f4e2b1d",
  "client_name": "Sarah Martinez",
  "action": "updated",
  "message": "Existing client updated with new form data"
}

Notice "action": "updated". Your JavaScript can detect this:

document.addEventListener("jobber:success", (event) => {
  if (event.detail.action === "updated") {
    console.log("Client was already in database, details refreshed");
  } else if (event.detail.action === "created") {
    console.log("Brand new client added to Jobber");
  }
});

If NO → Create New:

// No match found
INSERT INTO clients (
  firstName, lastName, email, phone, company, address
) VALUES (
  "Sarah", "Martinez", "[email protected]",
  "(555) 123-4567", "Martinez Properties",
  "123 Oak Street, Orlando, FL 32801"
)

The API returns a new client ID:

{
  "success": true,
  "jobber_id": "c_newid12345",
  "client_name": "Sarah Martinez",
  "action": "created",
  "message": "New client created successfully"
}

The Quote API works the same way:

// POST /jobber/v1/quote - Quote form submission
{
  "first_name": "David",
  "last_name": "Thompson",
  "email": "[email protected]",
  "phone": "(555) 456-7890",
  "title": "Kitchen Remodel - Estimate Request",
  "message": "Looking for budget estimate on full kitchen overhaul",
  "line_items": [
    {"description": "Cabinets", "quantity": 1, "cost": 0},
    {"description": "Countertops", "quantity": 1, "cost": 0}
  ]
}

Same deduplication logic applies. Email (or email+phone) gets searched, client gets updated or created.

API Health Note: Every request consumes API points. Jobber gives you 10,000 points per day, with 500 points restoring per second. A typical form submission costs about 50-100 points depending on payload size and the number of fields updated. You can monitor your usage in the API Health Dashboard within Integration Pro settings.

Testing Duplicate Handling: Real Submissions

Theory is fine. Let’s test this in the real world.

Setup for Testing

First, create a test Jobber account or use a sandbox space if available. Then set your WordPress form to use your Jobber credentials:

[jobber_booking_form
  type="request"
  title="Test Duplicate Detection"
  show_service="yes"
  show_address="yes"
]

Test 1: Email Deduplication (Skip If Email Matches)

1. Set your duplicate handling mode to “Skip if email matches”
2. First submission:

• Fill the form with name “Tom Wilson” and email “[email protected]”
• Submit the form
• Check Jobber: New client “Tom Wilson” created with client_id: c_abc123

3. Second submission (same email, different phone):

• Fill the form with name “Tom Wilson” and email “[email protected]”
• Use a different phone number: “(555) 555-5555”
• Submit the form
• Check Jobber: Same client record (c_abc123) gets updated with the new phone

4. Verify in browser console:

// After first submit

   jobber:success event shows:

   → action: "created", jobber_id: "c_abc123"</p>
<p>// After second submit

   jobber:success event shows:

   → action: "updated", jobber_id: "c_abc123"

Result: You now have ONE client in Jobber with two phone numbers recorded. This is working as intended.

Test 2: Strict Deduplication (Skip If Email AND Phone Match)

1. Change your duplicate handling mode to “Skip if email and phone match”
2. First submission:

• Name: “Lisa Chen”, Email: “[email protected]”, Phone: “(555) 777-7777”
• Submit
• Jobber creates new client c_xyz789

3. Second submission (same email, different phone):

• Name: “Lisa Chen”, Email: “[email protected]”, Phone: “(555) 888-8888”
• Submit
• Jobber: NEW client created (c_different) because phone doesn’t match
• Now you have two “Lisa Chen” records

4. Third submission (email AND phone both match first submission):
   – Name: “Lisa Chen”, Email: “[email protected]”, Phone: “(555) 777-7777”
   – Submit
   – Jobber updates the original client (c_xyz789)

Result: This mode is strict. It only reuses clients when both email and phone match exactly. Useful for high-value scenarios but generates more duplicates if customer info changes slightly.

Test 3: Always Create (No Deduplication)

1. Change mode to “Always create new clients”
2. Submit the same form 3 times with identical data:
   – Every submission creates a brand new client record
   – You’ll have three separate records with the same name, email, phone
   – Each gets a unique client_id

Result: Maximum lead capture, minimum cleanup. Useful for bulk lead campaigns but creates the mess we started this article trying to avoid.

Cleanup Strategies for Existing Duplicates

So you’ve been running WordPress forms for six months without duplicate handling active. Your Jobber database is now a duplicate paradise. How do you fix it?

Strategy 1: Manual Merge in Jobber (Small Scale)

If you have < 20 duplicates, do it manually:

1. In Jobber, go to Clients → Search for your duplicate names
2. Click the duplicate record
3. In the client record, look for a Merge option (appears if duplicates exist)
4. Select the “primary” record to keep
5. Jobber merges all job history, payments, and notes into the primary
6. The duplicate disappears

Time cost: ~5-10 minutes per duplicate. Good for small cleanup bursts.

Strategy 2: Bulk Merge via CSV Export

For larger cleanups (50+ duplicates):

1. Export your Jobber client list to CSV (Settings → Export Data)
2. Open in Excel or Google Sheets
3. Sort by name, then manually identify obvious duplicates
4. Use Jobber’s API or bulk tools to batch-merge duplicates
5. Re-import the cleaned list

This requires some spreadsheet skills but works for major cleanups.

Strategy 3: Contact Jobber Support

If your database is severely compromised (hundreds of duplicates):

Contact Jobber support directly. They have backend tools to identify and merge duplicates en masse. This isn’t automatic, but they can usually run a cleanup in 1-2 business days.

Best Practices for Multi-Form WordPress Sites

If you’re running multiple booking and quote forms across different pages, here’s how to manage duplicate handling effectively:

Practice 1: Consistent Dedup Strategy

Use the same duplicate handling mode across all forms. When you change the setting in Integration Pro, it applies globally:

If Form A uses email dedup...
Form B also uses email dedup...
Form C also uses email dedup...
→ Consistent behavior across your entire site

This prevents confused data where different forms use different rules.

Practice 2: Require Email on All Forms

Make email a required field on every form. This ensures deduplication can actually work:

[jobber_booking_form] show_email="yes" email_required="true"
[/jobber_booking_form]

If customers can submit without email, email-based dedup fails. Phone-only submissions bypass your dedup entirely.

Practice 3: Add Email Validation

Use a plugin like WPForms Lite (free) or integrate built-in HTML5 validation to catch bad emails:

<input type="email" name="email" required />

Bad email data (johnatexample instead of john@example) breaks deduplication because Jobber can’t find matches.

Practice 4: Test After System Changes

Whenever you update your form or change dedup settings:

1. Submit a test form with a known email
2. Verify the correct behavior in Jobber
3. Monitor the next 10 real submissions for anomalies

This catches configuration issues before they create a thousand duplicate ghost records.

Practice 5: Monitor API Health

Check your API Health Dashboard weekly:

Settings → Jobber Integration Pro → API Health

Watch for:

• Rate limit approaching (might indicate form spam)
• Failed requests (API errors that prevent submissions)
• Duplicate submission patterns (bot attacks creating fake duplicates)

If you see rapid-fire submissions from the same email in seconds, that’s likely bot activity or form reload loops.

Impact on Reporting and Revenue Tracking

Here’s the business consequence of duplicate mismanagement. Your CFO comes to you asking, “Why does revenue tracking show $47,000 in jobs, but our actual deposits were only $43,000?”

The answer is often duplicates.

When you have the same customer split across two client records:

• Revenue appears twice in reports (client A: $5,000, client B: $5,000 = $10,000 reported)
• Job count inflates (same job history split across records)
• Customer lifetime value becomes unreliable (is John a $10k customer or a $5k customer?)
• Pipeline forecasting breaks (you’re counting the same opportunity twice)
• Attribution gets confusing (which marketing channel acquired this customer—and did they actually convert, or is it a duplicate from another channel?)

With proper duplicate handling:

• One client record = one accurate revenue history
• Reporting metrics reflect reality
• Your pipeline forecast aligns with actual conversions
• Marketing attribution is trustworthy
• Financial projections are grounded in actual customer data

This isn’t just database hygiene—it’s business intelligence.

Combining Duplicate Handling with Email Validation

For maximum accuracy, combine Jobber Integration Pro’s duplicate handling with a dedicated email validation plugin.

Here’s the recommended stack:

1. WPForms Lite (free) or Gravity Forms (paid, more powerful)

• Provides client-side email format validation
• Prevents obviously bad emails from reaching Jobber

2. Jobber Integration Pro with email-based duplicate handling

• Catches repeat customers at the API level
• Consolidates submissions with valid, matching emails

3. Mailgun verification (optional, advanced)
   – Validates that email addresses actually exist
   – Requires API key, adds ~100ms to form submission
   – Prevents fake emails from cluttering your database

Setup example with WPForms:

[contact-form-7 id="12345"]
→ Email field set to type="email"
→ Required: Yes
→ Connected to Jobber Integration Pro shortcode
→ Jobber dedup mode: "Skip if email matches"

The flow:

Customer fills form
↓
WPForms validates email format ([email protected] OK, johnatexample rejected)
↓
Form submits to WordPress
↓
Jobber Integration Pro checks for existing client with this email
↓
Client created or updated based on dedup mode

This is the most reliable path to clean data.

Common Pitfalls and How to Avoid Them

Pitfall 1: Email Required, But Not Always Collected

You set dedup to “skip if email matches,” but some customers submit forms without email. Those submissions create new clients, bypassing dedup.

Fix: Make email required on your form. Most modern contact form plugins support this.

Pitfall 2: Jobber OAuth Token Expired

Integration Pro uses OAuth to connect to Jobber. If your token expires, form submissions fail silently.

Fix: Check the API Health Dashboard monthly. If you see failed requests, refresh your OAuth credentials in Settings.

Pitfall 3: Phone Number Formatting Issues

You’re using “Skip if email AND phone match” mode, but phone numbers are stored inconsistently:

• First submission: “(555) 123-4567”
• Second submission: “5551234567”
• No match, duplicate created

Fix: Use a phone formatting plugin like Intl-Tel-Input to standardize formatting before submission.

Pitfall 4: Testing Without Flushing Test Data

You test dedup by submitting forms with test email addresses, but never clean them up. Now your Jobber database has 50 “[email protected]” records.

Fix: Create a separate test Jobber space for testing. Keep your production space clean.

Pitfall 5: Changing Dedup Mode Mid-Stream

You run with “Always create” for 3 months, then switch to “Skip if email matches.” Your database still has old duplicates, and new submissions using email dedup won’t catch the old ones.

Fix: When changing dedup strategy, manually merge existing duplicates first. Then switch the mode.

Summary and Next Steps

You now understand duplicate client handling at a practical and technical level:

• The three modes: Always Create, Skip if Email, Skip if Email+Phone
• When to use each: Based on your business model and customer patterns
• How the API works: The actual search-and-match logic
• Testing and verification: How to confirm dedup is actually working
• Cleanup strategies: Fixing messy databases
• Best practices: Multi-form sites, required fields, email validation
• Business impact: Accurate reporting and revenue tracking
• Common pitfalls: What goes wrong and how to prevent it

Your action items:

1. Evaluate your current situation: How many duplicate clients do you have right now?
2. Choose a dedup mode: Select the one matching your business (most should use email-based)
3. Enable it in Integration Pro: Settings → Duplicate Client Handling
4. Clean up existing duplicates: Small sites can do it manually; large sites may need API assistance
5. Test with real submissions: Verify the behavior matches expectations
6. Monitor weekly: Check API Health Dashboard for errors

This single configuration change will transform your Jobber database from a duplicate-prone mess into a reliable source of truth for your business metrics.

If you run into issues, the Automate & Deploy team can help troubleshoot. We’ve seen every duplicate scenario imaginable and know how to untangle them.

---

Related Reading:

• Jobber WordPress Integration: Complete Guide 2026
• Jobber Booking Form WordPress: No iFrame Required
• Jobber WordPress Leads: Home Service Magic

---

Ready to connect Jobber to your WordPress site? Native forms, real-time API, no Zapier needed. Get Jobber Integration Pro – $99/year