Automate weekly Steam competitor research with n8n, Gemini, and Notion

If you're a solo game developer, you probably mean to keep an eye on your Steam competitors - player counts, review trends, what people praise or complain about. And then you don't, because opening five store pages every week is boring.

I automated the whole thing with n8n, Steam's public APIs, Google Gemini, and Notion. No Steam API key required, and it runs on free tiers. Here's exactly how it works, so you can build your own, and if you'd rather skip the wiring, there's a ready-to-import pack at the end.

Here's a 2-minute demo of the finished workflow:
👉 https://www.loom.com/share/4edd443f3ae341088dfa025d55efcc34

What it does

Once a week (or on demand), for every competitor you list, it:

1. Pulls the current player count from Steam
2. Pulls review score + total reviews
3. Calculates a simple popularity score
4. Writes a short AI brief (what players care about, risks, one lesson for a solo dev)
5. Saves one Notion row per game

The flow looks like this:

Schedule Trigger
  → Competitor List
  → Loop Over Items
      → Get Player Count (Steam)
      → Get Reviews (Steam)
      → Calculate Score
      → AI Summary (Gemini)
      → Save to Notion

What you need

• n8n running locally (Docker is easiest)
• A Notion account + an internal integration
• A Google Gemini API key (free tier is fine to start)

No Steam API key, the endpoints we use are public.

Step 1 - Run n8n

docker volume create n8n_data

docker run -d --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

Open http://localhost:5678 and create your account.

Step 2 - The competitor list

Add a Code node that returns the games you want to track. The app_id is the number in a game's Steam store URL (store.steampowered.com/app/APP_ID/...):

const games = [
  { game_name: "PlateUp!", app_id: "1687950" },
  { game_name: "Unrailed!", app_id: "754150" },
  { game_name: "Overcooked! 2", app_id: "728880" },
];

return games.map(g => ({ json: g }));

Feed it into a Loop Over Items node so each game runs through the pipeline.

Step 3 - Current players (no API key)

An HTTP Request node:

GET https://api.steampowered.com/ISteamUserStats/GetNumberOfCurrentPlayers/v1/
  ?appid={{ $json.app_id }}
  &format=json

Returns {"response":{"player_count":1234,"result":1}}. A 404 means a bad App ID, double-check the number.

Step 4 - Reviews

Another HTTP Request node hits Steam's public review summary:

GET https://store.steampowered.com/appreviews/{{ $json.app_id }}
  ?json=1
  &language=english
  &num_per_page=0

You get query_summary.total_reviews and review_score_desc (e.g. "Very Positive").

Step 5 - A simple popularity score

A Code node combines players and reviews so a game with lots of players and lots of reviews ranks higher:

const game = $('Loop Over Items').item.json;
const players = ($('Get Player Count').item.json.response || {}).player_count || 0;
const review = $('Get Reviews').item.json.query_summary || {};
const total = review.total_reviews || 0;

const popularity = Math.round(players * Math.log10(total + 1));

return [{
  json: {
    game_name: game.game_name,
    app_id: game.app_id,
    player_count: players,
    review_score: review.review_score_desc || "No score",
    total_reviews: total,
    popularity_score: popularity,
    steam_link: `https://store.steampowered.com/app/${game.app_id}`,
  }
}];

Step 6 - AI brief with Gemini

Add the Google Gemini node and give it a focused prompt so you get solo-dev insight, not marketing fluff:

You are a game market analyst helping a solo indie developer.

Game: {{ $json.game_name }}
Current players: {{ $json.player_count }}
Review score: {{ $json.review_score }}
Total reviews: {{ $json.total_reviews }}

Write short markdown:
1. What players likely care about (3 bullets)
2. Possible complaints or risks (2 bullets)
3. One lesson a solo dev could learn from this game

Under 180 words. Be practical, not hype.

Step 7 - Save to Notion

Create a Notion database with these properties: Name (title), AI Summary (text), Steam App ID (text), Player Count (number), Review Score (text), Popularity Score (number), Steam Link (URL), Last Updated (date).

Create an internal integration at notion.so/my-integrations, connect it to the database, then map the fields in n8n's Notion node. The Gemini text lands in AI Summary.

Step 8 - Put it on a schedule

Add a Schedule Trigger (e.g. every 7 days), connect it to the Competitor List, and set the workflow Active. Now Notion updates itself while you build your game.

Gotchas

• 404 on player count → wrong App ID.
• Empty Notion rows → property names must match exactly.
• Duplicate rows each week → this version appends history; upsert-by-App-ID is a later enhancement.

Want the done-for-you version?

If you'd rather import a tested workflow than wire eight nodes, I packaged this with a setup guide, troubleshooting doc, the AI prompt, and example screenshots:

👉 https://shrisab.gumroad.com/l/indie-launch-ops/LAUNCH

Either way, automate the boring launch chores so you can spend the time making your game. Questions welcome in the comments.

Comments

[Sufi Dhungel]

I've been trying to use n8n as well, and your idea was really helpful. How long did it take you to build this?

[Shrisab Shrestha]

Thanks, glad it was helpful! Honestly the core workflow came together in an afternoon once I stopped overthinking it, the actual n8n part (the 8 nodes) is maybe 1-2 hours. What took longer was the fiddly bits: getting the Notion property names to match exactly, and finding correct Steam App IDs (a wrong ID just 404s).

If you're building your own, start with just the "Get Player Count" HTTP node for one game and confirm you get JSON back - once that works, the rest is just chaining nodes onto it.

What are you trying to build with n8n? Happy to help if you get stuck on a specific node.