Monitoring Pipeline

Fresh Source: docs.airtop.ai

Monitor web pages for specific conditions using Airtop's monitor method. Set a condition, configure check intervals, and get notified when the condition is met.

Architecture

Basic Monitoring

TypeScript

import Airtop from '@airtop/sdk';

const client = new Airtop({ apiKey: process.env.AIRTOP_API_KEY });

async function monitorPage() {
  const session = await client.sessions.create({
    configuration: { timeoutMinutes: 30 },
  });
  const sessionId = session.data.id;

  try {
    const window = await client.windows.create(sessionId, {
      url: 'https://example.com/product',
    });
    const windowId = window.data.windowId;

    // Monitor for a price drop
    const result = await client.windows.monitor(sessionId, windowId, {
      condition: 'The product price drops below $50',
      configuration: {
        intervalMs: 5000,    // Check every 5 seconds
        timeoutMs: 300000,   // Give up after 5 minutes
      },
    });

    if (result.data.conditionMet) {
      console.log('Condition met!', result.data.modelResponse);
    } else {
      console.log('Timed out waiting for condition');
    }
  } finally {
    await client.sessions.terminate(sessionId);
  }
}

Python

from airtop import Airtop

client = Airtop(api_key="your-api-key")

def monitor_page():
    session = client.sessions.create(
        configuration={"timeoutMinutes": 30}
    )
    session_id = session.data.id

    try:
        window = client.windows.create(
            session_id, url="https://example.com/product"
        )
        window_id = window.data.window_id

        # Monitor for a price drop
        result = client.windows.monitor(session_id, window_id,
            condition="The product price drops below $50",
            configuration={
                "intervalMs": 5000,     # Check every 5 seconds
                "timeoutMs": 300000,    # Give up after 5 minutes
            }
        )

        if result.data.condition_met:
            print(f"Condition met! {result.data.model_response}")
        else:
            print("Timed out waiting for condition")
    finally:
        client.sessions.terminate(session_id)

Monitor Configuration

Option	Type	Description
condition	string	Natural language condition to watch for
intervalMs	number	Milliseconds between checks (e.g., 5000 = 5s)
timeoutMs	number	Max milliseconds to wait before giving up

Use Cases

Stock Availability

await client.windows.monitor(sessionId, windowId, {
  condition: 'The "Add to Cart" button becomes available or the item shows as "In Stock"',
  configuration: { intervalMs: 10000, timeoutMs: 600000 },
});

Content Updates

await client.windows.monitor(sessionId, windowId, {
  condition: 'A new blog post appears on the page that was not there before',
  configuration: { intervalMs: 30000, timeoutMs: 3600000 },
});

Visual Changes

The monitor supports visual analysis, detecting changes in page appearance, not just text content.

await client.windows.monitor(sessionId, windowId, {
  condition: 'The status indicator changes from red to green',
  configuration: { intervalMs: 3000, timeoutMs: 120000 },
});

Best Practices

1. Set reasonable intervals — too frequent wastes credits, too infrequent misses changes
2. Always set a timeout — prevents runaway sessions
3. Use descriptive conditions — be specific about what you're watching for
4. Account for session timeout — ensure timeoutMinutes exceeds monitor timeoutMs
5. Combine with actions — after condition is met, use click/type to act on it