AI-Powered Vinted Alerts: MCP + Claude Automation

The best deals on Vinted disappear in minutes. By the time you see that underpriced Nike Dunk or vintage Levi's jacket, someone else already bought it. What if you had an AI watching Vinted 24/7 and alerting you the moment a deal appears?

With MCP + Claude + a simple automation script, you can build exactly that.

The Concept

Your alert system works like this:

1. Define what you're looking for (item, brand, size, max price)
2. A script periodically searches Vinted via the Vinted MCP Server or Apify Smart Scraper
3. New listings matching your criteria trigger an alert
4. Claude analyzes the listing and tells you if it's a good deal
5. You get a notification (email, Slack, Telegram, whatever you prefer)

Architecture

┌─────────────────────────────────────────┐
│           Alert Pipeline                 │
│                                         │
│  ┌──────────┐    ┌──────────────────┐   │
│  │ Scheduler │───►│ Vinted MCP/Apify │   │
│  │ (cron)    │    │ Search           │   │
│  └──────────┘    └───────┬──────────┘   │
│                          │              │
│                  ┌───────▼──────────┐   │
│                  │ New Listing       │   │
│                  │ Detection         │   │
│                  └───────┬──────────┘   │
│                          │              │
│                  ┌───────▼──────────┐   │
│                  │ Claude AI         │   │
│                  │ Deal Analysis     │   │
│                  └───────┬──────────┘   │
│                          │              │
│                  ┌───────▼──────────┐   │
│                  │ Notification      │   │
│                  │ (Slack/Email/TG)  │   │
│                  └──────────────────┘   │
└─────────────────────────────────────────┘

Method 1: Simple Script (Node.js)

The quickest approach — a script that runs every 15 minutes:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const ALERTS = [
  {
    name: 'Nike Dunk Low Size 42',
    search: 'Nike Dunk Low',
    filters: { size: '42', priceMax: 60 },
  },
  {
    name: 'Vintage Levi\'s Jacket',
    search: 'Levi\'s vintage jacket',
    filters: { priceMax: 40 },
  },
];

const seenIds = new Set();

async function checkAlerts() {
  for (const alert of ALERTS) {
    const run = await client.actor('kazkn/vinted-smart-scraper').call({
      search: alert.search,
      country: 'fr',
      maxItems: 20,
      sortBy: 'newest',
      ...alert.filters,
    });

    const { items } = await client.dataset(run.defaultDatasetId).listItems();

    for (const item of items) {
      if (!seenIds.has(item.id)) {
        seenIds.add(item.id);
        console.log(`🔔 NEW: ${alert.name}`);
        console.log(`   ${item.title} — €${item.price}`);
        console.log(`   ${item.url}`);
        await sendNotification(alert.name, item);
      }
    }
  }
}

async function sendNotification(alertName, item) {
  // Slack webhook example
  await fetch('https://hooks.slack.com/services/YOUR/WEBHOOK/URL', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: `🔔 *${alertName}*\n${item.title} — €${item.price}\n<${item.url}|View on Vinted>`,
    }),
  });
}

// Run every 15 minutes
setInterval(checkAlerts, 15 * 60 * 1000);
checkAlerts(); // Initial run

Method 2: Apify Scheduled Actors

For a more robust, hosted solution:

1. Go to Apify Vinted Smart Scraper
2. Configure your search parameters
3. Set up a Schedule (every 15 minutes)
4. Add a Webhook that triggers when new items are found
5. The webhook can call your Slack/Telegram/email endpoint

No server to maintain. Apify handles scheduling, proxies, and reliability.

Method 3: Claude + MCP for Smart Analysis

The basic alert tells you "new listing found." Claude makes it smarter:

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

async function analyzeWithClaude(item, marketData) {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 500,
    messages: [{
      role: 'user',
      content: `Analyze this Vinted listing as a potential deal:

        Item: ${item.title}
        Price: €${item.price}
        Condition: ${item.condition}
        Brand: ${item.brand}

        Market average for similar items: €${marketData.averagePrice}
        Lowest current listing: €${marketData.minPrice}

        Is this a good deal? Rate 1-10 and explain briefly.`
    }]
  });

  return response.content[0].text;
}

Now your alerts include AI analysis:

🔔 NEW DEAL: Nike Dunk Low Size 42
📦 Nike Dunk Low Panda - €38
📊 Market avg: €72 | This is 47% below average
🤖 Claude says: "9/10 deal. This is significantly underpriced. 
   Panda colorway in this size typically sells for €65-80. 
   Condition is 'very good'. Buy immediately if authentic."
🔗 vinted.fr/items/12345

Method 4: Telegram Bot

For mobile alerts, build a Telegram bot:

import TelegramBot from 'node-telegram-bot-api';

const bot = new TelegramBot('YOUR_BOT_TOKEN');
const CHAT_ID = 'YOUR_CHAT_ID';

async function sendTelegramAlert(alertName, item, analysis) {
  const message = [
    `🔔 *${alertName}*`,
    ``,
    `*${item.title}*`,
    `💰 €${item.price}`,
    `📦 ${item.condition}`,
    ``,
    `🤖 ${analysis}`,
    ``,
    `[View on Vinted](${item.url})`,
  ].join('\n');

  await bot.sendMessage(CHAT_ID, message, { parse_mode: 'Markdown' });
}

Alert Configuration Tips

Be Specific

// ❌ Too broad — you'll get 100 alerts/day
{ search: 'Nike', priceMax: 100 }

// ✅ Targeted — only relevant deals
{ search: 'Nike Dunk Low Panda', size: '42', priceMax: 60, condition: 'very good' }

Set Smart Price Thresholds

Don't just set a max price. Set it at 30-40% below market average for genuine deals:

const MARKET_AVG = 72; // Research this first using MCP
const DEAL_THRESHOLD = MARKET_AVG * 0.65; // 35% below average

Timing Matters

• Peak listing hours: 18:00-22:00 (evenings)
• Best deals: Often posted by people who don't know market value — random hours
• Check frequency: Every 15 minutes is a good balance between coverage and API usage

Multi-Country Alerts

The same item at different prices across countries:

const COUNTRIES = ['fr', 'de', 'nl', 'be'];

for (const country of COUNTRIES) {
  await checkAlerts(country);
}

Production Checklist

• [ ] Persistent storage for seen IDs (Redis, file, database)
• [ ] Error handling and retries
• [ ] Rate limit awareness
• [ ] Logging and monitoring
• [ ] Multiple notification channels
• [ ] Easy alert configuration (JSON file or database)
• [ ] Market price auto-refresh (weekly)

Cost Breakdown

Component	Cost
Vinted MCP Server (local)	Free
Apify Smart Scraper (free tier)	Free (100 runs/month)
Apify Smart Scraper (paid)	~$5/month for daily alerts
Telegram Bot	Free
Slack Webhook	Free
VPS for hosting script	~$5/month

Total: $0-10/month for a fully automated deal alert system.

FAQ

How fast will I get notified?

With 15-minute checks, you'll know about a new listing within 15 minutes of it being posted. For faster alerts (5 minutes), increase check frequency.

Can I run multiple alerts?

Yes, unlimited. Each alert is just a search configuration. The script checks them all in sequence.

Will this get my Vinted account banned?

The alerts use the Vinted Smart Scraper which accesses public data through Apify's managed infrastructure. Your Vinted account isn't involved.

Can I set alerts for specific sellers?

Yes. Modify the search to monitor a seller's new listings.

Does it work for all Vinted countries?

Yes. All Vinted markets are supported by both the npm package and the Apify version.

Never Miss a Deal Again

Manual browsing is over. Set up your alerts and let AI find the deals for you.

👉 Vinted MCP Server (npm)
👉 Vinted Smart Scraper (Apify)
👉 Vinted MCP on Apify
👉 GitHub

The best deal is the one you don't miss. 🔔