ServicePower Claims Status Check Automation: The Deep Dive

Wilmer Toro
January 17, 2026
Read Time: ~12 minutes

Warranty A/R gets painful when you are chasing dozens of claims across different manufacturers and portals.

The problem isn’t “checking one claim.”

The problem is when a manufacturer sends you that dreaded “Concern Regarding Old A/Rs” email with a massive table of invoice numbers. You have to look up what ServicePower says for each claim, log the payment status, and find the reference numbers.

And you need to do all of that without paying someone to sit there and do manual portal lookups all day. This workflow automates exactly that. It parses the A/R email, extracts every line item, pushes them into Google Sheets, and then queries ServicePower for each claim to update the status and payment data automatically.

Here is the deep dive on how to build the ServicePower Claims Status Check automation.

Key Takeaways

Email Parsing: Automatically strips HTML from A/R emails and extracts the “Past Due” table into structured data.
Manufacturer Mapping: Converts email names (like “LGE”) into the specific codes ServicePower expects (like “LG”).
AI Extraction: Uses an AI agent to turn messy email text into clean JSON with PO numbers and amounts.
Direct API Lookup: Calls the ServicePower API for every single claim to get the real-time status.
Financial Enrichment: Updates your Google Sheet with the Payment Method, Reference Number, and Paid Labor amount.

What This Automation Solves

The core issue is the disconnect between the “Past Due” email and your actual payment data.

You receive a table of numbers, but you don’t know why they are past due. Did they reject it? Did they pay it under a different reference?

This automation bridges that gap.

It takes the raw email and turns it into a living dashboard. Instead of checking claims one by one, you only check the exceptions.

High-Level Architecture

This workflow has two entry points and two distinct “stages”.

Entry Points:

Gmail Trigger: Runs automatically when the A/R email arrives.
Manual Trigger: Lets you run it on demand (perfect for testing).

The Stages:

Stage A: Parse the email and write line items to Google Sheets.
Stage B: Call ServicePower for each invoice and update the row with payment info.

Stage A: Email → Clean Line Items → Google Sheets

1. Gmail Trigger (Catches the A/R Email)

We configure the Gmail Trigger to watch for emails with the specific subject line:

“Concern Regarding Old A/Rs”.

This is the “incoming signal” that tells the bot your report is ready to process.

2. "Extract Email" Code Node: Cleans the HTML and Finds the Table

This is a heavy-lift node, and honestly, it is the secret sauce of this entire workflow.

It performs several critical cleanup tasks:

Strips HTML: It removes tags and normalizes whitespace so we are working with clean text.
Extracts Metadata: It pulls the sender, subject, and message ID.
Detects Manufacturer: It looks for the text between “Claims Department” and “Dear Sir” to figure out who sent it.
Grabs Summary Stats: It captures the total value and days past due from the email body.

Most importantly, it isolates the table. It finds the header line containing “YOUR P.O.” and “OUR INVOICE” and keeps everything after that section. This gives the AI a clean block of text to read.

3. Manufacturer Mapping (Critical for ServicePower Lookup)

Inside that same code node, we have a mapping table. This is critical for the ServicePower lookup later.

The email might say “LGE,” but ServicePower expects “LG”. The email might say “Bosch,” but ServicePower expects “BSH”.

We map these variations explicitly:

LGE → manufacturerName: “LG”
GE → manufacturerName: “GE_APPLIANCES”
Electrolux → manufacturerName: “ELECTROLUX”.

We use SquareTrade and Assurant mappings as well.

This makes the workflow multi-manufacturer compliant instead of hardcoded to just one brand.

4. AI Agent: Extract Line Items

We use an AI Agent (powered by GPT-4o-mini or similar) to parse the table data.

We instruct it to produce strict JSON containing:

po_number
invoice_number
billed_date
amount
balance_due

We also force it to strip dollar signs and commas so the numbers are clean for the database.

Model used: gpt-4.1-mini with low temperature (0.1) for consistency.

5. Code Node: JSON to Rows

The AI gives us one big JSON object. This node breaks it down. It loops through each line item and emits one n8n “item” per row. It also handles null values, normalizing empty PO numbers so Google Sheets doesn’t break.

In other words:

removes “`json fences if present
parses the JSON
loops each line_item and emits one n8n item per row
normalizes empty PO numbers to “” so Sheets won’t break on null
SP Claims AR Payments Bot

6. Google Sheets: Append or Update

Finally, we write this clean list into your “AR Claim Payments Bot” sheet. We map the columns (OUR INVOICE, AMOUNT, BALANCE DUE) and set the Matching Column to OUR INVOICE. This ensures that if the same invoice appears in next week’s email, it updates the existing row rather than creating a duplicate. Mapped columns:

OUR INVOICE
YOUR P.O.
BILLED DATE
AMOUNT
PdToDt
BALANCE DUE

Stage B: ServicePower Lookup & Enrichment → Enrich the same sheet

At the end of Stage A, you have a clean list. Now we need to get the money data.

7. HTTP Request to ServicePower "retrieval"

For each row in the sheet, the workflow makes a call to the ServicePower API endpoint: https://claimworks.servicepower.com:8443/services/claim/v1/retrieval. The request body includes the mapped data we prepared earlier:

manufacturerName (from our map)
serviceCenterNumber
claimNumber (which matches “OUR INVOICE”)
authentication object
- SP Claims AR Payments Bot

Security Note: For the template version, you should use n8n credentials, encrypted variables in n8n and environment variables for the ServicePower username/password. Never paste raw passwords directly into the node logic.

8. Google Sheets: Update Row

When ServicePower responds, we write the new data back to the same row in Google Sheets.

We enrich the row with:

SP STATUS: The claim status description (e.g., “Paid”, “Rejected”).
PAYMENT METHOD: How they paid you.
PAYMENT REFERENCE: The check or transaction number.
PAID LABOR: The exact amount approved for labor.

This is the “money part”: now your A/R sheet isn’t just a list of what you billed; it is a list of what actually happened.

What Makes This Workflow "Operator-Grade"

We didn’t build this to be a toy. It is built for scale.

Driven by Reality: It triggers off the actual artifact you receive (the email), so you don’t have to change your behavior.
Normalizes Data: The manufacturer map is a massive scaling lever, allowing one bot to handle GE, LG, and Bosch simultaneously. That manufacturerMap is a scaling lever.
Single Source of Truth: It creates one master sheet that is continuously enriched, rather than scattered notes.
Drastic Time Savings: It reduces follow-up time by handling the rote lookups for you. Instead of checking claims one by one, you check exceptions.

How to Configure It

If you are downloading this template to plug into your own business, here is the checklist:

Gmail Trigger: Change the credential to your email account and update the search query if your subject lines look different. Yours is subject: Concern Regarding Old A/Rs.
Manufacturer Map: Update the manufacturerMap in the “Extract Email” node. Ensure the “Claims Department” text matches exactly what is in your emails.
OpenAI Credential: Connect your own API key so the AI Agent can parse the tables.
Google Sheet: Swap in your Spreadsheet ID and make sure your tab name matches.
ServicePower Credentials: Replace the placeholders with your secure ServicePower API credentials.

Frequently Asked Questions

Does this work for all manufacturers? It works for any manufacturer that uses ServicePower for claims and sends email reports. You just need to add them to the “Manufacturer Map” in the code node so the bot knows how to translate their name.

Is my ServicePower password safe? Yes, provided you follow best practices. We recommend using n8n’s built-in credential manager or environment variables rather than hardcoding passwords into the workflow itself.

What if the email format changes? Since we use an AI Agent to parse the table, the workflow is surprisingly resilient. As long as the email contains a list of invoices and amounts, the AI can usually figure it out without needing a code rewrite.

Conclusion

Warranty A/R is often the “leaky bucket” of a service business. Money gets stuck in “Pending” status simply because nobody has the time to check on it. By implementing this ServicePower Claims Status Check automation, you patch that leak.

You move from “I hope they pay us” to “I know exactly when they paid us.” We can help you deploy this workflow, map your specific manufacturers, and get your A/R under control.

Ready to automate your warranty payments? Let’s talk at Super Service Bros.