DEV Community: clement-melkior

I asked a keyword API for 80 long-tail keywords and got 8. Here is why, and how to fix it

clement-melkior — Mon, 05 Oct 2026 19:18:09 +0000

I was building a small keyword research script and asked a keyword data API for 80 long-tail ideas around "running shoes", sorted by search volume. The top of the list looked like this:

sneaker running shoes     301,000
running on shoes          301,000
shoes running             301,000
running and shoes         301,000
running with shoes        301,000
shoes for running         301,000
runners running shoes     301,000

Seven "ideas", one number. It is the same keyword seven times.

Why this happens

Google Ads does not report search volume per exact wording. It groups close variants together (reordered words, plurals, filler words like "for" and "with") and reports one figure for the whole family. Every tool that resells Google Ads data inherits this.

The data provider then returns each member of the family as its own row. So a "list of 80 keywords" is really a much shorter list, repeated.

I checked how much shorter. Two rows belong to the same family when all their Google Ads figures match: same volume, same cost per click, same competition, and the same twelve months of history. Grouping my 80 rows that way gave:

Family	Rows
running shoes (the seed itself)	12
on running shoes	8
nike running shoes	31
trail running shoes	18
brooks running shoes	5
stability running shoes	4
two single keywords	2

80 rows, 8 distinct keywords. And one of the 8 was the seed I started from.

If you pay per result, or if you hand this list to a writer or an LLM, nine tenths of it is noise.

How to fix it yourself

If you already pull keyword data from an API, the fix is a few lines.

1. Build a signature per row from the figures Google reports:

import json

def signature(row):
    info = row["keyword_info"]
    return json.dumps([
        info["search_volume"],
        info["cpc"],
        info["competition"],
        [m["search_volume"] for m in info["monthly_searches"][:12]],
    ])

Matching on volume alone is not enough. Google rounds volumes into buckets, so "nike running shoes" and "trail running shoes" can both show 165,000 while being different keywords. Their cost per click and monthly history differ, which is what separates them.

2. Group rows by signature and keep one per group. Picking which one matters, or you end up showing "shoes running" instead of "running shoes". What worked for me, in order: prefer a wording that contains the seed phrase intact, then the shortest one.

3. Drop the group that contains your seed. It is not an idea.

4. Ask for more rows than you need. With roughly ten rows per family, getting 100 real ideas means fetching around 1,000 rows.

Or use the version I packaged

I turned this into a tool: Keyword Ideas Generator on Apify. It does the grouping, returns one clean keyword per family, and lists the other wordings beside it.

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("spokentext/keyword-ideas").call(run_input={
    "seedKeywords": ["running shoes"],
    "maxResults": 10,
    "maxKeywordDifficulty": 40,
})

for row in client.dataset(run.default_dataset_id).iterate_items():
    print(f'{row["keyword"]}: {row["searchVolume"]}/month, difficulty {row["keywordDifficulty"]}')

For the same seed, the first results are now different keywords:

running shoes on: 201000/month, difficulty 27
nike running shoes: 165000/month, difficulty 34
trail running shoes: 165000/month, difficulty 3
asics novablast 5 running shoes: 165000/month, difficulty 1
brooks running shoes: 165000/month, difficulty 12

Each row also carries cost per click, advertiser competition, search intent, and a closeVariants field with the wordings that were merged into it. You can filter by minimum volume and maximum difficulty before paying, and choose between long-tail ideas (containing your seed) and related ideas (same topic, different words).

It costs $0.006 per idea plus $0.03 per search, so 100 ideas for one seed is $0.63.

What it does not do

It needs a paid Apify plan. Every search is bought from a data provider, so the free plan returns labelled sample rows only.
The pick is not always perfect. In the output above, "running shoes on" is the brand On, which people type as "on running shoes". The merged wordings are in closeVariants, so you can see what was grouped.
Country level, Google only, with data refreshed monthly.
No brand-new topics. Ideas come from keywords people already search for.

The takeaway

Whatever tool you use, check your keyword lists for repeated volumes before acting on them. If twenty rows share the same number, you have one keyword, not twenty.

Disclosure: I built the tool described above. This article was drafted with AI assistance and checked by me.

How to get Google search volume for a list of keywords (without a Google Ads account)

clement-melkior — Mon, 05 Oct 2026 19:08:39 +0000

"How many people search for this?" is the first question behind any content plan, product idea or ad budget. Getting a straight answer for a list of keywords is harder than it should be.

Here are the options I looked at, with their real limits.

1. Google Keyword Planner

The official source. It is free, but:

You need a Google Ads account, and setting one up pushes you toward creating a campaign.
Without an active campaign, volumes come back as wide ranges such as "1K – 10K", which is not much use for comparing keywords.
There is no bulk export through code unless you get approved for the Google Ads API.

Good for: people already running Google Ads.

2. Google Trends

Free and needs no account, but it does not answer the question. Trends shows interest on a relative 0 to 100 scale, not how many searches there are. Two keywords at "80" can differ by a factor of a thousand in real volume.

Good for: seasonality and comparing a few terms. Not for volumes.

3. SEO suites

Ahrefs, Semrush and similar tools show volume, difficulty and much more. They are excellent, and they start at around a hundred dollars a month.

Good for: people doing SEO every day. Hard to justify for an occasional lookup or for a script.

4. A keyword data API

Several providers resell Google Ads keyword data through an API. I use DataForSEO: its keyword overview endpoint returns volume, cost per click, competition, difficulty and search intent, and takes up to 700 keywords per request.

The catch for small projects is the entry cost: a $50 minimum deposit, plus the work of writing the client, batching, and handling keywords that have no data.

Good for: building a product on top of keyword data.

5. Pay per lookup

I wanted option 4 without the deposit or the client code, callable from scripts and automation tools. So I wrapped it: Keyword Search Volume on Apify.

You paste keywords and pick a country. Each keyword comes back as one row:

{
    "keyword": "running shoes",
    "found": true,
    "country": "US",
    "language": "en",
    "searchVolume": 301000,
    "cpc": 1.09,
    "competition": 1,
    "competitionLevel": "HIGH",
    "lowTopOfPageBid": 0.47,
    "highTopOfPageBid": 2.17,
    "keywordDifficulty": 43,
    "searchIntent": "transactional",
    "trend": { "monthly": 22, "quarterly": 50, "yearly": -45 },
    "monthlySearches": [
        { "month": "2026-08", "searchVolume": 301000 },
        { "month": "2026-07", "searchVolume": 246000 }
    ],
    "dataUpdatedAt": "2026-09-15"
}

From Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("spokentext/keyword-search-volume").call(run_input={
    "keywords": ["running shoes", "trail running shoes", "best running shoes for flat feet"],
    "country": "US",
})

for row in client.dataset(run.default_dataset_id).iterate_items():
    if row["found"]:
        print(f'{row["keyword"]}: {row["searchVolume"]} searches/month, difficulty {row["keywordDifficulty"]}')
    else:
        print(f'{row["keyword"]}: no data')

It covers 92 countries and up to 20,000 keywords per run, with up to 24 months of history per keyword.

Pricing is $0.004 per keyword with data, plus $0.02 per lookup of up to 700 keywords. A hundred keywords cost $0.42. Keywords with no data are free.

What to know before using it

It needs a paid Apify plan. Every lookup is bought from the data provider, so on Apify's free plan the tool returns clearly labelled sample rows instead of live data.
The data is monthly, not real time. Each row carries the date it was last updated.
Country level only. No city or region breakdown.
Google groups close variants. "running shoe" and "running shoes" can share one figure. That comes from Google Ads itself, and every tool built on that data inherits it.
Rare keywords have no data. They come back with "found": false.

Which option to pick

Your situation	Use
You already run Google Ads	Keyword Planner
You only care about seasonality	Google Trends
You do SEO daily	An SEO suite
You are building a keyword product	A data API directly
You need volumes for a list now and then, or inside a script or automation	Pay per lookup

Disclosure: I built the tool described in section 5. This article was drafted with AI assistance and checked by me.

How to transcribe audio and video files to text with one API call (MP3, MP4, Google Drive, Dropbox)

clement-melkior — Mon, 05 Oct 2026 16:36:33 +0000

Speech-to-text models are very good now. The annoying part is everything around them: recordings that are too big to upload, video files, and files that live behind a Google Drive or Dropbox share link.

This post covers the do-it-yourself route first, then a one-call alternative I built for myself.

The do-it-yourself route

Short audio file

If you have a short MP3 and Python, open-source Whisper is enough:

pip install -U openai-whisper
whisper interview.mp3 --model small --output_format txt

Video file

Whisper wants audio. Pull the audio track out with ffmpeg first, and shrink it while you are there, since speech models work on 16 kHz mono anyway:

ffmpeg -i meeting.mp4 -vn -ac 1 -ar 16000 -b:a 48k meeting.mp3

A one-hour video becomes an MP3 of about 20 MB.

Long recordings and hosted APIs

Hosted speech-to-text APIs are much faster than a laptop, but they cap the upload size. OpenAI's transcription endpoint, for example, accepts files up to 25 MB. For a long recording you have to:

split the audio into chunks,
transcribe each chunk,
shift every chunk's timestamps by where it started,
join the text back together.

ffmpeg can do the split:

ffmpeg -i meeting.mp3 -f segment -segment_time 600 -c copy chunk_%03d.mp3

The rest is glue code, plus retries for when the API rate-limits you halfway through.

Share links

A Google Drive or Dropbox share link opens a preview page, not the file. You need the direct-download form:

Dropbox: change dl=0 to dl=1 at the end of the link.
Google Drive: take the file ID from the link and use https://drive.usercontent.google.com/download?id=FILE_ID&export=download&confirm=t.

None of this is hard. It is just a lot of small steps to maintain.

The one-call route

I packaged those steps into a tool: Audio & Video to Text on Apify. You give it file links, Drive or Dropbox share links, or an uploaded file, and it handles extraction, splitting, retries and timestamps. Transcription uses Whisper large-v3.

curl -X POST "https://api.apify.com/v2/acts/spokentext~audio-video-to-text/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "urls": ["https://example.com/interview.mp3"], "includeSrt": true }'

The response is one JSON object per file:

{
    "status": "ok",
    "fileName": "interview.mp3",
    "language": "English",
    "durationSeconds": 1842,
    "transcribedMinutes": 31,
    "text": "Thanks for joining me today. Let's start with...",
    "segments": [{ "start": 0, "end": 3.4, "text": "Thanks for joining me today." }],
    "srt": "1\n00:00:00,000 --> 00:00:03,400\nThanks for joining me today.\n"
}

To process a batch from Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("spokentext/audio-video-to-text").call(run_input={
    "urls": [
        "https://example.com/interview.mp3",
        "https://www.dropbox.com/scl/fi/abc123/meeting.mp4?rlkey=xyz&dl=0",
    ],
})

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["fileName"], item["status"], len(item.get("text", "")))

From my own runs: a 50-minute MP3 shared through Dropbox was transcribed in about 40 seconds and cost $0.15. Pricing is $0.003 per audio minute, and files that fail are not charged.

What it does not do

No YouTube or TikTok links. It takes files, not video pages.
No speaker labels. You get what was said, not who said it.
Your audio leaves your machine. It is sent to a hosted speech-to-text provider for processing. If the recording is sensitive, run Whisper locally instead.

Which route to pick

Situation	Route
A few short files, privacy matters most	Whisper on your own machine
Long recordings, video, share links, or batches	The API
You need speaker labels	Neither; look for a tool with diarization

Disclosure: I built the tool described in "The one-call route". This article was drafted with AI assistance and checked by me.

How to get a transcript of any Spotify podcast episode (3 ways, with and without code)

clement-melkior — Mon, 05 Oct 2026 16:35:14 +0000

I wanted the text of a few podcast episodes so I could search them and feed them to an LLM. Spotify shows a transcript in its app for some shows, but there is no export button, and many shows have no transcript at all.

Here are the three ways I found to get one, with the trade-offs of each.

1. Read it in the Spotify app

Open the episode, scroll down, and if the show has transcripts enabled you will see a Transcript section.

Good for: reading along.
Not good for: anything else. You can't copy the whole thing, download it, or get it for shows that don't have one.

2. Do it yourself with the RSS feed and Whisper

Almost every podcast on Spotify is also published through a public RSS feed, and the feed links to the actual audio file. So you can download the audio and transcribe it on your own machine.

Find the feed. Apple runs a free lookup API:

curl "https://itunes.apple.com/search?media=podcast&term=lex+fridman+podcast"

The feedUrl field in the response is the RSS feed. Open it, find the episode you want, and copy the URL in its <enclosure> tag. That is the audio file.

Transcribe it with OpenAI's open-source Whisper:

pip install -U openai-whisper
curl -L -o episode.mp3 "PASTE_THE_ENCLOSURE_URL"
whisper episode.mp3 --model small --output_format txt

Good for: occasional use, full control, no account anywhere.
Not good for: long episodes on a laptop without a GPU (it is slow), or doing this for many episodes. Matching a Spotify link to the right feed and the right episode by hand also gets old quickly.

Shows that are exclusive to Spotify have no public feed, so this route does not work for them.

3. Paste the Spotify link into a tool

I got tired of step 2, so I built a small tool that does the same thing automatically: Spotify Podcast Transcript on Apify.

You paste the link you get from Spotify's Share → Copy link, and it finds the show's public feed, matches the episode, and transcribes the audio with Whisper large-v3. It also accepts Apple Podcasts links, RSS feeds and direct audio URLs.

From Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("spokentext/spotify-podcast-transcript").call(run_input={
    "urls": ["https://open.spotify.com/episode/4IpeKxxTTa6vw4lRbqH0lg"],
})

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["episodeTitle"])
    print(item["text"][:500])

Each result has the plain text, timestamped segments, and optionally an SRT subtitle file. Paste a show link instead of an episode link and it takes the most recent episodes.

Some numbers from my own runs: a 50-minute episode took about 40 seconds and cost $0.15 (it is priced at $0.003 per audio minute). Apify's free plan includes $5 of credit a month, which covers roughly 27 hours of audio.

Good for: many episodes, automation, pipelines that start from a Spotify or Apple link.
Not good for: Spotify-exclusive shows (same limit as the manual route: no public audio), and it does not label who is speaking.

Which one should you use?

You want to...	Use
Read along once	The Spotify app
Transcribe an episode now and then, for free	RSS feed + Whisper
Transcribe many episodes or automate it	The tool, through its API

One reminder: a transcript is a copy of someone else's work. Using it for your own notes, search or analysis is one thing; republishing it needs the publisher's permission.

Disclosure: I built the tool described in section 3. This article was drafted with AI assistance and checked by me.

How to extract text from PDFs and scanned documents (and how to tell which pages need OCR)

clement-melkior — Mon, 05 Oct 2026 16:20:14 +0000

"Extract the text from this PDF" hides two very different jobs:

A digital PDF was made on a computer. The text is inside the file and can be read exactly.
A scanned PDF is a stack of pictures. There is no text in it until you run OCR (optical character recognition).

They look identical on screen. Use the wrong tool and you get either nothing or slow, error-prone output for text that was sitting in the file all along. And plenty of real documents mix both: a typed contract with a scanned signature page, for example.

Step 1: check what you have

pdftotext comes with Poppler (apt install poppler-utils, or brew install poppler):

pdftotext report.pdf - | head -20

If you see your text, the PDF is digital and you are done:

pdftotext report.pdf report.txt            # flowing text
pdftotext -layout report.pdf report.txt    # keeps columns and tables aligned

If the output is empty or just a few stray characters, the pages are scans.

Step 2: OCR the scanned pages

Render the pages to images, then run Tesseract on each one:

apt install tesseract-ocr tesseract-ocr-fra    # add the languages you need

pdftoppm -r 200 -gray -png scan.pdf page
for f in page-*.png; do tesseract "$f" "${f%.png}" -l eng; done
cat page-*.txt > scan.txt

Three things I learned the hard way:

200 DPI is a good default. Below about 150, small print starts to break. Higher mostly costs time.
Tell Tesseract the language. -l fra or -l eng+fra matters a lot for accents. Don't add languages you don't need: each one slows it down.
In a container, set OMP_THREAD_LIMIT=1. Tesseract starts four threads by default. On a container with one CPU core they fight each other: in my tests the same dense page took 10.4 seconds by default and 3.8 seconds with the limit set.

Step 3: mixed documents

For a PDF with both kinds of pages, check each page separately. pdftotext separates pages with a form-feed character, so you can split its output, keep the pages that have text, and send only the empty ones to OCR. That keeps the exact text where it exists and avoids paying the OCR time for pages that don't need it.

When an API is easier

I needed this as a service I could call from scripts, so I packaged the steps above into a tool: PDF & Image to Text on Apify. It decides page by page whether to read the text layer or run OCR, and also takes images (PNG, JPEG, TIFF, WEBP), Google Drive and Dropbox share links, and uploads.

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("spokentext/pdf-image-to-text-ocr").call(run_input={
    "urls": ["https://arxiv.org/pdf/1706.03762"],
    "languages": ["en"],
})

for doc in client.dataset(run.default_dataset_id).iterate_items():
    print(doc["fileName"], doc["pageCount"], "pages")
    for page in doc["pages"]:
        print(page["page"], page["method"], len(page["text"]))

Each page comes back with a method field: text if it was read from the file, ocr if it was recognised. That 15-page paper is fully digital and came back in a few seconds.

It is priced per page: $0.001 for a digital page and $0.004 for an OCR page. Files are processed inside the run and are not sent to any outside AI service.

What neither route does well

Handwriting. Tesseract is built for printed text.
Tables as data. You get lines of text, not rows and columns. -layout keeps the alignment, which is often enough for an LLM to read.
Bad photos. Blurry, skewed or shadowed pictures of documents give poor results. Rescan if you can.
Password-protected PDFs. Remove the password first.

Summary

Your document	Do this
Digital PDF	`pdftotext`, exact and instant
Scanned PDF or image	Render at 200 DPI, then Tesseract with the right language
Mixed, or many files	Check page by page, or use the API

Disclosure: I built the tool described in "When an API is easier". This article was drafted with AI assistance and checked by me.