DEV Community: Ayush Mishra

Compare Google Trends keywords in bulk without pytrends

Ayush Mishra — Sun, 01 Nov 2026 09:35:43 +0000

If you track search interest weekly, a pytrends script tends to stop with HTTP 429 sooner or later. This tutorial runs the same job with an Apify Actor I built, Google Trends Scraper, and puts the result in a spreadsheet. Disclosure: the Actor is mine and paid per keyword.

What you get

For every keyword, one row with interest over time, interest by region and top and rising related queries. Up to five keywords are compared on one 0-100 scale, the way Google Trends compares them. The values are relative interest, never search volume.

Step 1: Create a free Apify account

Step 2: Enter keywords

Put 2 to 5 keywords you want to compare in keywords, for example pickleball and padel. Pick geo (US, GB, or empty for worldwide) and timeRange (default today 12-m). Keep related terms in the same group of five if you want to compare them: each group of five has its own scale.

Step 3: Run it

Click Start. The default two-keyword run costs $0.006 (two ok rows at $0.003). Set a maximum cost per run if you like; the run stops when it is reached.

Step 4: Read the rows

Each row has status: ok, no_data, partial or error. Only ok is charged. Useful fields:

comparedWith: the other keywords on the same scale.
peak and latest: the highest point and the most recent one.
regions: interest by region.
relatedRising: queries gaining interest ("Breakout" means a very large increase).

The README shows the row shape; the values there are a sample, not a real Google record.

Step 5: Schedule it

Schedule the Actor weekly and connect the dataset to Google Sheets, Make, Zapier or n8n.

Limits

Google can slow down or refuse requests. The Actor pauses between requests, refreshes its cookie once, then stops with an explanation row. Failed keywords are not charged. It runs on Apify Proxy datacenter only. Not affiliated with Google.

Search a YouTube channel's transcripts and get alerts for new uploads (Apify, no code)

Ayush Mishra — Sat, 31 Oct 2026 13:55:06 +0000

You want to know what a YouTube channel said about a topic, and hear about it when it says it again. This walkthrough uses the YouTube Transcript Scraper Actor, which I built. Disclosure: it is my own Actor, priced at $1.50 per 1,000 transcript hours on the Free and Starter plans (a video under an hour counts once).

Actor: https://apify.com/fulox/youtube-transcript-scraper

1. Try the default input

Open the Actor and click Start. It reads two public videos and costs about $0.003. Open the dataset: each video row has text, segments, chapters, quality and matches.

2. Preview a channel for free

Paste a channel into Videos, channels or playlists, for example @mkbhd, set Videos per channel to 20 and turn on List only. You get one free preview row per video with its length, caption languages and estimatedResults, the number of results a real run would charge. Nothing is downloaded or charged.

3. Search the transcripts

Turn List only off. Add search terms such as battery life, set formats to empty ([]) if you only want quotes, and turn on matchRows. Run. Each match row has the term, the second, a quote and a youtu.be/<id>?t=<seconds> link. Clicking it opens the video at that moment. Matching is case-insensitive text matching, not meaning-based. Matches are free; you pay for the transcripts delivered.

Here is a real match from the Stanford 2005 commencement address:

{ "term": "connecting the dots", "start": 55.85, "timestamp": "0:55",
  "url": "https://youtu.be/UF8uR6Z6KLc?t=55",
  "quote": "...The first story is about connecting the dots. I dropped out of Reed College..." }

4. Get only new uploads

Turn on Watch mode, give it a watchlistName, and optionally paste a Slack incoming-webhook URL. Open Schedules, create a daily schedule with this saved input. The first run delivers the existing videos (use publishedAfter such as 7 days to limit that); later runs deliver only new uploads, and Slack gets a message with the new videos and the top quotes only when something is new.

5. Use the output for AI

Set formats to chunks for RAG chunks with a stable id, start and end seconds, token estimate and deep link, or markdown for a document with front matter. Check quality.grade (A to D) before you embed.

What it cannot do

It reads existing captions: a video without captions is a free no_captions row, there is no audio transcription and no translation, and YouTube can change how it serves captions. Questions or bugs go to the Actor's Issues tab.

Track a competitor's hiring with Apify and Google Sheets

Ayush Mishra — Fri, 30 Oct 2026 15:32:04 +0000

Hiring is one of the clearest public signals of what a company plans to do. Here is how to watch a list of companies and get only the job postings that changed, using an Apify Actor I built: Job Postings API & Change Tracker. It reads Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Recruitee and Personio, and nothing else.

1. Add companies

Paste company domains (acme.com) or career-page links into boards, up to 100. The job board is detected for you, free. If detection misses, write the board yourself: greenhouse:vercel, ashby:linear, lever:spotify, smartrecruiters:Bosch, workable:mindvalley, recruitee:bunq, personio:acme. Give the list a watchlistName if you track several lists; each name keeps its own snapshots.

2. First run

Click Start. The first run lists every open posting (turn emitBaseline off to only record the starting point). Use titleIncludes, departments, locations or remoteOnly to list only the roles you care about. Each company also gets a type: board row with open roles, roles per function and a signal (surge, freeze, expanding, contracting, steady).

3. Later runs

Run it again, or schedule it daily or weekly. Now you get only changes:

type: posting with status new, closed or changed (with changedFields and previous)
type: board with newCount, closedCount, newFunctions, leadershipHires, techStack and open roles 7 and 30 days ago

A function hiring for the first time (newFunctions) or a leadership hire is usually the strongest signal for outreach. Function, seniority and tool tags come from fixed word lists, so use them to filter and count, not as exact facts.

4. Send it somewhere

Google Sheets: in the Actor's Integrations tab connect Google Sheets, then filter the type column to posting.
Slack: paste an incoming-webhook URL into slackWebhookUrl; a digest is posted only when something changed, and it is free. webhookUrl sends the same digest as JSON.
Clay or any HTTP tool: call the Actor's run-sync-get-dataset-items endpoint with body {"boards":["{{domain}}"],"emitBaseline":false} and read signal, summary and leadershipHires from the board row.

Cost and limits

$1.50 per 1,000 results; a quiet company costs $0.0015 a day. Domain detection, unreadable boards, invalid entries, the digest and alerts are free, and you can set a maximum cost per run. The default input lists the last 7 days' postings of three companies, about $0.02; with postedWithinDays cleared on a first run the same three list about 200 postings, about $0.30. Limits: not BambooHR, Workday, Teamtailor or LinkedIn; you see changes between your runs, not exact times; description edits are ignored.

Disclosure: I built this Actor.

Two AI chats, one game board, and a server that trusts neither

Ayush Mishra — Wed, 28 Oct 2026 19:06:44 +0000

Every game in Fyreflock was written for two browsers in lockstep, with no referee anywhere. That held up right until I let a language model take a seat, because a model reads everything it's handed, and the thing handing it over was now a server holding both halves of the board.

Some context. Fyreflock is a random text and video chat I run, with two-player games you can open against the stranger mid-conversation. It also has an MCP connector for Claude, ChatGPT and Claude Code (github.com/FuloxDev/fyreflock-claude, which holds the plugin and setup; the server code quoted below lives in the main app). So the person you're playing Connect 4 against might be in a browser tab, or typing "4" into their own Claude.

This is how the games survived that.

Lockstep games keep secrets by not sending them

Between two browsers, both sides run the same pure reducer from the same seed. A move crosses the WebRTC data channel and the receiving side runs it through one function before applying it:

// packages/shared/src/games/sync.ts (trimmed)
export async function ingestMove<S, M>(def: GameDef<S, M>, state: S, move: M, seat: Seat, env: MoveHashes) {
  if (!def.isLegal(state, move, seat)) return { ok: false, reason: 'ignored' };

  if (def.verifyIncoming) {
    const honest = await def.verifyIncoming(state, move, seat).catch(() => false);
    if (!honest) return { ok: false, reason: 'cheat' };
  }

  const next = def.reduce(state, move, seat);
  // ...plus a state-hash comparison that only means something between lockstep peers
  return { ok: true, state: next };
}

Secrets are handled by omission. In Rock Paper Scissors you send a hash of your throw first and the throw plus its salt later, and the other side checks the reveal against the hash. A Battleship fleet never leaves the device that placed it. Nobody needs a referee, because neither peer ever holds the other one's secret.

Then a model sits down

The connector lets an assistant play through tools: fyreflock_game_invite, fyreflock_game_move, fyreflock_game_board and a few more. The person says "4", the model calls the move tool, and the server applies it.

Which means one process now holds both seats. If it hands Claude the raw Would You Rather state, Claude knows the other person's pick before it asks you for yours. There's no clever attack in that. The model just reads the JSON.

So the server became the referee. GameSession owns the one true state per conversation, applies moves through the same ingestMove the browsers use, and gives each seat its own view and nothing else:

// apps/server/src/gamesession.ts
/** What this seat is allowed to know. Never the raw state. */
view(seat: Seat): { text: string; data: Record<string, unknown> } {
  const g = this.game as unknown as AgentGame<unknown, unknown>;
  return { text: g.render ? g.render(this.state, seat) : '', data: g.redact(this.state, seat) };
}

Games live in memory and die with the conversation. A restart can't leave a half-played board that nobody recalls starting, which I think is the correct way to lose data.

Here's one move from a text assistant:

sequenceDiagram
    participant P as Person A
    participant M as A's assistant
    participant S as Fyreflock server
    participant G as GameSession
    participant B as Person B
    P->>M: 4
    Note over M: Claude Code only, a hook checks the move is what P typed
    M->>S: fyreflock_game_move with move 4
    S->>S: screen the text, rate limit
    S->>G: play seat 0, input 4
    G->>G: parse, then ingestMove inside the queue
    G-->>S: ok, new state
    S->>B: game.moved, or game.state if B has a box
    S-->>M: text board and redacted state for seat 0, in an envelope
    M-->>P: the board

Redaction has to be per game

Nothing in my state shapes says which fields are private. Between browsers nothing had to, since a peer only ever received what the other peer chose to send. A generic redactor would have to guess, and guessing wrong here means telling somebody the answer.

So each text-playable game got its own. Would You Rather shows the whole idea:

// packages/shared/src/games/agent.ts
redact(s, seat) {
  const both = s.picks[0] !== null && s.picks[1] !== null;
  return {
    round: s.round + 1,
    your_pick: s.picks[seat] === null ? null : (s.picks[seat] as number) + 1,
    // Only once the card is face up. Before that it is the answer.
    their_pick: both ? (s.picks[other(seat)] as number) + 1 : null,
    agreed: s.agreed,
    done: s.done,
  };
},

Two Truths and a Lie hides the lie from the setter's own payload too. You obviously know which of your statements is false. Your model would also know, and it would happily repeat it into a conversation the other person is reading.

Pig was a fun one. Its dice come from the seed, so whoever holds the seed can read the next roll before deciding whether to hold. Between browsers that was harmless. Once the server rolls and the client only watches, the seed has to go:

// packages/shared/src/games/agent.ts
board: (s) => {
  const { seed: _seed, ...rest } = s;
  return rest;
},

Two more MCP details bit here. Hosts pass structuredContent to the model, so the redacted object is the only thing that ever goes in it, and the readable board goes in content. And that board gets wrapped in the same envelope as a chat line, because Two Truths statements and Word Chain words are text a stranger typed, which makes them a prompt injection channel with a game skin on it. For the same reason the 400-character move argument goes through the outbound screen like any message. 400 characters is plenty of room for a phone number or an API key.

The salt can't live in a transcript

Two Truths commits to which statement is false and reveals it after the guess, so a modified client can't pick whichever one it wasn't caught on. Between browsers each side keeps its own salt.

A model can't keep a secret from its own transcript. The salt would sit right next to the answer it's meant to hide. So the server keeps the salt, makes the commitment for the player, and produces the reveal when the game's phase asks for it. The hash check still runs and still rejects a reveal that doesn't match. Only the custody moved.

The lie itself arrives as its own tool argument, never inside the move text:

// apps/server/src/mcp/tools.ts
inputSchema: {
  conversation_id: z.string().min(1).optional(),
  move: z.string().min(1).max(400),
  // Two Truths only. A separate argument rather than part of the move text because
  // it must never travel back to the model, and anything inside `move` is echoed.
  lie_index: z.number().int().min(1).max(3).optional(),
  person_asked: personAsked,
},

Two assistants answer at once, every time

ingestMove is async. Two moves landing close together could both read the same state, both pass the checks against it, and both reduce from it, with the second quietly overwriting the first. With people clicking boards that's rare. With two models firing tool calls it's the normal case, since neither of them is waiting to watch a board redraw.

So every state change goes through a promise chain:

// apps/server/src/gamesession.ts
private serialise<T>(work: () => Promise<T>): Promise<T> {
  const run = this.queue.then(work);
  // Chained on the settled result so one rejection cannot wedge the queue.
  this.queue = run.then(() => undefined, () => undefined);
  return run;
}

The first version only routed play through it. The bot's turn and the Two Truths setter wrote this.state on their own, after their own awaits, while the queue's comment promised it protected the state. Good comment. Wrong code.

Then the chat box showed up and the model left the path

Later the connector grew an MCP Apps widget, a small chat box drawn inside the conversation. Hosts unload that iframe whenever you look at another chat, and a WebRTC connection dies with it, so since commit ac0a5aa every match with a box in it is relayed through the server:

// apps/server/src/hub.ts
const relay = kindA === 'agent' || kindB === 'agent' || boxed(aId, kindA) || boxed(bId, kindB);

No data channel means the lockstep engine had nothing to ride. But the referee already existed, so it moved onto the box's WebSocket: five socket messages that mirror the tools, each ending in a game.state to every seat holding a box. In the box, the model never touches a move. It only gets a one-line note about the game, so "how's the game going?" still has an answer.

Four ways in, one referee:

flowchart LR
    T[Text assistant, no widget] -->|fyreflock_game_move| D
    W[Chat box on its WebSocket] -->|game.move| D
    F[Chat box whose host refused the socket] -->|fyreflock_app_game| D
    R[fyreflock.com tab in a relayed chat] -->|game.move| D
    D[GameDesk finds the session] --> Q[GameSession queue]
    Q --> I[ingestMove checks legality and commits, then reduces]
    I --> V[render and redact for a model]
    I --> X[board for a box]

The box draws your own move before the server answers, keyed on the state it was made from. The next board from the server is a new object, so the guess drops away by itself:

// apps/web/src/lib/relayGame.ts
const shown = live && local && local.base === live.state ? local.next : live?.state;
// ...
play: (move) => {
  if (def && live && shown && def.isLegal(shown, move, live.seat)) {
    setLocal({ base: live.state, next: def.reduce(shown, move, live.seat) });
  }
  send({ t: 'game.move', move });
},

And when the referee says no, the hub sends the true board straight after the refusal, so a box that drew the move early takes it back. The socket also got the rate limit the tool path already had: 60 moves per 10 seconds per person.

Why bother with the socket when a tool call works? The host probe I ran on 2026-10-19 measured both from inside the iframe:

On Claude and ChatGPT the socket answers in 270 to 283 ms and the host-proxied tool call takes 700 to 1116 ms. VS Code is the odd one out at about 100 ms, because its proxy runs locally. On loopback, a move reached the other box in 4 ms. Your own move costs nothing to see either way, thanks to the optimistic draw.

The box plays all 25 turn-based games, while the text tools offer 5, because only those have a board you can read as characters. The three realtime games need a data channel and stay on the website. The games with a secret play in the box exactly as they do in a browser, salt held on the client. One catch: that secret lives in the box instance, so if the host reloads the box mid-game, the salt is gone and the game ends with a note. A perfect-information game just gets its board handed back.

Twenty-one green tests and a game nobody could start

The first commit of all this had twenty-one passing tests. A review the same morning found that nothing about two-player games actually worked, and the review was right.

The invitation reached nobody. The function that drains a player's mailbox handled seven message types and silently threw away game.invite and game.moved, under a comment saying anything else was reported rather than dropped.

Two Truths was registered, listed and invitable, and its parser returned null for every input, so each move came back "illegal" with a hint telling the model to retry the one thing that could never work. The loser never saw the end, because the session was torn down inside the winner's call, so their next move was answered with "there is no game running". A person playing the computer while they waited, who then matched and accepted a real game, had their next move land on the bot's board while the stranger stared at an empty one.

And any third account could end two other people's game, because quitting checked that a game existed instead of checking that you were in it.

My favourite: the bot test asserted solo === true on a session it had just built with a null second seat. It tested that I can type.

The fix was 657 inserted lines across 10 files, including a new 263-line test file covering the layer where four of these were hiding: the mailbox, the board, move routing, and who's allowed to end a game. The units were fine. The thing between them was broken.

What I'd do differently

I'd mark private fields in the state types from day one. "Secret by not sending it" was a perfectly good rule for two peers, and it left me with zero information about what to hide once one process held everything. Every redactor was written by reading a reducer and asking "would this spoil the game?"

I'd also write the first test as a whole conversation: two accounts, an invite, an accept, some moves, a finish both sides can see. That's roughly what the 263-line file became, written after the review instead of before it.

The part I still can't enforce everywhere

The server stops illegal moves and hides secrets. What it can't do on its own is stop a model from playing a perfectly legal move its person never chose.

In Claude Code it's enforced. The plugin has a PreToolUse hook on the move tool that compares the move with what you typed, and the rule is equality. Its first rule was "is the sent text somewhere in what they typed", and a review found fifteen ways through that in one sitting. Typing 4 works, tell them 4 works, and column 4 please gets refused. On claude.ai and ChatGPT there are no hooks, so the rule is one sentence in the tool description: "they are playing, not you". The box sidesteps the whole thing by keeping the model out of the move path, and the text tools are still there for hosts that can't draw it.

So here's what I keep going back and forth on. If your MCP tool acts for one person against another, would you enforce the exact words and annoy everyone who types like a human, or let the model paraphrase and accept that some day it plays a move nobody picked?

Get a weekly list of your competitor's new Google ads

Ayush Mishra — Wed, 28 Oct 2026 18:54:21 +0000

Google's Ads Transparency Center shows every ad an advertiser runs, but one advertiser at a time and with no export. Here is how to get a weekly list of only the new ones with an Apify Actor I built: Google Ads Transparency Scraper.

1. Enter advertisers

In advertisers, type a name, a domain or a Google advertiser id (AR plus 20 digits), up to 50. Names and domains resolve to the advertiser with the most ads; the other matches are listed in the free advertiser row under alternatives. If the match is wrong, copy the id from there and run again.

2. First run

Set maxAdsPerAdvertiser (default 40, up to 2,000) and click Start. Each ad is one row: format, firstShown, lastShown, imageUrl or previewUrl, and adUrl, which opens the ad on the Transparency Center. The default run costs $0.056. With onlyNewSinceLastRun on, this first run is the baseline: all fetched ads are returned, flagged isNew.

3. Weekly runs

Turn on onlyNewSinceLastRun and schedule the Actor weekly. Now each run returns only ads first seen since your last run. The memory is a named key-value store in your own account; resetState starts over. A quiet week costs nothing.

4. Send it somewhere

In the Integrations tab connect Google Sheets, or use Make, Zapier or n8n, and filter rows to type = ad.

Limits

Google does not list ads newest first, and new-only compares the first maxAdsPerAdvertiser ads it returns, so for a large advertiser raise the limit. There are no region or date filters yet, and video ads come out as unknown format. The price is $1.40 per 1,000 ads; lookups, empty results and failed requests are free. Not affiliated with Google.