---
title: "Internship posts checked by AI and alerts sent on WhatsApp"
kind: "Kit"
category: "Education"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/38d010b0-346b-46c8-bc03-938ea5d37e2f"
updated: "2026-11-12"
---

# Internship posts checked by AI and alerts sent on WhatsApp

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow for students who follow internship channels on Telegram. It splits each forwarded post into openings, reads the application pages and has AI keep the fitting ones. Those go to the numbers on your list.

Internship posts checked by AI and alerts sent on WhatsApp is an n8n workflow in the Education category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow reads internship posts that you forward to a Telegram bot. An AI model splits each post into separate openings. The workflow reads every application page, and a second AI model decides whether the opening suits students of the batch of 2027. A fitting opening is logged in a Google Sheet and a data table. If it has a deadline, it also lands in your calendar. A WhatsApp message then goes to every number on your list. Thirty nodes do the work.

### Who it suits

Students who follow many internship channels and miss good openings in the noise. It also suits a placement cell or a campus group that wants to alert its members. It is built for one profile, so another batch or another kind of role needs its prompts and checks changed. Contact only people who asked to hear from you.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Education | Students | Filter the flood of internship posts in channels | A student forwards a post that lists five openings and hears about the one that fits. |
| Education | Placement cells | Alert a campus group about new openings | A cell keeps the numbers of members who opted in and sends each fitting opening to them. |
| Recruiting | Campus groups | Keep a log of accepted and rejected openings | A group reads the two sheet tabs to see what was sent and why others were skipped. |
| Software | Developers | Study a workflow with two models, tools and a fallback | A developer swaps the WhatsApp step for a Telegram message. |

You need more n8n than usual: import a file, connect eight services and prepare a sheet and a data table. Nothing in the file states a setup time.

### Where to use it

Any n8n that can reach Telegram, the model providers and your WhatsApp sender will run it.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file and steps, and a place to run your own WhatsApp sender
- Another batch year: change 2027 in the prompt and in \`Pre-Check\`
- Another channel: swap \`Send Whatsapp Message\` for a Telegram or email node

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. The table lists everything to prepare first.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| Telegram | A bot made with @BotFather |
| Groq and Cerebras | One API key for each, for the two models and their fallbacks |
| Firecrawl | An API key, to read the application pages |
| SerpApi | An API key, for the check of the batch year |
| Google | A sheet with three tabs, a calendar and a Google account for both |
| n8n data table | One with the columns \`title\`, \`Company\_Name\`, \`Eligibilty\` and \`Application\_Link\` |
| WhatsApp | A sender of your own that takes a POST with the fields \`to\` and \`message\` |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add a Telegram credential and select it in `Telegram Trigger` and in `Resend failed message`.
3. Add a Groq credential and select it in `Splitter Main` and `Analyst Fallback`.
4. Add an OpenAI credential whose base URL is `https://api.cerebras.ai/v1` and whose key is your Cerebras key. Select it in `Splitter Fallback` and `Analyst Main`.
5. Add a Header Auth credential for Firecrawl, with the name `Authorization` and the value `Bearer`, a space and your key. Select it in `Firecrawl Scrape`.
6. Add a SerpApi credential and select it in `serpapi_request`.
7. Add a Google Sheets and a Google Calendar credential. Replace `<YOUR_GOOGLE_SHEET_ID>` in `Get Mobile Numbers`, `Append Valid` and `Append Rejected`, and `<YOUR_GOOGLE_CALENDAR_ID>` in `Add event reminder`.
8. Create the data table and replace `<YOUR_DATA_TABLE_ID>` in `check_duplicate`, `Check for duplicate valid` and `Insert row`.
9. In `Send Whatsapp Message`, replace `<YOUR_WHATSAPP_SEND_URL>` with the address of your sender.
10. In `Notify User`, pick a workflow of your own or delete the node.
11. Publish the workflow and forward one internship post to your bot.

### How to use it

Publish the workflow and forward internship posts to your bot. On the first runs, check the three places it writes to: the two sheet tabs and the data table. Change 2027 if your batch is another.

What to change for a different result

| To change | Where |
| --- | --- |
| The batch year and the role rules | The prompt of \`Analyst Agent\`, the code of \`Pre-Check\` and the name of \`For 2027?\` |
| The text of the alert | The template in the prompt of \`Analyst Agent\` |
| The people who get it | The rows of the \`Mobile Numbers\` tab |
| The deadline reminder | The times in \`Add event reminder\` |
| The models | The four chat model nodes |

### Example

You forward a post from an internship channel that lists three openings.

The splitter turns the post into three items, and the workflow reads each application page. Two pages name only earlier years and are rejected at once, with a row in the rejected tab. The third passes the analyst, has a deadline and is not in the data table yet. It gets a calendar event, every number on your list gets a message, and a row lands in the valid tab.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. An AI agent is a node that asks a model to decide and can call small tools, here a duplicate check and a web search. A fallback model takes over when the main one fails.

**For experts.** Two agents each run on a main model and a fallback model, and the analyst also has two tools.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Splitter Agent\` | An agent on \`Splitter Main\`, Groq \`openai/gpt-oss-20b\`, with \`Splitter Fallback\`, Cerebras \`gpt-oss-120b\` | It tries up to 5 times and sends an error to \`Notify User\` |
| \`Pre-Check\` | A Code node that cuts a page to 30,000 characters and rejects pages that name only earlier years | The year 2027 is written into its code |
| \`Analyst Agent\` | An agent on \`Analyst Main\`, Cerebras, with \`Analyst Fallback\`, Groq, and the tools \`check\_duplicate\` and \`serpapi\_request\` | \`Output Parser\` pulls its JSON out of the reply |
| \`Firecrawl Scrape\` | A POST to Firecrawl’s v2 scrape address with Header Auth | It retries, and a page that stays blocked leaves an empty result while the run goes on |
| \`Loop Over Items\` | A Split In Batches node that sends the message to one number at a time | When it finishes, \`Append Valid\` and \`Insert row\` run once for the opening |
| \`Add event reminder\` | A Google Calendar node that creates an event from 09:00 to 10:00 UTC on the deadline | The title has \`APPLY TODAY\` |

### Good to know

It needs services of your own, and it messages real people.

- Your batch: the year 2027 and technical roles are written into the prompts and into \`Pre-Check\`. Change them for any other reader
- WhatsApp: it needs a sender of your own. WhatsApp’s Business Messaging Policy, read on 12 November 2026, says you may contact people only when they gave you their number and agreed to hear from you. Keep the \`Mobile Numbers\` tab to people who asked
- Repairs: the original copy called its owner’s own Firecrawl, search and WhatsApp servers. Mindket’s copy calls Firecrawl’s v2 address and SerpApi directly, and the sender, sheet, table and calendar are placeholders
- Models: Groq shut down \`llama-3.3-70b-versatile\` on 16 August 2026, and Cerebras deprecated two models on 27 May 2026. Mindket’s copy uses \`openai/gpt-oss-120b\` on Groq and \`gpt-oss-120b\` on Cerebras, which those vendors’ pages name or list
- Your data: the text of each post goes to Groq and Cerebras, the application link goes to Firecrawl, and a search phrase may go to SerpApi. The phone numbers stay in your sheet and go only to your sender
- Scraping: read each application site’s terms. A blocked page leaves the Telegram text as the only input
- A missing piece: \`Notify User\` runs a workflow named Agent Error that is not in the file. Pick one of your own or delete the node
- Billing: each opening can cost up to two model calls with retries, one Firecrawl request and sometimes one SerpApi search
- Not run: Mindket did not run the workflow, the Firecrawl v2 call or the SerpApi call. It read the vendors’ pages and n8n’s source instead
- Credentials: the JSON holds none, and the ids in it are placeholders

## README

```markdown
# Internship posts checked by AI and alerts sent on WhatsApp

An n8n workflow for students who follow internship channels on Telegram. You forward a post to your bot. An AI model splits it into separate openings, the workflow reads each application page, and a second AI model decides whether the opening fits pre-final year students of the batch of 2027. A fitting one is logged, set as a calendar reminder for its deadline and sent as a WhatsApp message to the numbers on your list. Thirty nodes do the work.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 30 nodes and no sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

Mindket repaired and cleaned the copy:

- Three addresses pointed at the previous owner's own services: a Firecrawl server, a webhook that wrapped a search, and a WhatsApp sender. The Firecrawl step now calls `https://api.firecrawl.dev/v2/scrape` with a Header Auth credential. The search tool now calls SerpApi directly and asks it for only the title and snippet of each result. The WhatsApp address is the placeholder `<YOUR_WHATSAPP_SEND_URL>`.
- The previous owner's Google Sheet, data table and calendar ids are now `<YOUR_GOOGLE_SHEET_ID>`, `<YOUR_DATA_TABLE_ID>` and `<YOUR_GOOGLE_CALENDAR_ID>`. The three sheet tabs are picked by name: `Mobile Numbers`, `True Classification` and `False Classification`.
- The Groq model `llama-3.3-70b-versatile` was shut down on 16 August 2026. Groq's deprecations page, read on 12 November 2026, names `openai/gpt-oss-120b` as the replacement, so Mindket's copy uses it. The Groq model `openai/gpt-oss-20b` stays.
- The Cerebras models `llama3.1-8b` and `qwen-3-235b-a22b-instruct-2507` were deprecated on 27 May 2026. Cerebras names `gpt-oss-120b` as the replacement, and its model list shows it, so both Cerebras nodes now use it.
- The `Notify User` node ran a workflow named Agent Error from the previous owner's n8n. Its id is cleared, so pick a workflow of your own or delete the node.
- A stray column name, `Internship`, is gone from the data table's matching columns.
- The file had no settings. Mindket's copy uses the current execution order, `v1`.
- No credential is inside.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A Telegram bot made with @BotFather.
- A Groq API key, a Cerebras API key, a Firecrawl API key and a SerpApi API key.
- A Google Sheet with three tabs. `Mobile Numbers` has a column `Phone Number`, filled with digits that start with the country code and no plus sign. `True Classification` has `Timestamp`, `Telegram Message`, `Title`, `Company Name`, `Eligibility`, `Application Link` and `Status`. `False Classification` has `Timestamp`, `Telegram Message`, `Application Link` and `Rejection Reason`.
- An n8n data table with the columns `title`, `Company_Name`, `Eligibilty` and `Application_Link`. The third name is spelled that way in the file.
- A Google Calendar, and a Google account for the credentials.
- A WhatsApp sender of your own that accepts a POST with the fields `to` and `message`.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add a Telegram credential with your bot token. Select it in `Telegram Trigger` and in `Resend failed message`.
3. Add a Groq credential and select it in `Splitter Main` and `Analyst Fallback`.
4. Add an OpenAI credential whose base URL is `https://api.cerebras.ai/v1` and whose key is your Cerebras key. Select it in `Splitter Fallback` and `Analyst Main`.
5. Add a Header Auth credential for Firecrawl: the name `Authorization` and the value `Bearer` followed by a space and your key. Select it in `Firecrawl Scrape`.
6. Add a SerpApi credential and select it in `serpapi_request`.
7. Add a Google Sheets credential. In `Get Mobile Numbers`, `Append Valid` and `Append Rejected`, replace `<YOUR_GOOGLE_SHEET_ID>` with the id of your sheet.
8. Create the data table. In `check_duplicate`, `Check for duplicate valid` and `Insert row`, replace `<YOUR_DATA_TABLE_ID>` with its id.
9. Add a Google Calendar credential. In `Add event reminder`, replace `<YOUR_GOOGLE_CALENDAR_ID>` with your calendar's id.
10. In `Send Whatsapp Message`, replace `<YOUR_WHATSAPP_SEND_URL>` with the address of your sender.
11. In `Notify User`, pick a workflow of your own, or delete the node.
12. Change the year 2027 and the role rules in the prompt of `Analyst Agent`, in `Pre-Check` and in the name of `For 2027?`, if your batch is another.
13. Publish the workflow, forward one internship post to your bot and check each tab and the data table.

## How a run goes

1. `Telegram Trigger` starts a run for every message the bot receives.
2. `Text Guard` passes only a message whose text is longer than 20 characters.
3. `Splitter Agent` asks `Splitter Main` to split the text into a JSON list, one object for each opening, with `role`, `company`, `stipend`, `eligibility`, `description` and `apply_link`. It skips channel invitation links. It tries up to 5 times, and `Splitter Fallback` takes over if the main model fails. On an error, `Notify User` runs.
4. `JSON Format Fixer` removes a Markdown fence and parses the list into one item for each opening.
5. `Loop Over Each Link` takes one opening at a time.
6. `Firecrawl Scrape` fetches the application page as Markdown. If the site blocks it, the run goes on with an empty result.
7. `Pre-Check` keeps the first 30,000 characters of the page. When the page is shorter than 150 characters, it uses the Telegram text instead. It rejects an opening whose text names a year from 2020 to 2026 and not 2027. `For 2027?` sends the rest to the analyst and the rejected ones to `Merge`.
8. `Analyst Agent` decides, with `Analyst Main` and `Analyst Fallback`. Its prompt asks it to call `check_duplicate` first. It calls `serpapi_request` only when the batch year is missing. It answers with JSON: `send_whatsapp`, `reason`, `whatsapp_message` and `deadline`. On an error, `Wait` pauses for 2 minutes and `Resend failed message` sends the post's text back to you.
9. `Output Parser` pulls the JSON out of the reply. `Check for duplicate valid` looks up the link in the data table, and `Not Duplicate?` passes the opening only when `send_whatsapp` is true and no row has that link.
10. `Deadline Exists?` sends an opening with a deadline to `Add event reminder`, which creates a calendar event from 09:00 to 10:00 UTC on that day, titled with `APPLY TODAY`.
11. `Get Mobile Numbers` reads the numbers, and `Loop Over Items` sends the message to each one through `Send Whatsapp Message`.
12. `Append Valid` logs a row with the status `Pending`, and `Insert row` stores the opening in the data table. A rejected or repeated opening goes to `Append Rejected` with its reason. Then the loop moves to the next opening.

## Change the look

- The kind of internship: the prompt of `Analyst Agent`, the `Pre-Check` code and the name of `For 2027?`.
- The text of the alert: the template in the prompt of `Analyst Agent`.
- The channel: swap `Send Whatsapp Message` for a Telegram or email node.
- The deadline reminder: the times in `Add event reminder`, or delete the node.
- The models: the four chat model nodes.

## Good to know

- The workflow is built for one reader, a pre-final year student of the batch of 2027 who wants technical internships. Change the prompts and `Pre-Check` for anyone else.
- The Cerebras nodes are OpenAI Chat Model nodes pointed at Cerebras through the credential's base URL. Cerebras's own page, read on 12 November 2026, gives `https://api.cerebras.ai/v1` for that.
- WhatsApp's Business Messaging Policy, read on 12 November 2026, says you may contact people only when they gave you their number and agreed to hear from you. Keep the `Mobile Numbers` tab to people who asked, and treat the numbers as personal data.
- The text of each post goes to Groq and Cerebras, the application link goes to Firecrawl, and a search phrase may go to SerpApi. Do not forward private messages to the bot.
- Read the terms of each application site before you scrape it. A site that blocks the request leaves the Telegram text as the only input.
- Each opening costs up to two model calls with retries, one Firecrawl request and sometimes one SerpApi search.
- Mindket did not run the workflow, the Firecrawl v2 call or the SerpApi call. It read the vendors' pages and n8n's source instead, so check the first runs by hand.
- The JSON holds no credential.
```

## What is in it

3 files, 50 KB, downloaded as a zip.

```text
NOTICE.md  551 B
README.md  8 KB
workflow.json  41 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 24 steps, starting on a Telegram event
- AI: 2 steps call an AI model: Splitter Agent and Analyst Agent
- Sign-ins: Signs in to: Firecrawl, SerpApi, Google Sheets, Google Calendar, Telegram, Groq and OpenAI
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads 11 of its 13 step types. It does not read: AI Agent and Data Table

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/38d010b0-346b-46c8-bc03-938ea5d37e2f)
- [Its page on Mindket](https://mindket.com/p/38d010b0-346b-46c8-bc03-938ea5d37e2f)
