Forem: Arjun Vijay Prakash

I Finally Updated My 2-Year-Old Portfolio (Thanks to Antigravity)

Arjun Vijay Prakash — Wed, 21 Jan 2026 05:18:15 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Hey! I'm Arjun. I'm 16, from Lucknow, India. I build stuff on the web, write about tech, and I'm the CTO at Pilot.

I've shipped 20+ projects, have 34,000+ followers on DEV.to, and made $1,375 from technical writing. My research project got selected for INSEF Regional Fair too. This portfolio is basically proof that I actually do things.

Portfolio

How I Built It

The Problem

My portfolio was 2 years old. That's ancient in tech time. The projects were outdated. The design was ugly. It needed to go. Here's the old one if you want to see what I was working with.

The last commit before this rebuild? September 15, 2024. Then nothing until January 2, 2026. By January 7, the whole thing was done. 5 days. Here's the PR if you want to see the chaos:

66 commits
78 files changed
+15,591 lines added, -9,667 lines removed

Yeah. It was a lot.

The Fix

I used Antigravity, Google's AI IDE. It made the whole thing way easier than I expected.

Here's what I did:

Added new projects and achievements
Removed old stuff that didn't represent me anymore
Made the design look actually good with animations and dark mode
Cleaned up the clutter

The funny part? I did most of the data updates through Antigravity too. Like, my resume.tsx file that runs the whole site? I just told the AI what to change and it changed it. Same with the markdown files for my chatbot.

I barely typed anything. I just described what I wanted. True vibe coding. At this point, I'm not even sure if I can call myself a developer or just a really good prompter.

Tech Stack

Next.js 16 with App Router
TypeScript
Tailwind CSS and shadcn/ui
Framer Motion for animations
Google gemini-3-flash for the AI stuff
Vercel Postgres with pgvector for vector search
Deployed on Google Cloud Run

What I'm Most Proud Of

The RAG Chatbot

So after I finished updating everything, I asked Antigravity what else I should add.

It said: "RAG Chatbot."

I said: "Okay, let's do it."

Then Antigravity built it. And it actually works. Go try it on the portfolio.

I also used AI Studio to test prompts. I wanted the chatbot to sound like me, not some generic AI. That's also where I got my API key from.

You can ask the chatbot anything about me. My projects, my background, my skills. It gives real answers based on actual facts about me. No made up stuff.

Here's how it works:

I have markdown files with info about me in src/data/rag/
These get turned into vector embeddings using Google Gemini's text-embedding-004 model
When you ask a question, your question also becomes an embedding
The system finds the most similar chunks from my knowledge base using Postgres and pgvector
Those chunks plus your question go into gemini-3-flash
The model writes a response based on the real facts and streams it back

Other Cool Stuff

Smooth animations with Framer Motion
Dark mode that follows your system settings
A gallery for my certificates
Project cards with live links and GitHub repos
A guestbook where people can leave messages

This was fun. What could have taken weeks took way less time because Antigravity did the heavy lifting.

New year, new portfolio. Check it out:

Cloud Run: arjuncodess-portfolio-1081106407952.asia-south2.run.app
Main Site: arjuncodess.is-a.dev

I Built an AI-Powered Trend Analysis Tool Using the Virlo API (Here's How It Works)

Arjun Vijay Prakash — Thu, 08 Jan 2026 19:00:00 +0000

So here's the thing.

My friend was trying to grow his motivational page through trends. He kept telling me how he used to miss trends every time. By the time he noticed something was trending, it was already past its peak. He'd see creators hitting millions of views on a topic he was planning to cover, but by the time he posted, the moment had passed.

I started looking into how to catch trends earlier. The tools he was using just showed him what was already popular. They'd say "this hashtag has 2.3 million posts," but that didn't help him decide what to do next.

Should he use it? Was it too competitive already? Was there a better angle? The data never answered those questions.

The problem wasn't a lack of data. It was a lack of meaning.

I don't love theory. When something bothers me, I build things. So I decided to make something small that would actually help. Something that would turn trends into actionable next steps, rather than just showing numbers.

The gap between seeing trends and using them

Most tools that show you trending content do exactly that. They show you what's trending. That's it.

Hashtag analytics platforms tell you which tags have the most posts. Video dashboards show you view counts. Trend aggregators surface topics with big spikes.

All useful information, but they stop there.

Most dashboards are built for looking at data, not for making decisions with it. They show you rows and columns and filters, but they don't tell you what to do next.

Creators think differently. They want to know:

What should I post today?
What hashtags should I use?
How can I connect this trend to my niche?
When should I post for maximum reach?

I wanted something that behaved more like a thinking partner.

Something that would answer the question creators actually ask: what should I do next?

So I built the thing I wished existed

I called it ContentCompass. It helps you "navigate" trends. That's it.

I built it with Python and Streamlit. The reason is simple, it's fast!

Streamlit lets you build interactive web apps in Python without dealing with frontend frameworks. You write Python, you get a UI. For a side project, that's perfect. I could build something functional in hours instead of days or weeks.

Here's how it works. The app has four layers:

Awareness layer: The Trend Hub
- Shows what's happening right now across platforms
- Organises trends into three buckets: what's hottest, what's stable, and what's emerging
- That categorisation matters because different trends require different strategies

Context layer: The Video Vault
- Shows what's actually winning with real embedded videos
- You can watch them, see how they're structured, notice patterns
- Includes hashtags that made those videos successful

Planning layer: The Weekly Blueprint
- Takes trends and turns them into a five-day content plan
- Suggests specific video ideas, hooks, hashtag strategies, and posting times
- Instead of staring at a blank calendar, you have five starting points

Execution layer: The Brief Creator
- Turns any trend or idea into a shareable brief
- Includes why this trend matters, what format to use, which hashtags to choose, and when to post
- The kind of document you'd send to an editor or client

Each layer builds on the last.

I added AI here because turning patterns into plans requires actual thinking. You can't just automate trend detection, but you can automate the translation from "this is trending" to "here's how to use it."

I used Google's Gemini 3 Flash model for the content generation parts. Weekly plans and briefs. The stuff that requires reasoning, not just data lookup.

I also deliberately didn't automate some things:

Video selection
Hashtag strategy selection

Those are judgment calls. The app gives you options, but you make the choice. That restraint was intentional.

Too much automation feels like a black box. Too little feels like a data dump.

None of this works without good data underneath. This is where Virlo did the heavy lifting.

Where the data comes from

When I started building this, I had options. I could scrape social platforms directly, use multiple APIs and stitch them together, or build my own aggregation system.

All of those sounded painful. Scraping breaks constantly. Multiple APIs mean multiple integrations and multiple points of failure. Building my own aggregation system means maintaining infrastructure I don't want to maintain.

What I actually needed was reliable trend data across platforms. Trends that actually mean something. Hashtag data that's consistent. Video performance metrics I could trust.

That's what Virlo provides.

Finding Virlo's API changed how I built this project.

Virlo is the world's largest short-form data aggregator. They're analysing 1.5 million videos across TikTok, YouTube Shorts, and Instagram Reels. They track 268+ trends emerging every 24 hours. They're used by 1,700+ teams worldwide. This wasn't just another API. This was actual infrastructure.

Virlo gives you real data from real platforms. Their API connects to TikTok, YouTube, Instagram Reels, and more. You're not getting scraped data or estimates. You're getting actual trend signals that platforms are generating right now. Their data refreshes twice daily.

The trends endpoint powers the Trend Hub. The hashtags endpoint provides analytics and stats. The videos endpoint surfaces top-performing content.

The cross-platform aspect matters. Virlo aggregates across platforms like TikTok, YouTube Shorts and Instagram Reels, which helps avoid tunnel vision.

The API works well. Their API documentation is clear and straightforward. The API has credit costs. Trends cost more than hashtags. Videos cost more than niche lookups. That structure actually helped me design better because I couldn't just refresh data constantly. I had to cache intelligently and only fetch what users actually need.

What this means for builders: If you're working on anything that needs trend data or social analytics, Virlo is worth checking out.

What I learned building this

This wasn't about trends. Not really. It was about thinking clearly when everyone else is shouting numbers. Trends were just the excuse.

When you're early on something, whether it's a creator account or a side business, clarity is everything. But clarity doesn't come from more data. It comes from better ways of processing data.

ContentCompass is just one way. Not the only one. Probably not even the best one. But it's the one I needed.

If something feels fuzzy, don't wait for clarity. Build a lens. Even a small one.

Because.

Clarity often shows up after you ship.

ArjunCodess / ContentCompass

AI-powered trend intelligence and content planning tool for creators

ContentCompass - AI-Powered Trend Intelligence & Content Planning Platform

AI-powered trend intelligence and content planning tool for creators — discover trending content, optimize hashtag strategies, and generate actionable briefs using Gemini AI

📝 Table of Contents

🧐 About

ContentCompass is a creator-focused trend intelligence and content planning tool built with Python + Streamlit. It features two modes: Demo Mode (uses locally-generated JSON sample data, no API calls) and Live Mode (uses Virlo API with BYOK authentication).

The app helps creators discover trending content, optimize hashtag strategies, and generate actionable content briefs using Gemini AI. Users can explore trend hubs, analyze hashtag performance, scout content niches, browse top-performing videos, generate weekly content plans, and create professional briefs for their teams.

Key features include:

Trend Hub: Discover hottest, most stable, and emerging trends
Hashtag Lab: Generate strategic hashtag combinations (Safe…

View on GitHub

If you want to check it out, the code is on GitHub and there's a live demo on Streamlit Cloud.

Give it a try and see if it helps you turn trends into actual content ideas.

An Instagram Automation Tool That Turns Engagement into Sales

Arjun Vijay Prakash — Mon, 05 Jan 2026 07:54:51 +0000

This is a submission for the DEV's Worldwide Show and Tell Challenge Presented by Mux

What I Built

I built Pilot, an Instagram automation and deal management platform for creators, founders, and small teams who sell through Instagram.

Pilot turns comments and DMs into a structured sales workflow. Instead of manually replying, losing leads, or tracking deals in screenshots, everything runs through one system: automated replies, lead capture, contact management, and deal tracking, all connected to your Instagram account.

It's built for people who already have demand and want clarity, not hacks.

My Pitch Video

Demo

Live app: https://pilot-ops.vercel.app
App Repository: https://github.com/pilot-ops-crm/app
Website Repository: https://github.com/pilot-ops-crm/website

To test:

Sign up
Connect an Instagram business account
Create a simple automation like "comment YES → send DM"
Watch leads show up in the dashboard as contacts and deals

Another way to test it is to try putting a comment on this reel. Pilot will automatically reach out to you with the ebook described in the reel.

The Story Behind It

Instagram has quietly become a real sales channel. Creators close brand deals there. Small businesses sell products there. Coaches and founders run their entire pipeline through DMs.

But the tooling hasn't caught up.

Most people still manage everything manually. Replies are copy-pasted. Leads get buried. There's no visibility into who's serious and who's not.

Pilot exists to bring structure to that chaos.

Not to replace how people sell on Instagram, but to support it with systems that scale.

Once someone experiences Instagram with a real pipeline behind it, they don't go back.

Technical Highlights

Built with Next.js (App Router) and TypeScript
PostgreSQL + Drizzle ORM for structured data and deal tracking
Instagram API for account connection, comments, and DMs
Event-driven workflows using Inngest
AI-powered assistant built with Vercel AI SDK + Google AI
Fully typed forms, tables, and dashboards using shadcn/ui and TanStack Table
Deployed on Vercel, production-ready with Sentry monitoring

A key focus was personalisation.

The AI assistant works off the user's actual business data, contacts, and deal history, not generic prompts or canned replies.

By submitting this project, I confirm that my video adheres to Mux's terms of service: https://www.mux.com/terms

I Built a Zero-Miss Cancer Screening Model Using Routine Blood Tests

Arjun Vijay Prakash — Mon, 05 Jan 2026 07:50:30 +0000

This is a submission for the DEV's Worldwide Show and Tell Challenge Presented by Mux

What I Built

I developed the MEN2 Predictor, a machine learning screening tool for a rare hereditary cancer syndrome called MEN2, which is caused by mutations in the RET gene.

MEN2 often leads to medullary thyroid cancer if it's not caught early. In India, confirmation typically requires genetic testing, which costs around ₹20,000; as a result, many families delay or skip it.

This project explores whether routine blood markers and basic clinical features can act as a first screening layer before sequencing.

My Pitch Video

Demo

GitHub repository: https://github.com/ArjunCodess/men2-predictor
Live demo (Gradio / Hugging Face): https://huggingface.co/spaces/arjuncodess/men2-predictor

The demo lets you enter clinical features like calcitonin, CEA, age, and RET risk level and see the predicted cancer risk.

The Story Behind It

This started with a simple question: why does a life-saving diagnosis cost so much?

MEN2 is rare, but missing it has serious consequences. Most screening pipelines assume access to genetic sequencing, which isn't realistic in many settings. Meanwhile, clinicians already collect blood markers like calcitonin and CEA and track basic clinical features.

I wanted to see if that existing data could be used better.

I built this project by aggregating real patient data from published studies and testing whether a model could prioritise safety over performance optics. The key requirement was clear: missing a cancer case was unacceptable.

Technical Highlights

Trained on 152 real patients from 20 peer-reviewed studies across *24 RET variants
Implemented five different ML models for cross-validation and comparison
Focused on recall (sensitivity) instead of headline accuracy
Achieved 100% recall on real patient data, with zero documented cancers missed
Explicitly tested how synthetic data augmentation affects recall
End-to-end reproducible pipeline in Python with clear evaluation artefacts
Deployed an interactive demo using Gradio for transparency

The project intentionally favours interpretability and safety over complexity.

Participants

This project was not built in isolation, and I want to acknowledge the people who contributed meaningfully to it.

Harnoor Kaur
A class 12 student from my school. She is not on dev[dot]to.
Harnoor helped extensively with the research side of this project, including locating and compiling relevant peer-reviewed studies and assisting in sourcing and organising the clinical data used for model development.
Shashwat Misra
Mentor on this project.
Shashwat provided guidance throughout the development process, helped review the approach, and offered feedback on both the technical and research decisions that shaped the final pipeline.

Their support played an important role in turning this from an idea into a working, validated project.

By submitting this project, I confirm that my video adheres to Mux's terms of service: https://www.mux.com/terms

What If Your Chat History Could Tell You the Truth?

Arjun Vijay Prakash — Mon, 05 Jan 2026 07:49:27 +0000

This is a submission for the DEV's Worldwide Show and Tell Challenge Presented by Mux

What I Built

I built ChemistryCheck, an AI-powered tool that analyses chat exports from WhatsApp, Telegram, and Instagram to show what's actually happening in a conversation.

You upload a chat file, and it breaks down communication patterns: who initiates more, response delays, effort imbalance, message volume, word usage, emojis, and consistency over time.

The goal is simple: turn vague feelings into clear signals.

My Pitch Video

In the video, I explain the problem, why people miss red flags in chats, and how ChemistryCheck makes those patterns visible instead of emotional.

Demo

Live app: https://chemistrycheck.vercel.app
GitHub repo: https://github.com/ArjunCodess/chemistrycheck

Here's a sample chat analysis link: https://chemistrycheck.vercel.app/analysis/00d311b9-8619-4bae-8367-029aea4eeae6

How to try it yourself:

Sign up or log in
Upload a WhatsApp (.txt), Telegram (.json), or Instagram (.json) chat export

[for the judges, I have uploaded three of my chat exports here so they can download it and test the product right away]

Wait for the analysis to complete
View insights on the dashboard

The Story Behind It

This project came from personal experience.

When a conversation starts hurting, people often rename the pain. We call it "trauma bonding," "mixed signals," or "bad timing." But the red flags usually show up much earlier in the chat itself.

Uneven effort. Long gaps. One person is always initiating. Warm one day, cold the next.

I built ChemistryCheck because I kept rereading chats and still couldn't tell what was real. I wanted something that looked at patterns instead of excuses.

Technical Highlights

Built with Next.js 16, React 19, TypeScript and shadcn/ui
Custom parsers for WhatsApp, Telegram, and Instagram chat exports
PostgreSQL(Neon) + Drizzle ORM for structured analysis storage
Google Gemini for AI-generated insights and summaries
Visual dashboards using Recharts
Secure file uploads with Vercel Blob
Shareable, public analysis pages

The focus was on correctness, clarity, and explainability rather than flashy output.

By submitting this project, I confirm that my video adheres to Mux's terms of service: https://www.mux.com/terms

Anthropic Bought Bun: Here's What It Really Means for Us

Arjun Vijay Prakash — Wed, 03 Dec 2025 20:30:00 +0000

Anthropic didn't just buy a fast JavaScript runtime.

They bought the one missing piece that turns Claude Code from a clever tool into a full-stack engine for how software will be built in the next decade.

Yes, it's true. It's about control of the runtime layer at the exact moment AI agents begin writing, testing and shipping most of the world's code.

Let's get straight to the point.

TL;DR

Anthropic acquired Bun because Claude Code hit a billion dollars in revenue in six months but depended on a runtime they didn't control.

Bun needed Anthropic because despite 7 million monthly downloads, it made zero revenue.

This deal creates agent-native infrastructure where AI agents write code using a fast, single-binary runtime, fundamentally changing how software is built.

Anthropic now controls both the runtime and agent layer, giving them leverage over competitors like OpenAI, Cursor, and Vercel.

The risks include vendor lock-in, ecosystem fragmentation, and the closed-source nature of Claude Code.

Why Anthropic Needed Bun
Why Bun Needed Anthropic
The Bigger Shift
The Competition
Pros
Cons
Future of Software
Final Thoughts

Why Anthropic Needed Bun

Claude Code hit a billion dollars in run-rate revenue in six months. That growth created a bottleneck they couldn't ignore anymore: their entire product depended on a runtime they didn't own.

https://www.anthropic.com/news/anthropic-acquires-bun-as-claude-code-reaches-usd1b-milestone

Bun is fast, but that's not the real reason it matters. The real reason is this: AI agents need a runtime that doesn't slow them down or break under pressure.

Node is messy. It's slow to start. It depends on dozens of tools glued together.
Bun is one binary. It starts instantly. It runs tests fast. It bundles code tightly. It simplifies everything that slows agents down.

When an AI agent writes code, tests it, fixes it, retests it and repeats that loop a hundred times, a fast runtime compounds into hours saved. Claude Code depends on that.

Anthropic was already shipping Bun inside Claude Code as the runtime. That alone tells you how deep the dependency had become.

So yes, we can conclude that buying Bun was kind of like survival for Anthropic.

Why Bun Needed Anthropic

Bun was loved already.
It was fast. It was growing. It had 7 million downloads a month.
But it had one massive problem: it made no money.

The team had raised $26 million. They had a runway, yes, but no real business model.
They didn't want to run a cloud hosting service. They didn't want to build an enterprise plan. They didn't want to do the boring parts. They wanted to ship code.

https://bun.com/blog/bun-joins-anthropic

If Bun stayed independent, every year would become more stressful. More users. More features. More expectations.

Same revenue: zero.

Enterprise companies asked a fair question:
If we bet our org on Bun, will it even exist in five years?

Now the answer is yes. Anthropic pays the bills. Bun stays open source. The team keeps shipping. The existential risk disappears.

The Bigger Shift

Forget the corporate story. Think about the everyday workflow.

https://bun.com/blog/bun-joins-anthropic

1. Faster feedback loops

Claude Code runs on Bun. This means every time Claude generates or tests code, it gets answers faster. Developers feel that as instant scaffolding, quicker tests and shorter debugging cycles.

2. One runtime instead of ten tools

Modern JavaScript development is a mess of npm, node, webpack, jest and other tools.
Bun turns it into one command. AI agents love this because they hate complexity. Humans love this because complexity steals time.

3. Single-binary everything

Bun can bundle code into one executable. No Node installed. No juggling versions.
This solves the biggest pain point in enterprise environments and in agent sandboxes.

This is why Anthropic didn't build its CLI in Rust.

They didn't need to.

Bun made single-binary possible without the rewrite.

4. Node compatibility becomes optional

AI-generated code doesn't care about the past. It cares about what works best now.
If Bun becomes the default environment for Claude Code, developers slowly shift habits. They start writing for Bun first. Node second.

That shift matters.

The Competition

This deal hits every major player in the dev tools world.

OpenAI

They rewrote their CLI in Rust. That slowed the iteration.

Bun would've prevented that. Now they're behind on runtime speed and developer experience.

Cursor and Windsurf

Both depend on Claude models. Neither controls a runtime.
Anthropic now controls the runtime and the agent layer.

That's leverage. And some damn good leverage.

Replit

They own their cloud. Now Anthropic owns the runtime that powers AI-native dev flows. Replit will feel this pressure hard.

Vercel

Next.js is tied to Node. Bun is faster and more future-proof for AI agents.

If developers shift toward agent-first workflows, Vercel must adapt or lose relevance.

Pros

1. Bun becomes the default AI-native runtime

You won't need to think about Node versions or dependency hell.

Claude Code will generate code that runs in Bun out of the box.

2. Agent workflows take over early development

Scaffolding, wiring, testing, rewriting. These tasks shift entirely to Claude Code.

Humans focus on architecture, taste and decisions. Machines handle the repetitive parts.

3. More Bun-native tools and frameworks

Think "Next.js for agents."

New frameworks will rise around Bun because it's the fastest path for AI-assisted development.

4. Enterprises standardise on Bun for internal tools

It's a safer bet now. Anthropic backing removes the fear of collapse.

Cons

Even with all the optimism, there are real dangers.

1. Vendor trust

If Anthropic ever twists Bun toward Claude Code's needs at the cost of the wider community, trust won't just weaken; it will collapse instantly.

Developers don't wait around when a core tool feels captured. They fork, they migrate, and they warn everyone else.

That kind of fracture can split an ecosystem for years.

2. Ecosystem fragmentation

You could end up with:

Bun for AI-driven work
Node for legacy systems
Deno in niche spaces

Not the cleanest world, but a likely one.

3. Closed-source Claude Code

Bun is open, Claude Code is not.

That alone creates a structural imbalance where one half of the stack is transparent, and the other is locked away.

If Anthropic keeps the core agent tooling closed, suspicion will grow fast.

Developers hate black boxes, and pressure to open the chain will only intensify.

Maybe this won't matter much in the end, or maybe it will become a real problem. Honestly, it's impossible to say right now.

Future of Software

This deal marks the beginning of agent-native infrastructure.

The old world looked like this:

humans write code
tools help

The new world looks like this:

agents write code
humans guide, approve and design
the runtime must be fast, simple and predictable

Bun fits that world perfectly.

Bun removes friction. Together, they make software development faster than any team of humans alone.

This is the first clear sign that the runtime layer and the AI layer will merge.

Final Thoughts

At the end of the day, this move is just about momentum.

Anthropic grabbed the one piece of the stack that turns Claude Code from a cool tool into something that can reshape how software is built.

Bun gets stability.
Anthropic gets speed.
Developers get a cleaner path into an AI-native workflow.

If Anthropic handles this with care, everyone wins. If they don't, the community will push back hard. Simple as that.

And that's it for today, folks!

Thanks for reading!
Have a great day! Until next time :)

wrote this breakdown of the best proxy and scraper apis for 2025. simple, honest and actually useful. check it out if you want 👇

Arjun Vijay Prakash — Wed, 03 Dec 2025 08:30:44 +0000

Arjun Vijay Prakash

Dec 3 '25

11 Powerful Proxy & Web Scraper APIs You Should Use in 2025 🤯

#news #webdev #webscraping #productivity

Comments 2

6 min read

11 Powerful Proxy & Web Scraper APIs You Should Use in 2025 🤯

Arjun Vijay Prakash — Wed, 03 Dec 2025 08:30:00 +0000

Web scraping has changed completely in the last few years.

Anti-bot systems got smarter. Websites got heavier. And AI teams suddenly needed way more real-time, clean, structured data.

If you're building anything related to AI training, RAG pipelines, SEO monitoring, e-commerce analytics, or market research, the quality of your proxy + scraping stack matters more than your code.

This guide walks you through 11 services worth checking out in 2025.

[If you're short on time, jump to the TL;DR section directly.]

Each one solves a different problem. Each one fits a different scale.

Let's jump in!

ThorData
Bright Data
Oxylabs
Decodo (Smartproxy)
Zyte
Crawlbase
Apify
Webshare
SOAX
ScraperAPI
IPRoyal
TL;DR // How to Choose the Right Tool
Final Thoughts

1. ThorData: The All-in-One Web Data Stack (My Top Pick)

If you want something that "just works," this is the one to start with.

ThorData gives you 60M+ residential proxies, 120+ scraper APIs, and ready-to-use datasets, all packed into a clean interface that feels far less painful than most scraping tools.

Try it here:

Why it's strong:

60M+ residential IPs across 190+ countries
99.9% uptime and 99.7% success rate
120+ pre-built scraper APIs for Google, Amazon, YouTube, Zillow, and more
Real mobile IPs for tough targets
Structured JSON, CSV, XLSX output
No-code scraper builder
Ready-to-use datasets for AI training and RAG

Bonus: Mention Thordata when registering to get free residential proxies + 2000 SERP API calls.

A few extra perks:

💰 Use code THOR66 for 30% off your first purchase
🔗 Register with invitation code 0HSUJ23G or click here: https://dashboard.thordata.com/register?invitation_code=0HSUJ23G

If you're building AI apps or scraping at scale, start here. It's the fastest way to skip the annoying setup phase.

Check it out 🔥

2. Bright Data: Enterprise-Level Everything

Bright Data is basically the "AWS of web data." Huge infrastructure. Lots of control. Tons of features. If you're an enterprise team with compliance needs and a massive budget, this is your playground.

Where it excels:

150M+ proxies
Strong compliance framework
Web Unblocker handles CAPTCHAs automatically
High reliability, high throughput

Great for large companies, not small budgets.

Check it out 🔥

3. Oxylabs: AI-Smart Web Scraping

Oxylabs built an AI assistant called OxyCopilot that lets you describe what you want scraped in plain English. It figures out selectors and parsing logic for you.

Why it's good:

100M+ IPs
AI-powered scraping and parsing
Strong SERP and e-commerce scraping tools

Think of this as the "smart" version of Bright Data.

Check it out 🔥

4. Decodo (Smartproxy): Easy Scraper APIs

Smartproxy recently rebranded to Decodo, but the idea is the same: simple, clean scraping APIs that work without setup headaches.

Best parts:

125M+ IPs
Ready-made APIs for Google, Amazon, social media, and e-commerce
Friendly pricing
Very easy for beginners

Good if you want instant structured data.

Check it out 🔥

5. Zyte: Built for Complicated Websites

Zyte (old Scrapinghub) is still the most "serious" scraping company for enterprises. If you're dealing with complex, dynamic sites that break your crawlers every week, Zyte is worth it.

Why people use it:

AI Extraction that reads pages without selectors
Smart Proxy Manager
Compliance help from actual experts

It's more expensive but gives you peace of mind.

Check it out 🔥

6. Crawlbase: AI-Driven Proxy Gateway

Crawlbase is underrated. Simple API. Smart proxy rotation. AI-powered retry logic. Zero configuration headaches.

Highlights:

Mix of datacenter + residential
AI that detects blocks and retries automatically
Pay only for successful requests
Built-in cloud storage

Low stress, high success rate.

Check it out 🔥

7. Apify: Full Automation Cloud

Apify is not "just a scraper." It's basically a platform where you run scraper scripts in the cloud, schedule them, store results, and even automate browser tasks.

Why it's useful:

200+ ready-made scrapers ("actors")
Crawlee, great Node.js library
Built-in proxy rotation
Cloud scheduling and job monitoring

Perfect for developers who like full control.

Check it out 🔥

8. Webshare: Best Low-Budget Option

If you're new to scraping or building something small, Webshare is the easiest and cheapest way to get started.

What stands out:

Free tier with 10 proxies
Datacenter proxies starting at $2.99/month
Simple dashboard, zero friction
Good speeds for the price

Great for beginners or budget projects.

Check it out 🔥

9. SOAX: Extreme Geo Targeting

SOAX is the first tool I recommend to anyone who needs exact locations, ISP targeting, or mobile carrier-specific scraping.

What it's good at:

8.5M+ IPs
ASN targeting
Carrier targeting
Strong concurrency support

Useful for advanced experiments, ad verification, or regional testing.

Check it out 🔥

10. ScraperAPI: Plug-and-Play Simplicity

ScraperAPI is built for people who want scraping without learning scraping.

One endpoint. That's it.

Why it's popular:

Automatic proxy rotation
Built-in CAPTCHA solving
JavaScript rendering
Simple pricing
Super easy to integrate

If you want to get data fast without thinking, this is the one.

Check it out 🔥

11. IPRoyal: Best for the Lowest Prices

IPRoyal is the "cheapest-but-still-decent" provider. Great for people experimenting or running smaller-scale workflows.

What makes it appealing:

Residential proxies from $1.75/GB
Datacenter and ISP options
Good for multi-accounting
Simple dashboard

If cost is the priority, this is the one.

Check it out 🔥

TL;DR // How to Choose the Right Tool

No tool is "the best." It depends on what you're building.

Use Case	Best Options
AI and RAG pipelines	ThorData, Oxylabs
Enterprise-scale + compliance	Bright Data, Zyte
Zero-stress setup	ScraperAPI, Decodo
Custom scrapers	Apify, Crawlbase
Budget scraping	Webshare, IPRoyal
Precise geo-targeting	SOAX

Final Thoughts

2025 is the year scraping finally stopped being "a hacky developer thing" and became a real data infrastructure layer.

Every one of these tools has its own use case, and most offer trials, so test freely before you commit.

But if you want to start with something powerful, simple, and friendly for AI workflows… start with ThorData.

They give you an instant way to scrape at scale, 120+ APIs you don't have to build, and a huge residential proxy network to keep things stable.

If you want to try it, here's everything again:

ThorData Web Scraper
ThorData Residential Proxies
🎁 Free trial included
💰 Use code THOR66 for 30% off
🔗 Invitation code 0HSUJ23G or https://dashboard.thordata.com/register?invitation_code=0HSUJ23G

Thanks for reading!

Have a great day! Until next time :)

How I Built an AI-Powered SERP Tracker Using n8n & Bright Data

Arjun Vijay Prakash — Tue, 26 Aug 2025 18:30:00 +0000

This is a submission for the AI Agents Challenge powered by n8n and Bright Data

Checking where your site ranks for a keyword shouldn't feel like torture.

Yet every SEO still burns hours hopping between Google, Bing, Yahoo, DuckDuckGo, copy-pasting, scrolling, and guessing.

It's slow. It's messy. And it's killing momentum.

That's why I built RankSniper: a Telegram bot that does the grunt work in seconds and gives you clean, instant rankings across all major search engines.

What I Built

For this challenge, I built RankSniper, a Telegram bot designed to track keyword rankings across multiple search engines: Google, Bing, Yahoo, and DuckDuckGo.

The problem it solves is simple but crucial for digital marketers, SEO specialists, and webmasters: manually checking keyword positions for domains is tedious, inconsistent, and time-consuming.

RankSniper automates this process, allowing users to instantly find where their domain ranks for any keyword, either across all supported search engines or on a specific one.

With RankSniper, you no longer have to switch tabs, copy-paste keywords, or deal with browser restrictions.

The bot accepts natural language queries like "Check example.com for best shoes" or "How does vercel.com rank for vercel?"

This is powered by n8n's AI Agent node connected with Gemini 2.5 Flash, which parses free-form text into structured domain/keyword/engine instructions for the rest of the workflow.

Demo

You can interact with the bot on Telegram using this link.

Once started, you can run natural language commands like "Check example.com for best shoes" or "How does vercel.com rank for vercel?".

Some screenshots:

n8n Workflow

The full n8n workflow JSON is here for anyone interested in inspecting or reusing the setup.

Technical Implementation

RankSniper is built entirely within n8n, using a combination of code nodes, the AI Agent node, Bright Data's Verified Node, Airtable logging nodes and Telegram nodes for the full process.

Here's the breakdown of the configuration:

System Instructions: The bot operates as a query processor for domain-keyword pairs. It receives input from Telegram, interprets user queries via the AI Agent, and constructs the search engine URLs.
Model Choice: The system combines AI-driven natural language parsing (Gemini) with rule-based ranking extraction. The AI handles messy human input.
Memory: Each query is stateless, processed in real time. We do not persist data beyond the current request, but the structure can be extended to store historical rankings in a database for trend analysis.
Tools Used:
- n8n: Orchestrates the workflow, triggers on Telegram commands, and splits batch requests.
- AI Agent Node:
- Bright Data Verified Node: Handles the extraction of raw HTML from search engines, bypassing potential anti-bot restrictions and ensuring consistent data retrieval.
- Telegram Nodes: Sends start messages, help messages, and structured rank results back to the user.
- Airtable: Stores every query result (domain, keyword, rank, search engine, timestamp) to build a historical record of rankings.

Bright Data Verified Node

Bright Data's Verified Node is crucial in this workflow because direct scraping of search engines is often blocked or rate-limited.

The node allows RankSniper to:

Fetch search engine results reliably for Google, Bing, Yahoo, and DuckDuckGo.
Handle dynamic pages that require JavaScript rendering, especially DuckDuckGo and Yahoo.
Maintain speed and accuracy across multiple concurrent requests.

Without Bright Data, the bot would struggle to provide accurate rankings and would be prone to IP bans, resulting in unreliable output.

Airtable Logging

Airtable acts as the memory layer for RankSniper.
Each time a query is run, the results are written into an Airtable base with fields for domain, keyword, rank, engine, and timestamp.

This unlocks two things:

History tracking: users (or me) can analyse how rankings evolve over days/weeks instead of just checking one-off results.
Visual dashboards: Airtable views and charts allow quick trend analysis and competitor comparisons.

In the future, this foundation will also enable the triggering of alerts when a rank changes significantly.

I also kept the base public for inspection, check it out here.

Journey + Thoughts

Building RankSniper was an eye-opening journey in automation, search engine quirks, and parsing HTML structures reliably.

I started with Google only, but I quickly realised the potential of supporting multiple search engines to make the bot genuinely useful.

Initially, the bot required specific command formats. Adding the AI Agent transformed it into a natural language assistant.

And also, in V1, RankSniper only returned the current rank in Telegram. That was useful, but short-lived; the data vanished after every check.

By adding Airtable logging, I turned RankSniper from a "momentary rank checker" into a real tracking tool.

Now I (or any user) can look back at trends, visualise rank movements, and even set up alerts for major jumps or drops.

That felt like the missing piece.

The Quirks of Each Engine

Each engine posed unique challenges:

Google: Required filtering out internal Google links (webcache, /search?) and using regex to identify actual result URLs.
Bing: Needed extraction specifically from <cite> tags to avoid ads and irrelevant URLs.
Yahoo: Was tricky because result URLs are wrapped in multiple layers; fallback parsing with spans and regex was necessary.
DuckDuckGo: Needed careful handling of lightweight pages and ignoring redirect links.

The biggest challenge was standardising the extraction process while respecting each engine's quirks and ensuring accurate ranking calculations.

I implemented deduplication and normalisation to make sure results were consistent, regardless of variations in URL formatting or capitalisation.

Another key part was designing the Telegram interface.

Designing the Telegram Experience (Updated)

With the AI Agent integrated, RankSniper now understands plain-language queries from users, no rigid command formats required.

Users can type naturally, like:

"Check example.com for the best running shoes"
"How does vercel.com rank for vercel?"

The bot interprets the domain, keyword, and optional search engine automatically, so there's no need to remember specific commands or input orders.

This makes the experience intuitive, quick, and accessible even for users unfamiliar with technical SEO tools.

The AI Agent handles parsing, while the backend rule-based nodes extract ranking data reliably across all supported search engines.

Users get clean, instant results without worrying about syntax, formatting, or engine-specific quirks.

What I Took Away

Ultimately, this project solidified my understanding of search engine behaviours, n8n automation, and real-time query handling.

RankSniper demonstrates that with a carefully constructed workflow and the right tools, even complex multi-engine ranking checks can be automated efficiently for anyone in the SEO or digital marketing space.

🚀 Ready to stop wasting time on manual rank checks?
👉 Start using RankSniper on Telegram right now.

Drop a comment if there's a search engine you'd like to see added.
I'm building this to grow with the community.

Thanks for reading!

How I Built an Interactive Asteroid Dashboard with NASA's Data

Arjun Vijay Prakash — Tue, 26 Aug 2025 07:00:00 +0000

I was scrolling through Instagram the other day and stumbled on a reel.

The creator was listing "APIs you shouldn't miss," and the very first one? NASA.

I paused. NASA. Space. Data.
That was enough to pull me down a rabbit hole.

I dug into their NeoWs API and before I knew it, I had an idea: why not make a dashboard that tracks near-Earth asteroids, highlights risks, and makes sense of all this space data?

What started as a casual scrolling session turned into a full-on data science and analysis project.

Check out the project for yourself: https://astroscope.streamlit.app/
GitHub repository: https://github.com/ArjunCodess/astroscope

Here is a quick demo of the dashboard:

Some screenshots:

Breaking It Down

Step 1: Planning What I Wanted

Before writing a single line of code, I had to figure out what this project should actually do:

Fetch real asteroid data from NASA.
Show size, speed, and how close each asteroid comes to Earth.
Highlight which asteroids might be risky.
Visualise everything in charts and tables, not walls of JSON.
Make it smooth enough to work on both desktop and mobile.

That gave me a blueprint for tools, features, and project structure.

Step 2: Pulling Data from NASA's NeoWs API

NeoWs is powerful, but it has limits.
You can only fetch up to 7 days of data at a time.

So I had to:

Break the total range (like 30 days) into 7-day chunks.
Call the API for each chunk sequentially.
Save all the results locally so I wouldn't keep hammering NASA’s servers.

This was all handled in data_fetcher.py using Python's requests library.
I added retries and error handling because API calls fail, always.

Step 3: Cleaning Up NASA’s Raw Data

NASA sends massive JSON files, and most of it is noise.
I needed only the essentials:

ID, name, size
Approach date
Velocity
Miss distance
Hazard flag

I wrote data_processing.py to flatten everything into neat tables. pandas handled the heavy lifting.
I also converted units (like velocity into km/h) and saved the cleaned data as CSVs for faster loading later.

Step 4: Making Sense of It

Once the data was clean, I wanted to give it meaning. In analysis.py, I built a risk scoring system:

A risk score combining size, speed, and distance.
A threshold (0.6 by default) for high-risk asteroids.
Time series to show how risk changes over days.
Rankings for “closest approach” days.

This let me highlight outliers, giant rocks flying closer than usual.
pandas made all of this easy.

Step 5: Building the Dashboard

I used Streamlit because it lets you build web apps in Python without the headache of traditional frameworks.

Here’s what I added:

Date picker and risk slider for filtering.
GitHub-style heatmap showing average daily risk scores (brighter = scarier).
Top-10 closest approaches table with details.
Charts for asteroid sizes, speeds, and risk distributions.
Responsive layout for phones and laptops.

I also used plotly to make the graphs interactive and visually appealing.

Step 6: Configuration and Setup

I kept the app flexible with a .env file:

NASA_API_KEY=""
DATA_FETCH_DAYS=30
DATA_DIR="data"
API_CHUNK_SIZE=7
RISK_THRESHOLD=0.6

This keeps sensitive info like the API key safe and allows easy changes to the project's parameters.

Step 7: Putting Everything Together

When you run the app:

It checks if the data for the chosen days is already saved.
If not, it fetches it from NASA.
Then it processes and analyses the data.
Finally, it serves the dashboard.

I also made it possible to run individual steps separately for debugging and testing.

Here's a high-level flow of how the app works:

Final Thoughts

It's crazy how a 15-second reel led me to a full-fledged data project.

This dashboard is my little window to the space.
It's not perfect, but it works, it's extendable, and it's fun to explore.

If you're a coder or just a space nerd, try building your own.
Start small, play with real data, then push it further.
The universe is massive, unpredictable, and full of surprises.

Thanks for reading!

SaaS Pain Point Hunting with Runner H

Arjun Vijay Prakash — Mon, 16 Jun 2025 03:00:00 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

Introduction

Every builder hits that wall: "What should I build next?"

You scroll Twitter. You stalk indie hackers. You even ask ChatGPT for ideas, but nothing feels real. Nothing feels urgent.

That's the gap I wanted to close.

Instead of pulling ideas out of thin air, I made a system to go where the real problems are: inside user comments on Product Hunt.

Because let's be honest - launch pages lie. Comments don't.

People drop gold when they're frustrated. That's where the pain lives.
And pain = opportunity.

So I built a workflow with Runner H that finds those pain points fast, organises them clearly, and gives you actual SaaS ideas backed by real user frustration.

What I Built

I made a simple but powerful workflow to find real problems people face with new SaaS tools.

I used Runner H to build a step-by-step process that scrapes through Product Hunt comments - but only looks at the top launches of this year.

The goal is simple. To spot pain points, complaints, and problems that show up again and again - and use those to find new SaaS ideas.

Demo

Run link:

Surfer 2: The Next Generation of Cross-Platform Computer-Use Agents - H Company

We are a frontier AI research company that designs, builds, and deploys cost-efficient agentic AI systems directly into enterprises’ core workflows and processes.

hcompany.ai

Document it generated:

SaaS Pain Points from Product Hunt - Google Docs

docs.google.com

How I Used Runner H

I created a workflow inside Runner H that does this:

It opens a Google Doc and names it based on today's date.
It searches Product Hunt's top SaaS launches from this year.
It is included in each product's comments.
It pulls out only critical feedback, comments that discuss what's broken, missing, confusing, or annoying.
For each pain point, write down:

Product Name
Type of tool
The actual complaint or quote
A link to the comment
Upvotes on that comment (if there are any)
1. It keeps going until it has 5 real pain points from different products.
2. At the end, it writes a summary showing:
Common patterns across comments
What users are struggling with
2-3 solid product ideas you could build from this

All of it goes into a clean Google Doc.
No spreadsheets. No code. No scraping tools.
Just data, sorted by hand, with Runner H as the assistant.

Prompt

You are a SaaS Idea Hunter. Your job is to read through *Product Hunt's top SaaS launches of this year*, and collect *real user pain points* from the comment sections. These pain points must come from critical, constructive feedback, not vague complaints or shallow praise.

You must then *analyse each pain point* and explain why it could become the seed of a good SaaS idea.

*Workflow:*

1. Open a new Google Doc titled:
   `SaaS Pain Points from Product Hunt`

2. Visit Product Hunt and find the *top SaaS products launched this year*. Filter by date. URL: https://www.producthunt.com/leaderboard/yearly/2025

3. For each product, go through all user comments and reviews.

4. Extract only comments that include clear *negative feedback* or *constructive criticism*. Skip low-effort, generic, or praise-only comments.

5. For every useful pain point you find, add it to the Doc as a bullet point in this format:

   - *Product Name:*
   - *Category (if known):*
   - *Pain Point (exact excerpt or a clean summary):*
   - *Link to the original comment:*
   - *Upvotes on the comment (if visible):*
   - *Why this is a solid SaaS idea (your reasoning):*

6. Repeat for at least *5 unique, useful* pain points from different products.

7. After all bullets, write a short *300-word summary* including:

   - Common themes or recurring issues across comments
   - What this says about where SaaS still sucks
   - 2–3 idea directions founders could explore

*Rules:*

- Use *Google Docs only*. No spreadsheets, no tools, no automation.
- Focus on being *data-heavy, insight-rich*.
- Don't overgeneralize. Stay specific.
- Your final output should be so useful that a founder could open it and start building tomorrow.

Use Case & Impact

If you're a builder, solo founder, or just someone with an itch to launch something new, this helps you find ideas that already have demand.

Instead of building something no one needs, you're finding:

What annoys real users
What current tools fail to do
What people are asking for, over and over again

This saves time. It sharpens your focus.
And it gives you a real chance to build something useful, not just another clone.

Imagine finding your next startup idea just by reading through what real people hate about a tool like Notion, Linear, or some new AI tool. This is that - but on autopilot.

Final Thoughts

This isn't magic. It's just smart, focused listening.

Too many founders chase trends. This workflow helps you chase the truth.

What people really need.
What tools actually suck.
What gaps are wide open.

You don't need a billion-dollar vision.
You need one sharp idea that solves one sharp pain.
This workflow gives you 5.

Run it. Read the doc. Sit with the pain.
And then? Build the fix.
You'll be 10 steps ahead of everyone still guessing.

Let's stop building noise. Let's build what matters.

Thanks for reading.
Made with ❤️ by @arjuncodess for the DEV.to Runner H "AI Agent Prompting" Challenge.

Introducing the Storyblok MCP Server: Talk to Your CMS

Arjun Vijay Prakash — Sat, 14 Jun 2025 09:30:00 +0000

This is a submission for the Storyblok Challenge

Introduction

I've always hated boring dashboards.

Clicking around. Waiting for things to load.
Forgetting where that one damn setting was.
It's slow. It's clunky. And it kills flow.

So I built something better.

A MCP server that lets AI talk to your Storyblok CMS directly - with no dashboards, no clicks, no code. Just plain language.

Tell the AI what to do - "Translate this story," "Upload these assets," "Rollback that release" - and it just does it.

This is not a toy. It's not a wrapper. It's a fully working MCP server made for people who want to ship faster and think less.

Let me walk you through how I built it, what it can do, and why it matters.

🧠 Introduction
🚀 What I Built
🎥 Demo
🛠 Tech Stack
🧩 How I Used Storyblok
🤖 AI Integration
📓 Learnings and Takeaways
🏁 Final Thoughts

What I Built

Storyblok MCP Server serves as a bridge between Storyblok and Claude AI-based tools, such as Cursor.

It lets you manage your CMS through plain language - no dashboards, no manual clicks, no code changes.

It currently has 42 tools (4 of them being AI tools) covering stories, assets, releases, tags, components, and more.

Just tell the AI what you want:

"Please generate the metadata for this story: 123456789"
"Please translate this story to Spanish: 123456789"
"Please get all of my assets and generate alt texts for each one of them"
"Please create a tag named Test and add it to story: 123456789"
"Please auto-tag this story: 123456789"

...and it does it, instantly.

This isn't just a wrapper over Storyblok's API - it's a fully featured, extensible MCP server that lets any compatible AI tool reason about your content structure, fetch and edit stories, manage assets, roll back versions, and more.

My goal was to make managing a headless CMS feel less like dev work and more like magic.

Demo

Images

Code Repository:

ArjunCodess / storyblok-mcp

Connect AI tools to Storyblok instantly - use natural language to manage your CMS like magic.

Storyblok MCP Server

Connect AI tools to Storyblok instantly - use natural language to manage your CMS like magic.

Demo

Why This Project?

Built for the Storyblok Headless CMS Challenge on DEV.to.

The goal: push AI and Storyblok's power together, make something fresh and useful.

What is Storyblok?

Storyblok is a powerful headless CMS. API-first. Easy for devs and content creators to work together.

It's modular, super flexible, and fits with any frontend or workflow you want.

What's an MCP Server?

MCP = a protocol that connects AI, tools, and data.

The MCP server acts as a middleman, showing AI what it can do and what data it has.

This enables AI clients, such…

View on GitHub

Connected to Cursor

Watch the video: README

Tech Stack

Node.js + TypeScript - Core server and tool handling
pnpm - Fast, reliable package management
MCP TypeScript SDK - To implement the MCP protocol
Storyblok API - To control your CMS programmatically
Gemini 2.0 Flash via Vercel's AI SDK – To generate text for the 4 AI tools.

How I Used Storyblok

Storyblok is a great CMS platform that was the backbone of this entire experience.

Its powerful APIs, modular content approach, and management tokens gave me the flexibility to treat stories, assets, tags, releases, and components as first-class, programmable elements.

I exposed nearly every critical Storyblok capability as a callable AI tool, so the AI could:

Create and update stories
Manage tags, components, and releases
Upload assets and move them across folders
Query and restore past versions
Interact with slugs, folder structures, and datasources

Storyblok's API-first nature made this possible and a joy to build.

AI Integration

This project is built for both the Build Any Digital Experience With Storyblok and Awesome AI categories.

It uses the Model Context Protocol (MCP) to make Storyblok content accessible to local AI tools.

Once plugged into tools like Cursor, the AI can:

Understand what content exists in your space
Call functions like update_story, fetch_assets, create_release, etc.
Take natural commands like "Publish all stories in the 'June Campaign' folder" and convert them to precise API calls
Maintain context, handle rollbacks, and even search using fuzzy slugs or tags

Learnings and Takeaways

This wasn't easy. It was messy. It was slow.

I had never built an MCP server before.
Didn't even know what "MCP" stood for until I googled it five times.
Tried setting it up in Cursor for 2-3 hours straight. Failed every time. Lol.

And let me be honest, wiring that thing to Storyblok's API took me way longer than I want to admit.

Thankfully, this article by @anmolbaranwal saved me.
Without it, I'd have lost another 2 hours just understanding the basics:

Anmol Baranwal for Composio

Apr 22 '25

The guide to MCP I never had.

#programming #tutorial #mcp #opensource

254

Comments 15

22 min read

Then came the security part. Giving AI access to a CMS isn't a joke. Tokens, scopes, permissions - one mistake, and it's all open.

So instead of asking you to give me the keys... I made it so you give them directly to Cursor.
Cursor handles setup. Cursor stores the keys.
So if anything leaks, it's on them. Not you. Not me.
Might sound like an insane idea, but it's safer. Cleaner. Smarter.

Also, I built this with developers like me in mind.
No black boxes. Just code you can download, extend if you want, and plug into whatever stack you've got.

If you've ever used a messy integration like the other MCPs, you'll feel the difference here.

What I'm proud of:

A fully working AI-powered Storyblok CMS server, end-to-end.
A project that actually saves time.
Something that could be used by devs, marketers, creators, literally anyone using Storyblok as their CMS.
A great learning experience.

I built this because I believe the future of tooling is invisible, and AI should do more than answer questions.

It should build, edit, and manage EVERYTHING effectively.

This server helps make that future real.

Final Thoughts

Managing content shouldn't be painful. It shouldn't take 10 clicks to do 1 thing.
It should feel like magic. Fast. Clean. Invisible.

That's what this project tries to do.

If you're a dev working with Storyblok - or just someone tired of clicking around a CMS - this server is for you.

You can download it. Plug it into Cursor. Make it your own.
And if you want to see exactly how it works, every piece is explained in the README of the repo.

This is just the start.
I'm gonna keep improving it.
But for now, it works - and it works well.

Thanks for reading.

And if you build something cool on top of it, I'd love to see it.

Made with ❤️ by @arjuncodess for the DEV.to Storyblok Challenge.