DEV Community: Fast Data

Bulk-upscale product photos from a Google Sheet with n8n and Real-ESRGAN

Fast Data — Wed, 21 Oct 2026 11:44:13 +0000

If you have ever imported products from a supplier, you know the problem: half of the images are 400 pixels wide. Marketplaces want 1,000+ px, zoom features want more, and nobody wants to open 300 files one by one in an upscaling web app.

This n8n workflow does it from a Google Sheet. You paste image URLs into a column, click Execute workflow, and every image is upscaled 4x with Real-ESRGAN, saved to Google Drive, and the Drive link, new size and status are written back into the same row. Run it again later and it only processes the new rows.

Disclosure: the upscaling runs on the AI Image Upscaler Actor on Apify, which I built. Prices are below.

How it looks

Your sheet has a tab Images with four columns (illustrative rows):

image_url	upscaled_url	size	status
https://…/sku-1001.jpg	https://drive.google.com/file/d/…/view	3200x3200	done
https://…/sku-1002.jpg			failed: HTTPStatusError: Client error '404 Not Found' …
https://…/sku-1003.jpg

You fill image_url; the workflow fills the rest. In my test run a 179x179 px JPG came back as a 716x716 px file (92 kB) after about a second of processing, and a broken link was written back as failed, free of charge.

The workflow

Manual Trigger
  → Google Sheets: read "Images"
  → Filter: has image_url, no upscaled_url
  → Code: batch URLs (5 per batch)
  → HTTP Request: AI Image Upscaler
  → IF status = ok
       ├ yes → HTTP Request: download → Google Drive: upload → Set row → Google Sheets: update
       └ no  → Set row (failed + reason) ──────────────────────────────→ Google Sheets: update

Batching

Apify's synchronous endpoint (run-sync-get-dataset-items) is the simplest way to call an Actor from n8n: one request in, results out. It waits at most 300 seconds, though. Instead of sending 300 images in one run, a Code node groups the URLs into batches of five:

const BATCH_SIZE = 5;
const urls = [...new Set($input.all().map(i => String(i.json.image_url || '').trim()).filter(Boolean))];
const batches = [];
for (let i = 0; i < urls.length; i += BATCH_SIZE) batches.push({ json: { imageUrls: urls.slice(i, i + BATCH_SIZE) } });
return batches;

The HTTP Request node runs once per incoming item, so each batch becomes one Actor run, and the body is built from the item:

={{ JSON.stringify({ imageUrls: $json.imageUrls, scale: '4', outputFormat: 'jpg', quality: 92 }) }}

The Actor returns one result per image with status, outputUrl, outputWidth, outputHeight, or an error for images it could not process.

Why copy to Google Drive?

The upscaled files live in the Apify run's key-value store. The links work right away, but unnamed Apify storage is deleted after your plan's retention period (7 days on the free plan at the time of writing). For product images you want something permanent, so the workflow downloads each file (same Apify credential) and uploads it to a Drive folder. Swap that node for S3, Cloudinary or your shop's media upload if you prefer.

Writing back to the right row

The Google Sheets Update operation matches on the image_url column. That only works if the URL that comes back is exactly the one in the sheet, which is why the batching code trims whitespace and the Actor echoes the original URL as sourceUrl. The Drive file name is derived from it too: sku-1001.jpg becomes sku-1001-4x.jpg.

Quality and limits

Real-ESRGAN (general x4 v3) is good at sharpening edges, text and product shapes. It does not invent detail that isn't there; a blurry face stays a slightly cleaner blurry face.
Inputs are capped at 1 megapixel by default (larger images are scaled down first), so a 4x result is up to about 16 MP. That's plenty for shops and print catalogues and keeps processing fast.
"scale": "2" is often enough for web shops and gives smaller files.
PNG output keeps transparency for cut-out product shots and logos.

Cost

$0.015 per upscaled image, $15 per 1,000. Failed images are free. 100 product photos = $1.50. Apify's free plan includes $5 per month, roughly 330 images.

Get it

Workflow JSON and setup guide: https://github.com/ichkifokkus/data-recipes/tree/main/5-bulk-image-upscale
Actor: https://apify.com/fast_data_asap/ai-image-upscaler

Setup takes about ten minutes: one Apify credential, Google Sheets and Google Drive. Start with two or three rows to check the output before you throw your whole catalogue at it.

Only upscale images you have the rights to use. The model is BSD-licensed; the images are not.

Hiring signals: get a Slack alert when target companies post new jobs (n8n)

Fast Data — Wed, 21 Oct 2026 06:45:13 +0000

Job postings are one of the most honest signals a company sends. A startup that opens five account executive roles in a new country is about to sell there. A first "Head of Data" means a data stack is about to be bought. A burst of support roles often follows a launch.

Sales teams call these hiring signals, investors use them to track growth, and job seekers just want to be early. In all three cases the job is the same: watch a list of career pages and tell me what is new. This n8n workflow does exactly that, once a day, for about a dollar a month.

Disclosure: the job data comes from the Job Search API Actor on Apify, which I built. Pricing and limits are below.

The result

From a test run watching Stripe, Ramp and Palantir (postings from the last two days):

Hiring signals: 13 new role(s) at 3 company(ies)

Stripe: 9 new (Sales 3, Engineering 3, Leadership 1, Marketing 1, Customer 1)
- Account Executive, Velocity Platforms (Hunter) - Chicago, IL; New York, NY; ...
- Backend / API Engineer, Radar
- Country Manager, Israel - Israel
- Engineering Manager, Money as a Service (MaaS) - Singapore
...and 4 more (see the sheet)

Ramp: 2 new (Recruiting & People 2)
- Technical Sourcer - Engineering (Contract) - New York, NY (HQ)
- Lead Recruiter - Executive - New York, NY (HQ)

Palantir: 2 new (Engineering 2)
- Software Engineer, New Grad - Query Engines - London, United Kingdom
...

"Country Manager, Israel" is precisely the kind of line a sales or partnerships team wants to see on the day it appears. Every posting is also appended to a Google Sheet (company, team, title, location, remote, posted date, URL), so you can count over months.

The workflow

Schedule (daily 8:00)
  → HTTP Request: Job Search API (company career pages)
  → Remove Duplicates (previous executions, by job URL)
  → Code: tag team & pick columns
      ├→ Google Sheets (append)
      └→ Code: build digest → Slack

Reading career pages without scraping HTML

Most tech companies host their careers page on an applicant tracking system: Greenhouse, Lever, Ashby or SmartRecruiters. All four have public JSON endpoints for open positions. The Actor reads those and returns one unified format, so you can mix them freely:

{
  "companies": ["greenhouse:stripe", "ashby:ramp", "lever:palantir"],
  "postedWithinDays": 2,
  "maxJobsPerSource": 100,
  "includeDescription": false
}

You can also pass careers URLs like https://jobs.lever.co/palantir. Since no keywords are set, only the company pages are read and every role is returned. (With keywords, the Actor also searches public job boards: Remote OK, Himalayas, Arbeitnow and the German Federal Employment Agency. That's handy for a job-seeker version.)

The HTTP Request node calls https://api.apify.com/v2/acts/fast_data_asap~job-search-api/run-sync-get-dataset-items with a Header Auth credential (Authorization: Bearer <token>). For three companies, the run took about six seconds.

"New since the last run"

This is the part people usually build with a database. n8n has it built in: Remove Duplicates with "Remove items processed in previous executions", keyed on {{ $json.url }}. It stores every URL it has seen and only passes on new ones. I tested it by running the workflow twice in a row: the first run let 13 postings through, the second discarded all 13.

postedWithinDays: 2 (not 1) is deliberate. If a run fails or n8n is down for a day, the next run still covers the gap, and deduplication takes care of the overlap.

Guessing the team

Job titles are messy, but a dozen regexes get you surprisingly far:

const TEAMS = [
  ['Leadership', /\b(head of|director|vp|vice president|chief|country manager|general manager)\b/i],
  ['Recruiting & People', /recruit|sourcer|talent|people partner|\bhr\b/i],
  ['Sales', /sales|account executive|account manager|business development|\b[bs]dr\b|partnership/i],
  // ... Marketing, Customer, Data & AI, Engineering, Product & Design
];

Order matters. My first version put Engineering first, and "Account Executive, Velocity Platforms" was filed as Engineering because of platform. Now leadership and go-to-market patterns are checked first, and Engineering no longer matches on "platform".

Cost

The Actor charges $0.0025 per job returned. The test run above returned 13 jobs = $0.03; a daily run for three fast-growing companies comes to about $1 per month. Because of the one-day overlap, some postings are returned (and paid) twice; for very large companies, postedWithinDays: 1 halves the cost.

Apify's free plan includes $5 per month.

Ideas

Filter to what you sell into: add a Filter node, e.g. team = Sales or title contains "Data".
Tech-stack research: includeDescription: true plus an LLM step "Which tools does this posting mention?"
CRM task instead of Slack: create a HubSpot or Pipedrive task "Company X is hiring 5 AEs in DACH".
Job-seeker mode: add "keywords": "python developer" and "remoteOnly": true.
Workday employers: the Job Search API doesn't read Workday career sites. For those I built a second Actor, the Career Site Jobs API: nine ATS including Workday, Workable, Teamtailor, Recruitee and Personio, plus an optional "only new jobs" mode that remembers what it has already returned. $2 per 1,000 jobs (down to $1.50 on higher Apify plans).

Get it

Workflow JSON and setup guide: https://github.com/ichkifokkus/data-recipes/tree/main/4-hiring-signal-alert
Actor: https://apify.com/fast_data_asap/job-search-api

Job ads can contain recruiter names and e-mail addresses. Store and use them in line with data protection rules.

Build a weekly Google Trends report in Google Sheets with n8n (no pytrends)

Fast Data — Tue, 20 Oct 2026 16:44:30 +0000

Google Trends is one of the most useful free datasets in marketing and one of the most annoying to automate. There is no official API, the website compares at most five keywords, and pytrends breaks whenever Google changes something. So most people check it by hand once in a while and forget about it.

Here is a small n8n workflow that turns it into a habit: every Monday it pulls the last 90 days for your keywords and appends one row per keyword to a Google Sheet, with this week vs. last week, change in %, the peak day and the top rising related searches. After a month you have a trend history that's easy to chart.

Disclosure: the data comes from the Google Trends Scraper on Apify, which I built. Costs are in the post.

The output

Real numbers from a test run (US, past 90 days, three note-taking apps):

keyword	this_week	last_week	change_pct	period_avg	peak	rising_queries
notion	52.9	53.4	-1.1	61.1	Aug 24, 2026	notion ai workspace (+200%), ...
obsidian	74.1	75.1	-1.3	75.6	Jul 26, 2026	air jordan 12 obsidian 2027 (Breakout), ...
evernote	2.9	3.7	-23.1	3.4	Aug 13, 2026	how to delete evernote account (Breakout), ...

Two things jump out, and they are exactly why I like having the rising queries next to the numbers:

"obsidian" scores higher than "notion", but the rising queries are about sneakers, phones and Minecraft. The keyword is ambiguous, so its number tells you little about the app.
Evernote is small and dropping, and the top rising query is "how to delete evernote account".

The numbers are Google's relative interest (0-100) on one shared scale, not search volumes. They are good for comparing terms and periods, not for "how many people searched".

The workflow

Four nodes:

Schedule (Monday 8:00) → HTTP Request (Google Trends Scraper) → Code → Google Sheets (append)

Fetching the data

The HTTP Request node calls Apify's run-sync-get-dataset-items endpoint for the Actor fast_data_asap~google-trends-scraper (Header Auth credential with Authorization: Bearer <token>) with this body:

{
  "searchTerms": ["notion", "obsidian", "evernote"],
  "geo": "US",
  "timeRange": "today 3-m",
  "includeInterestOverTime": true,
  "includeInterestByRegion": false,
  "includeRelatedQueries": true
}

The response contains one item of type interestOverTime (a timeline with values for every keyword) and one relatedQueries item per keyword, with top and rising lists.

Unlike the Trends website you can pass more than five keywords. The Actor splits them into batches that share an anchor keyword and rescales everything onto one 0-100 scale, so twenty competitors are still directly comparable.

The Code node

The interesting part is turning a timeline into "this week vs. last week":

const points = (t.timeline || []).filter(p => !p.isPartial);
const stepDays = points.length > 1 ? (points[1].time - points[0].time) / 86400 : 7;
const win = Math.max(1, Math.round(7 / stepDays)); // 7 for daily data, 1 for weekly data
for (const kw of t.keywords) {
  const series = points.map(p => Number(p.values[kw] ?? 0));
  const thisWeek = avg(series.slice(-win));
  const lastWeek = avg(series.slice(-2 * win, -win));
  // ... change_pct, peak, top 5 rising queries
}

Two details:

Drop the partial point. The most recent data point is usually incomplete (isPartial: true) and always looks like a drop. Comparing it would give you a "-40%" panic every Monday.
Detect the resolution. Google returns daily points for 90 days and weekly points for 12 months. Computing the step from the timestamps means you can change timeRange without touching the code.

The result is one item per keyword, and the Google Sheets node appends them using automatic column mapping, so the header row just needs matching names.

Cost

The Actor charges $0.003 per result. A result is one timeline, one regional breakdown or one related-queries list. Three keywords with related queries = 4 results = $0.012 per run, about $0.05 a month for a weekly report. With related queries switched off, a run costs $0.003 no matter how many keywords you track.

Ideas

Spike alert: add an IF node change_pct > 30 → Slack.
Seasonality: a one-off run with "timeRange": "today 5-y" before you plan campaigns or stock.
Where to advertise: "includeInterestByRegion": true with "regionResolution": "REGION" or "CITY".
YouTube or Shopping interest: "searchProperty": "youtube" / "shopping".
Brand tracking: your brand plus competitors on one scale, with a steady anchorTerm when you track more than five.

Get it

Workflow JSON and setup guide: https://github.com/ichkifokkus/data-recipes/tree/main/3-weekly-trend-report
Actor: https://apify.com/fast_data_asap/google-trends-scraper

If you track something interesting with it, tell me in the comments. I'm curious which keywords people watch.

A daily competitor news digest in Slack for ~$1.50 a month (n8n + Google News)

Fast Data — Tue, 20 Oct 2026 11:44:14 +0000

Google Alerts still exists, but it has been unreliable for years: late, incomplete, and stuck in your inbox. What I actually wanted was simpler: every morning, one Slack message with what was published about our brand and our competitors in the last 24 hours, with links to the original articles, and nothing I have already seen.

This is the n8n workflow that does it. It has five nodes, takes about five minutes to set up and costs around $1.50 a month.

Disclosure: the news data comes from the Google News Scraper on Apify, which I built. Prices and limits are below.

The result

News digest 2026-10-20: 19 new article(s)

OpenAI (10)
- OpenAI races to raise $30 billion at $1.4 trillion valuation ahead of Anthropic IPO (CTech)
- EXCLUSIVE: OpenAI seeks to accelerate fundraising ahead of Anthropic IPO, sources say (Reuters)
- Lawsuit alleges OpenAI 'stole' children's user data (Mashable)
...

Anthropic (9)
- Former Google CEO Schmidt owns 1% stake in Anthropic, Bloomberg reports (Reuters)
- Anthropic is AI trade's last big hope for a major IPO this year (CNBC)
...

That is real output from a test run, with "OpenAI" and "Anthropic" as example queries. In Slack every headline is a link to the publisher's page, not to a Google redirect.

The workflow

Schedule (daily 7:30)
  → HTTP Request: Google News Scraper
  → Remove Duplicates (previous executions, by URL)
  → Code: build digest
  → Slack (+ optional e-mail)

1. Search Google News

An HTTP Request node calls the Actor through Apify's synchronous endpoint (run-sync-get-dataset-items), which runs it and returns the results in one request:

{
  "queries": ["\"OpenAI\"", "\"Anthropic\""],
  "edition": "US:en",
  "timeRange": "1d",
  "maxArticlesPerSource": 10,
  "includeFullText": false
}

A few details that matter for monitoring:

Quotes make a query an exact phrase. Without them, Acme Corp also matches every article that mentions "acme" and "corp" separately.
Google News operators work: "Acme" -jobs, intitle:acme, site:techcrunch.com.
edition sets country and language; 18 editions are supported (US, UK, Germany, France, Japan...).
Every article comes back with title, source, publishedAt and the original publisher URL. Google News RSS only gives you news.google.com/rss/articles/... redirect links; the Actor decodes them. That matters for the next step.

Authentication is an n8n Header Auth credential: Authorization: Bearer <Apify token>.

2. Only new articles

The 1d window overlaps from day to day, and big stories stay in the results for a while. The Remove Duplicates node in "Remove items processed in previous executions" mode, keyed on {{ $json.url }}, remembers every URL it has passed through and drops repeats. Because the URLs are the real publisher URLs, the key is stable.

Two caveats:

The first run has an empty history, so it posts everything.
The node keeps a limited history (I set 50,000 keys). If it ever fills up, n8n stops with "exceeds the maximum history size"; raise the limit or clear the history.

3. Build one message

I don't want 20 Slack notifications. A Code node groups the articles by query, sorts each group newest first, caps it at 10 and builds Slack mrkdwn plus an HTML version for e-mail:

const groups = {};
for (const a of articles) {
  const key = String(a.query || a.topic || 'Other').replace(/"/g, '');
  (groups[key] = groups[key] || []).push(a);
}
// ... `- <${a.url}|${title}> (${source})` per article

If there are no new articles the node returns an empty array, so no message is sent. Quiet days stay quiet.

4. Slack and e-mail

A standard Slack node posts {{ $json.text }} to #news-alerts. There is also a disabled Send Email node wired to the same output; enable it and add SMTP credentials to get the digest by mail as well.

Cost

The Actor charges $0.0025 per article (plus $0.0025 per article if you turn on full-text extraction and text was found). With two queries and a cap of 10 articles each, the worst case is 20 articles a day, about $1.50 a month. Quiet brands cost less. Note that duplicates are dropped in n8n after the run, so they are still paid for; set maxArticlesPerSource near the number of articles you realistically expect per day.

Apify's free plan includes $5 per month, enough for this and a few more workflows.

Ideas

Summaries and sentiment: set includeFullText: true and add an LLM step: "Summarise in two sentences and rate the sentiment towards our brand."
Tiered alerts: a Filter node that pings @channel only when source is Reuters, Bloomberg or the FT.
Industry radar: add "topics": ["TECHNOLOGY"] to get the top headlines of whole sections.
Several markets: duplicate the HTTP node with "edition": "DE:de" and merge.
Archive: append every new article to Google Sheets for monthly reporting.

Get it

Workflow JSON and setup guide: https://github.com/ichkifokkus/data-recipes/tree/main/2-daily-news-alert
Actor: https://apify.com/fast_data_asap/google-news-scraper

Questions or ideas for the next recipe? Leave a comment.

Summarise any YouTube channel into Google Sheets with n8n (free workflow)

Fast Data — Tue, 20 Oct 2026 09:40:30 +0000

I follow more YouTube channels than I have time to watch. Some of them I only need to know about: what did a competitor announce, which tools did a creator recommend, what topic is a channel pushing this month. So I built a small n8n workflow that does the watching for me: every Monday it takes the newest videos of a channel, summarises them with an LLM and adds one row per video to a Google Sheet.

This post walks through the workflow. You can import it as-is; the JSON is linked at the end.

Disclosure: the transcripts come from the YouTube Transcript Scraper on Apify, which I built. I'll be clear about what it costs and where its limits are.

What you end up with

A sheet with one row per new video:

date	channel	title	url	minutes	words	summary
2026-10-20	@Fireship	The runtime wars are over... and Node won	youtube.com/watch?v=l3L_lETiSzc	6	1155	TL;DR + 3-5 key points + a quote

After a few weeks you have a searchable archive of everything the channel said, which is far easier to skim than a list of video titles.

The workflow

Seven nodes, all built in:

Schedule Trigger: every Monday, 7:00.
HTTP Request: runs the transcript Actor and waits for the result.
Filter: keeps videos that actually have a transcript.
Remove Duplicates: mode "remove items processed in previous executions", keyed on videoId. This is the piece that makes the workflow idempotent: a video is summarised once, even if it is still among the newest videos next week.
Basic LLM Chain with an OpenAI Chat Model (swap in Anthropic, Gemini or Ollama if you prefer).
Edit Fields: picks the columns.
Google Sheets: append row.

Getting the transcripts

The HTTP Request node calls Apify's synchronous run endpoint:

POST https://api.apify.com/v2/acts/fast_data_asap~youtube-transcript-scraper/run-sync-get-dataset-items
Authorization: Bearer <your Apify token>

with this body:

{
  "startUrls": ["https://www.youtube.com/@Fireship/videos"],
  "maxVideosPerSource": 3,
  "languages": ["en"],
  "includeSegments": false
}

The endpoint starts the Actor, waits until it is done and returns the dataset as a JSON array. n8n turns every element into an item, so the rest of the workflow simply works on "one item per video".

A channel URL is enough: the Actor resolves the channel's video list, takes the newest maxVideosPerSource videos and returns for each one title, url, durationSeconds, wordCount, a status and the full text. I switch off timestamped segments here because the summary only needs plain text.

For the token, I use an n8n Header Auth credential (Authorization / Bearer <token>) instead of putting the token in the URL. Credentials are encrypted in n8n; the URL ends up in execution logs.

Why the HTTP Request node and not the Apify node? There is an Apify integration for n8n and it works. I went with HTTP Request because it runs on every n8n instance without installing anything, and you can see exactly what is being sent.

The prompt

Summarize this YouTube video for a busy reader.

Title: {{ $json.title }}

Write:
1. A one-sentence TL;DR.
2. Three to five key points as a bulleted list.
3. One notable quote from the transcript, if there is one.

Plain text, no headings. Transcript:
{{ $json.text.slice(0, 60000) }}

The slice(0, 60000) is a safety net: about an hour of speech. Without it, a three-hour podcast episode would quietly cost ten times more than the rest of the week combined.

What it costs

Transcripts: $0.002 per video that has a transcript. Videos without subtitles come back with a status like transcripts_disabled and are not charged.
As shipped (3 newest videos per week): about $0.006 per week on the Apify side.
Backfilling a whole channel once, say 100 videos: $0.20.
LLM: a 10-minute video is roughly 2,000 input tokens, so with a small model you are looking at fractions of a cent per video.

Apify's free plan includes $5 of usage per month, which is 2,500 transcripts, so you can run this for a long time without paying anything.

Things I learned building it

Deduplicate after filtering, not before. If a video has no transcript yet (auto-captions sometimes appear a few hours after upload), you want next week's run to try again. Filtering first means only videos that were really summarised are remembered.
Keep runs small. The synchronous endpoint waits up to 300 seconds. For a weekly job that is plenty; for a one-time backfill of hundreds of videos, run the Actor directly in Apify and import the dataset.
Log the source. For channel inputs the workflow writes the channel URL you put in (source) into the channel column, so rows from several channels stay easy to filter.

Variations

Several channels: add more URLs to startUrls.
Topic monitoring: replace startUrls with "searchQueries": ["n8n tutorial"].
Notion instead of Sheets: replace the last node with Notion → create database page.
RAG: set "chunkSizeChars": 1500; every result then includes chunks with start and end times, ready for a vector store node. Citations can link straight to the timestamp in the video.
Repurposing: change the prompt to "write a LinkedIn post in my voice" and you have a content pipeline.

Get the workflow

Workflow JSON and step-by-step setup: https://github.com/ichkifokkus/data-recipes/tree/main/1-youtube-channel-ai-summaries
The Actor: https://apify.com/fast_data_asap/youtube-transcript-scraper

Import the JSON (Workflows → Import from File), add the three credentials (Apify, OpenAI, Google), change the channel URL and click Execute workflow. If you build something on top of it, I'd love to hear about it in the comments.

Transcripts belong to their creators. Use the summaries for research and personal knowledge management, and respect copyright and YouTube's terms.