DEV Community: Emma Watson

Google PageRank Is Dead—Here’s How I’m Checking Domain Trust in 2026

Emma Watson — Fri, 21 Aug 2026 05:17:50 +0000

Google killed the public PageRank API years ago, but you still see outdated metrics in every SEO audit. The problem is that legacy tools show you a number that no longer reflects how Google actually evaluates trust. You are essentially looking at a 2013 snapshot to make 2025 decisions.

The real challenge is separating historical authority from current relevance. A domain can have a high PageRank history but be a spam-riddled shell today. Meanwhile, a fresh site with excellent content and strong backlinks gets ignored because it lacks that old metric.

That is why we built the Google PageRank Checker with a dual-signal approach. You get the legacy PageRank data for historical context, but you also get the SERPSpur Trust Rate, which analyzes current domain trust based on live ranking signals, backlink quality, and content integrity. This gives you a complete picture in seconds.

Instead of guessing whether a domain is worth pursuing for outreach or link building, you can compare both numbers side-by-side. If the legacy PageRank is high but the Trust Rate is low, you know the authority has decayed. If the Trust Rate is high, you have found a hidden gem that legacy tools would have missed.

Stop relying on outdated data. Check the historical metric, but verify it against the current reality. Run your authority analysis with both signals and make decisions based on what is true today, not what was true a decade ago.https://serpspur.com/tool/google-pagerank-checker/

I Built a Python Keyword Scoring System That Finds Low-Competition SEO Opportunities by Country

Emma Watson — Wed, 19 Aug 2026 04:40:21 +0000

When I started building my first real SaaS product, I thought I had the SEO part figured out. I was wrong. My biggest bottleneck wasn't writing content—it was validating whether the keywords I was targeting actually had commercial intent in specific markets.

Here is the thing: Search volume is a vanity metric if you don't understand the competition. A keyword might have 10,000 monthly searches in the US, but if the top 10 results are all authority domains with massive backlink profiles, you're wasting your time. Conversely, a keyword with 500 searches in Germany might have zero ads competition and a keyword difficulty score under 15, which is a goldmine for a new domain.

I recently ran a workflow that completely changed how I prioritize my content calendar. Instead of guessing, I wrote a simple Python script to pull data from the SERPSpur Keyword Research Tool and score opportunities based on a custom formula.

Here is the core logic I used to filter out the noise:

import requests

def analyze_keywords(keywords, country):
    results = []
    for kw in keywords:
        # Fetch data from the API (pseudo-code)
        data = get_serpspur_data(kw, country)

        # Custom scoring: (Search Volume * CPC * 0.5) / (KD + Ad Competition)
        score = (data['volume'] * data['cpc'] * 0.5) / (data['difficulty'] + data['ads_competition'])

        # Filter: Find low-competition, high-value keywords
        if data['difficulty'] < 20 and data['ads_competition'] < 0.3:
            results.append({
                'keyword': kw,
                'volume': data['volume'],
                'cpc': data['cpc'],
                'kd': data['difficulty'],
                'score': round(score, 2)
            })
    return sorted(results, key=lambda x: x['score'], reverse=True)

# Example usage for the German market
keywords = ["seo tool", "keyword planner", "backlink checker"]
print(analyze_keywords(keywords, "de"))

The key insight here is the country-specific data. The tool allows you to switch to specific countries, which is crucial. What works in the US rarely works in France or Japan. The ads competition metric is particularly useful—if nobody is bidding on a keyword via Google Ads, it usually means the traffic is too cold for commercial conversion, or the market is underserved.

My actual workflow now:

Brainstorm 50–100 seed keywords.
Pull volume, CPC, KD, and Ads Competition for target countries.
Filter by KD < 25 and Ads Competition < 0.3.
Rank by a weighted score that prioritizes CPC (revenue potential) over raw volume.

This approach helped me find a niche in the Dutch market where the difficulty was 12 and CPC was $3.50. I published two articles targeting those terms, and within three weeks, I was ranking on page one.

The point isn't to promote a specific tool—it's to stop treating keyword research as a one-size-fits-all metric. Use the filters available to you. Look at the ads competition. Look at the difficulty score relative to your domain authority. And always, always segment by country. Your organic traffic strategy will thank you.

How I Built a Node.js Workflow for Bulk Backlink Exports

Emma Watson — Mon, 17 Aug 2026 04:36:37 +0000

If you’ve ever tried pulling backlink data for dozens of competitor domains, you’ve probably run into the same problems: API rate limits, expensive credits, inconsistent data, and spreadsheets full of manually copied results.

I recently ran into this while working on a large SEO audit. I needed backlink data for more than 50 domains, and manually collecting everything from multiple tools was taking far too long.

Instead of continuing with the spreadsheet approach, I built a small Node.js workflow to handle the process automatically.

The goal was simple:

Input: A list of domains
Output: A clean, normalized CSV containing the backlink data

The interesting part wasn't actually fetching the data. The real challenge was managing concurrency, throttling, retries, and failed requests.

Why Rate Limiting Matters

Most backlink APIs have request limits. If you send dozens of requests simultaneously, you'll eventually start receiving HTTP 429 Too Many Requests responses.

For example, sending 50 requests at once might look efficient, but it's usually a bad idea.

A better approach is to maintain a controlled queue and process a limited number of requests concurrently.

Here's the basic pattern I used:

const pLimit = require("p-limit");

const delay = (ms) =>
new Promise((resolve) => setTimeout(resolve, ms));

async function exportBacklinks(domains) {
const limit = pLimit(5);
const results = [];

const tasks = domains.map((domain, index) =>
limit(async () => {
// Simulate an API request
await delay(1000 + Math.random() * 500);

  // Replace this with your actual API request
  const data = `Data for ${domain}`;


  results.push({
    domain,
    data
  });


  console.log(
    `Processed ${index + 1}/${domains.length}: ${domain}`
  );
})

);

await Promise.all(tasks);

return results;
}

The important part here is:

const limit = pLimit(5);

Instead of firing every request simultaneously, the queue allows only five operations to run at the same time.

That makes the workflow much less likely to overwhelm an API.

Don't Forget Retries

Concurrency control alone isn't enough.

APIs can still return temporary errors, especially when you're processing hundreds or thousands of URLs.

For 429 responses, an exponential backoff strategy is useful. Instead of retrying immediately, increase the delay after each failed attempt.

A simple strategy looks like this:

Attempt 1 → wait 1 second
Attempt 2 → wait 2 seconds
Attempt 3 → wait 4 seconds
Attempt 4 → wait 8 seconds

You should also set a maximum number of retries so a permanently failing domain doesn't keep your entire queue running indefinitely.

Normalize the Data Before Exporting

Another issue I discovered was inconsistent URL formatting.

You might receive:

https://example.com/page
https://example.com/page/

Depending on your analysis, these could end up being treated as different URLs.

Before deduplicating or comparing data, normalize the URLs.

For example:

function normalizeUrl(url) {
return url
.trim()
.replace(/\/$/, "");
}

For production workflows, I'd recommend using a proper URL parser rather than relying only on string manipulation.

Exporting to CSV

Once the backlink data has been collected and normalized, exporting it is relatively straightforward.

Libraries such as json2csv can convert JavaScript objects into CSV format that you can open in Excel, Google Sheets, or process with Python.

The resulting dataset might look something like:

domain,url,anchor,type
example.com,https://example.com/page,SEO guide,dofollow
another.com,https://another.com/resource,marketing,referral

Having everything in a consistent format makes the next stage—actual SEO analysis—much easier.

The Real Problem With Bulk Backlink Analysis

The script itself wasn't the biggest challenge.

The bigger issue was API cost and infrastructure.

When you're analyzing a large number of domains, every API request can consume credits. If you're doing this regularly for multiple clients, those costs can add up quickly.

That's why I eventually moved this particular workflow to a dedicated tool: SERPSpur's Bulk Backlink Exporter.

Bulk Backlink Exporter

Instead of writing and maintaining the entire queue, throttling, and export pipeline myself, I can provide the domains and get structured backlink data ready for analysis.

For one-off experiments, writing your own script is useful. For repetitive SEO audits, using an existing workflow can save a considerable amount of development time.

Lessons From the Workflow

If you're building your own bulk backlink exporter, I'd keep these principles in mind:

Respect API limits

Don't assume that because you can technically send 100 requests at once, you should.

Use concurrency limits and follow the API provider's documented rate limits.

Implement exponential backoff

Temporary failures happen. Give the server time before retrying instead of immediately sending another request.

Normalize your data

Standardize URLs, domains, anchors, and link types before running comparisons or deduplication.

Log failures

When processing 50+ domains, you need to know exactly which request failed and why.

A useful log should include:

Domain
Request status
Error message
Retry count
Timestamp

Separate collection from analysis

Don't try to perform all your SEO analysis while collecting the data.

First create a clean dataset. Then analyze metrics such as referring domains, anchor text, link types, authority, and link growth.

Build It Yourself or Use a Tool?

Building your own exporter is a great learning project if you want to understand asynchronous JavaScript, API limits, queues, and data processing.

But if your main goal is SEO analysis rather than building infrastructure, there's little value in spending an entire weekend maintaining the plumbing.

The most useful part of backlink analysis happens after the data is collected: identifying valuable referring domains, finding competitor gaps, analyzing anchor patterns, and turning those findings into an actionable link-building strategy.

Automate the repetitive part so you can spend more time analyzing the data.

How to Find Backlink Gaps Without Spending Hours in Spreadsheets

Emma Watson — Sat, 15 Aug 2026 04:37:41 +0000

Backlinks are still an important part of SEO, but simply being told to “build more links” doesn’t give you a useful strategy. The real question is: which websites should you target?

That’s where backlink gap analysis becomes useful.

The basic idea is straightforward: compare your backlink profile with your competitors and identify domains that link to them but don’t link to you. These domains can be valuable prospects because they’ve already shown that they’re willing to reference websites in your niche.

The Manual Approach

You can do this manually by exporting backlink data from an SEO tool, importing the files into a spreadsheet, and using formulas such as VLOOKUP or INDEX-MATCH to identify domains that appear in your competitors’ profiles but not yours.

It works, but it gets tedious quickly.

If you already have your backlink data in CSV files, you can automate the basic comparison with Python:

import pandas as pd

def find_gaps(your_file, competitor_file):
you = pd.read_csv(your_file, usecols=["Domain"])
competitor = pd.read_csv(competitor_file, usecols=["Domain"])

your_domains = set(you["Domain"].str.lower().dropna())
competitor_domains = set(competitor["Domain"].str.lower().dropna())


gaps = competitor_domains - your_domains
return sorted(gaps)

opportunities = find_gaps(
"my_links.csv",
"competitor_links.csv"
)

print(f"Found {len(opportunities)} opportunities")

for domain in opportunities[:20]:
print(domain)

This gives you a clean list of domains that appear in the competitor's backlink profile but not yours.

The code isn't really the difficult part, though. The quality of your backlink data matters much more.

A Faster Way to Find the Gaps

If you don't want to spend time exporting CSVs and comparing spreadsheets, I've been using the https://serpspur.com/tool/backlink-gap/ from SERPSpur for this type of workflow.

You enter your domain and competitor domains, and the tool compares their referring domains to identify websites you're missing.

One useful part is being able to prioritize opportunities instead of treating every backlink equally. A relevant, authoritative publication is usually a much better prospect than a random low-quality directory.

For example, during a recent analysis, I found a niche technology publication that was already linking to several competitors but had no link to my site. That immediately gave me a potential outreach target.

How I Use Backlink Gap Analysis

My workflow is fairly simple:

Run a backlink gap analysis against several competitors.
Export or record the most relevant missing domains.
Prioritize sites based on relevance and authority.
Research the pages where competitors earned their links.
Create a personalized outreach pitch.
Track the prospects and follow up.

I usually focus on the top 20–30 realistic opportunities rather than trying to contact hundreds of domains at once.

And the outreach matters.

Don't send a generic message saying:

“Can you please link to my website?”

Instead, explain why your content would actually be useful to their audience. If you have a newer statistic, original research, case study, or better resource, mention that specifically.

Backlink Gaps Are More Useful Than Random Link Building

The biggest advantage of competitor backlink analysis is that you're not starting from zero.

You're looking at websites that have already demonstrated some willingness to link to businesses or content in your space.

That doesn't guarantee they'll link to you, but it gives you a much more qualified prospect list than blindly searching for websites.

If you're already using tools such as Ahrefs or Semrush, you can perform this analysis there as well. For smaller projects, though, a lightweight backlink gap workflow can be enough to uncover some surprisingly good opportunities.

The goal isn't to build the most backlinks. It's to find the right websites and give them a genuine reason to mention your content.

How I Turned a 50+ Domain Backlink Audit Into a 30-Minute Workflow

Emma Watson — Sat, 08 Aug 2026 05:36:34 +0000

Backlink analysis is one of those tasks that seems simple until you need to do it at scale. I recently needed to export backlink data for 50+ domains to identify link-building opportunities for a client, and manually copying data from various tools was painfully slow.

That's when I discovered the Bulk Backlink Exporter from SERPSpur. It lets you pull comprehensive backlink data in one go, which is perfect for competitive analysis or portfolio-wide audits.

The key feature is the ability to organize data by domain, anchor text, and link type—all exportable to CSV for further processing. Here's how I structured my analysis pipeline:

python
import pandas as pd

df = pd.read_csv('backlinks_export.csv')

Filter for high-value links

df['domain_authority'] = df['domain_authority'].astype(int)
high_value = df[df['domain_authority'] > 50]

Group by target domain

summary = high_value.groupby('target_domain').agg(
total_links=('url', 'count'),
avg_authority=('domain_authority', 'mean')
).reset_index()

print(summary.head(10))

This approach let me quickly identify which competitor domains had the strongest link profiles and where the gaps were in our own strategy.

One tip: when exporting large datasets, always filter by date range first. The tool supports this, and it saves you from processing irrelevant historical data that could skew your analysis.

I also found it useful for spotting toxic backlinks across multiple domains at once. By exporting everything and running a simple script to flag suspicious anchors, I could prioritize disavow actions without manually scanning each domain.

For anyone managing multiple sites or doing agency work, this kind of bulk export is a game-changer. It turns a weekend project into a 30-minute task.

How do you handle large-scale backlink audits? I'm always looking for ways to streamline the process further.

Bulk Backlink Exports with Python: Stop Clicking "Next" and Automate Your SEO Workflow

Emma Watson — Wed, 05 Aug 2026 05:33:29 +0000

If you've ever managed backlink audits for multiple websites, you've probably experienced the same frustration.

Most SEO dashboards let you export a few hundred backlinks at a time. That's fine for a quick overview, but it's nowhere near enough for serious analysis. Large websites can have tens of thousands of backlinks, and manually exporting page after page quickly becomes a tedious process.

A while ago, I got tired of downloading dozens of CSV files, merging them together, and cleaning everything in Excel before I could even begin my analysis.

So I automated the entire workflow with Python.

The Problem with Manual Exports

Most backlink tools are designed around their web interface.

That usually means:

Exporting limited rows per download
Clicking through multiple pages
Combining several CSV files
Cleaning inconsistent data formats
Repeating the process for every client

When you're handling multiple projects, this can easily consume hours every week.

Instead of working with backlink data, you're spending your time collecting it.

Automating the Process

The solution was surprisingly straightforward.

Rather than interacting with the dashboard, I queried structured backlink data programmatically and wrote everything directly into a single CSV file.

The exact provider isn't important—the workflow works with any SEO platform that exposes backlink data through an API.

Here's a simplified example.

import requests
import csv

API_KEY = "your_key_here"

DOMAINS = [
"example.com",
"client2.org",
"client3.net"
]

url = "https://serpspur.com/api/v1/bulk-backlinks"

with open("backlinks.csv", "w", newline="", encoding="utf-8") as file:
writer = csv.writer(file)

writer.writerow([
    "Domain",
    "Source URL",
    "Anchor Text",
    "Authority",
    "Status"
])

for domain in DOMAINS:

    params = {
        "api_key": API_KEY,
        "domain": domain,
        "limit": 5000
    }

    response = requests.get(url, params=params).json()

    for backlink in response["data"]:

        writer.writerow([
            domain,
            backlink["source"],
            backlink["anchor"],
            backlink["authority"],
            backlink["status"]
        ])

Instead of downloading dozens of files manually, the script exports everything into one clean dataset.

Why This Saves So Much Time

Once the backlinks are in CSV format, the real work begins.

I can instantly:

Filter only dofollow links
Sort by authority score
Find duplicate backlinks
Analyze anchor text distribution
Detect suspicious link patterns
Build outreach prospect lists

Because every project follows the same structure, the data is much easier to process with Python.

For example:

import pandas as pd

df = pd.read_csv("backlinks.csv")

quality_links = df[
(df["Authority"] > 40) &
(df["Status"] == "dofollow")
]

print(quality_links.head())

With just a few lines of code, you can create a high-quality outreach list instead of scrolling through thousands of rows manually.

Don't Forget Pagination

The sample above assumes everything fits into one response.

In production, many APIs paginate large datasets.

A more scalable solution loops through each page until no additional results are returned.

Something like:

page = 1

while True:

params = {
    "domain": domain,
    "page": page
}

response = requests.get(url, params=params).json()

if not response["data"]:
    break

# Process backlinks...

page += 1

Pagination makes your exporter work equally well for websites with a few hundred backlinks or hundreds of thousands.

Taking It Further

Once you've collected backlink data, you can automate even more tasks:

Generate toxicity reports
Detect lost backlinks
Compare competitors
Monitor link growth over time
Build outreach opportunities
Create monthly SEO reports automatically

At that point, Python becomes far more valuable than another spreadsheet.

Final Thoughts

SEO isn't just about collecting data—it's about making that data useful.

Automating repetitive tasks gives you more time to focus on strategy instead of clicking export buttons all afternoon.

I built this workflow around SERPSpur's Bulk Backlink Exporter, but the overall approach works with any platform that provides structured backlink data through an API.

If you're still downloading backlink reports one page at a time, it's probably time to automate the process. Your future self—and your clients—will appreciate it.

Keyword Research Tool: Find High-Traffic, Low-Competition Keywords

Emma Watson — Mon, 03 Aug 2026 06:03:23 +0000

Keyword research is one of those tasks that seems simple until you actually try to do it properly. I've been refining my workflow recently, and the biggest game-changer was looking beyond just search volume. You really need to consider keyword difficulty, CPC, and ads competition to get a full picture. I built a small script that pulls data from multiple sources and aggregates it into a single CSV. The logic is straightforward: I query for a seed keyword, then expand it with long-tail variations, and finally score each one based on difficulty and potential ROI. The tricky part is filtering by country—search intent varies so much across markets. I found that grouping keywords by country and comparing the metrics side-by-side reveals opportunities you'd miss otherwise. If you want to skip the coding, SERPSpur's Keyword Research Tool does all of this in a few clicks. It gives you search volume, CPC, keyword difficulty, and ads competition for any country. Have you found any particular metric to be more reliable than others when evaluating keywords?https://serpspur.com/tool/keyword-research-tool/

Stop Guessing Domain Quality—Check Trust Signals Before You Build Links

Emma Watson — Sat, 01 Aug 2026 09:24:06 +0000

When I'm evaluating a domain for a project, I don't just look at backlinks. I want to know if the site is actually trustworthy from a technical standpoint. That means checking security headers, SSL configuration, and other behind-the-scenes signals that Google might use. Recently, I started using a dedicated trust rate checker to automate this process.

The SerpSpur Trust Rate Checker does a deep dive into a domain's technical reputation. It analyzes things like HSTS, content security policy, and domain age to give you a single score. This is incredibly useful when you're vetting a potential link partner or buying an expired domain. You can instantly see if the site has been neglected or if it's been maintained with security best practices.

Here's a quick script I use to batch-check multiple domains:

bash

!/bin/bash

Loop through a list of domains and check trust rates

for domain in $(cat domains.txt); do
echo "Checking $domain..."
curl -s "https://api.serpspur.com/trust-rate?domain=$domain" | jq '.score'
done

This saves me from manually visiting each site and inspecting the headers. It's a huge time-saver for outreach campaigns. If you're building a list of high-quality prospects, it's worth running them through this tool first. You can avoid wasting time on domains that have poor technical health. Try it yourself: https://serpspur.com/tool/serpspur-trust-rate-checker/

Find Available Domain Names Faster with an Instant Domain Suggestion Checker 🌐

Emma Watson — Mon, 27 Jul 2026 10:01:32 +0000

I'm always looking for domain names for new projects, and checking availability one by one on registrars is tedious. I found a Domain Suggestion Checker that lets you check availability instantly and even suggests alternatives. It's great for brainstorming – you type in a keyword, and it shows what's available. For automation, I wrote a small script to batch check names from a list:

python
import requests

def check_domain(domain):
url = f'https://serpspur.com/tool/domain-sugesstion-checker/?domain={domain}'
resp = requests.get(url)
if 'available' in resp.text.lower():
return f'{domain} is available'
return f'{domain} is taken'

domains = ['mycoolidea.com', 'mycoolidea.net', 'mycoolidea.io']
for d in domains:
print(check_domain(d))

It's not perfect for bulk, but for quick checks it's handy. If you're domain hunting, give it a try. https://serpspur.com

Take Control of AI Crawlers with an LLM.txt Generator for Smarter Content Access

Emma Watson — Wed, 22 Jul 2026 06:04:32 +0000

If you’ve been building websites in the last year, you’ve likely noticed a new kind of visitor showing up in your logs—AI crawlers. Bots from OpenAI, Anthropic, Google, and others are scraping content to train models and feed knowledge bases. But unlike traditional search crawlers, these bots don’t always respect robots.txt the same way. And even when they do, robots.txt lacks the granularity to tell an AI how to use your content.

This is where LLM.txt comes in. Think of it as a more modern, semantic companion to robots.txt. While robots.txt tells crawlers what to avoid, LLM.txt tells them how to interact—what content is safe to summarize, what should be cited, and what’s strictly off-limits for training.

I recently needed to set this up for a client project. Manually crafting the file is tedious, especially if you have a large site with multiple content types. That’s when I came across the SERPSpur LLM.txt Generator tool. It’s a straightforward web utility that lets you define rules for different AI crawlers and content sections. You can specify access levels—like “summarize only,” “allow training,” or “block entirely”—and it generates the full LLM.txt file for you.

Here’s a quick example of what the output looks like:

# LLM.txt configuration for example.com
# Generated with SERPSpur LLM.txt Generator

User-agent: *
Allow: /blog/
Disallow: /private/

For-model: GPT-4
  Allow: /docs/
  Disallow: /support/

For-model: Claude
  Allow: /public/
  Disallow: /api/

The syntax is still evolving, but the idea is clear: you can give different AI crawlers different permissions. This is huge for content creators who want to remain visible in AI-powered search but don’t want their proprietary tutorials or product docs used for model training.

What I like most is that the generator also includes a preview of what your file will look like and checks for common errors. No more guessing if your syntax is correct. Once you’re happy, you just drop the LLM.txt file into your site’s root directory.

If you haven’t looked into LLM.txt yet, it’s worth the 10 minutes. As AI crawlers become the default way users discover content, having control over how your site is consumed isn’t just nice—it’s necessary.

The Free File Converter I Keep Coming Back To: Fast, No Watermarks, and Supports 200+ Formats

Emma Watson — Mon, 20 Jul 2026 05:52:23 +0000

File conversion is one of those tasks that seems simple but always ends up being a hassle. I've tried a dozen online converters, and most either have file size limits, require sign-ups, or are painfully slow. Recently, I needed to convert a batch of WebP images to PNG and a PDF to DOCX for a client. I found SerpSpur's All Type Free File Converter, and it handled both flawlessly. It supports over 200 formats, including CSV, DOCX, PDF, and WebP. The best part? No upload limits or watermarks. I converted a 50MB PDF in seconds, and the output was clean. It's also secure—no files are stored on their servers. If you deal with format conversions regularly, this is a solid tool to bookmark. Try it here: https://serpspur.com/tool/all-type-free-file-converter/. It's fast, free, and actually works.

From PDFs to Spreadsheets: My Go-To Workflow for Converting Invoices to CSV in Seconds

Emma Watson — Wed, 08 Jul 2026 10:40:12 +0000

I've been automating invoice processing for a side project, and one thing that always tripped me up was converting different formats to CSV. Whether it's a PDF from a vendor, an Excel sheet from a client, or an HTML table from a web app, you need a reliable way to extract data. Here's a bash script I use for quick conversions, plus a web tool for when I'm not in the terminal.

bash

!/bin/bash

Convert all invoices in a folder to CSV

Requires: python3, pandas, pdfplumber, openpyxl, lxml

for file in invoices/; do
ext="${file##.}"
case "$ext" in
pdf)
python3 -c "
import pdfplumber, pandas as pd
with pdfplumber.open('$file') as pdf:
rows = []
for page in pdf.pages:
table = page.extract_table()
if table:
rows.extend(table)
df = pd.DataFrame(rows[1:], columns=rows[0])
df.to_csv('${file%.}.csv', index=False)
print('Converted $file')
"
;;
xls|xlsx)
python3 -c "
import pandas as pd
df = pd.read_excel('$file', engine='openpyxl')
df.to_csv('${file%.}.csv', index=False)
print('Converted $file')
"
;;
html|htm)
python3 -c "
import pandas as pd
df = pd.read_html('$file')[0]
df.to_csv('${file%.*}.csv', index=False)
print('Converted $file')
"
;;
*)
echo "Skipping $file: unsupported format"
;;
esac
done

This script works great for batch processing, but if you need a quick, one-off conversion without setting up dependencies, SERPSpur's Invoice to CSV Converter handles PDF, XLS, XLSX, and HTML instantly—no code required.