​
What is Intuned?

Intuned is a platform that enables developers to build and consume browser automations as code. Think of it as a way to turn complex browser interactions into simple, callable functions that can be executed reliably at scale.

​
Mental Model

Imagine you need to automate repetitive browser tasks - like extracting data from websites (scrapers), filling forms, or performing web-based complex multi-step workflows. Intuned provides the infrastructure to:
  1. Organize your automations into projects
  2. Define these automations as reusable parametrized functions
  3. Execute them reliably on demand or at a schedule
  4. Monitor their execution
  5. Scale from single executions to thousands of runs

​
Core Concepts

​
The Building Blocks

​
Projects: Organizing Your Automations

A Project in Intuned is a code project - a self-contained unit that groups related browser automation APIs together. Think of it as you would a software project: all the code, configurations, and resources needed for a specific automation goal. Common project patterns:
  • A single website scraper
  • An integration with a specific platform
  • A collection of APIs that work together on related tasks
Projects enable you to:
  • Organize code: Share helpers, utilities, and common logic between APIs
  • Deploy as a unit: All APIs in a project are deployed together
  • Configure settings: Authentication, replication/scale, and other settings are defined at the project level
Intuned projects can be built using Python and TypeScript. They can be developed in Intuned’s online IDE or using Intuned’s CLI. Project = Related APIs + Shared Code + Configuration → Deployable Unit

​
APIs: Defining Your Automations

At the heart of Intuned are browser automation APIs - these are functions that:
  • Accept a browser page object (via Playwright)
  • Take parameters to customize the execution
  • Return results
Think of them as regular functions, but instead of processing data, they interact with web browsers programmatically. API Function = Browser Page + Parameters → Result

​
The Execution Model

​
Runs: Executing Your Automations

When you execute a browser automation API, you create a Run. A Run represents a logical execution of your automation that may involve multiple Attempts until it succeeds or exhausts all configurable Attempt numbers. Every Run has:
  • Parameters: The inputs you provide
  • Options/Configs: To control the execution
  • Status: Current state (Pending → Success/Failed/Canceled)
  • Result: The data returned (if successful)
  • Attempts: One or more API executions to complete the logical operation (a retry after a failure as an example)

​
Attempts: Individual API Executions Within a Run

Browser automation is inherently complex. In many cases, a single Run may require multiple API executions - whether for retries after failures, handling transient issues, or other reasons. These individual executions are called Attempts. Each Run consists of one or more Attempts:
  • Each Attempt represents one complete execution of your API
  • Failed attempts can trigger automatic retries (up to your configured limit)
  • Every attempt is tracked separately with its own result, trace, and logs
  • Attempts may have pre-execution dependencies (like authentication validation)
This architecture provides fine-grained control and visibility while logically grouping related API executions together, making complex automation workflows manageable and traceable.

​
Execution Records and Debugging

Every execution in Intuned creates comprehensive records for debugging and monitoring: Run Records - Complete history of each API execution:
  • Input parameters used
  • Final status and result
  • All Attempt records
  • Execution timeline
  • Link to parent JobRun (if applicable)
  • Link to AuthSession (if applicable)
Attempt Records - Detailed information for each try:
  • Browser trace for visibility
  • Logs for debugging
  • Exact error details if failed
  • Timing information

​
Execution Patterns

​
Direct Execution

Perfect for:
  • On-demand automations
  • Testing and debugging
You trigger a single Run and get back results directly.

​
Jobs: Batch and Scheduled Execution

When you need to:
  • Run multiple APIs in bulk
  • Run automations on a schedule
Jobs are blueprints that define:
  • What automations to run
  • When to run them (schedule)
  • Where to send the results (sink)
Jobs are defined at a Project level. Each time a Job executes, it creates a JobRun - an instance of that Job’s execution. 
Job (Blueprint)
  └── JobRun (Execution Instance)
        └── Multiple Runs
              └── Multiple Attempts per Run

​
Advanced Job Features: Nested Scheduling

Intuned supports nested scheduling (available in Jobs only) where one API can dynamically expand the JobRun’s workload using extendPayload. How it works:
  1. An initial API Run (part of a JobRun) decides what else needs to be run as part of the same JobRun
  2. It calls extendPayload to add new payloads to the active running JobRun
  3. The JobRun automatically executes these newly added payloads
Common use case - Dynamic scraping: Imagine scraping an e-commerce site where you don’t know all the product pages you need to scrape:
  • First API: finds all product pages that need to be scraped
  • Uses extendPayload to expand the payload of the JobRun
  • Extended APIs: Runs and extracts each product details from product pages
This pattern is essential when the automation payload can change across JobRuns.

​
Additional Platform Capabilities

​
Authentication Support

Intuned supports authenticated browser automations for scenarios when you need to:
  • Log into websites before automating
  • Maintain user sessions across multiple runs
Authentication adds Auth Sessions to the conceptual model - reusable browser states that capture login information. When enabled, your Runs will automatically validate these sessions before executing. → Learn more in the Authentication Conceptual Guide for comprehensive coverage of this feature.

​
Monitoring and Debugging

Intuned provides comprehensive visibility into your automations through:
  • Real-time execution monitoring
  • Detailed browser traces for each attempt
  • Structured logs and error tracking
  • Performance metrics and timing data

​
Key Takeaways

  1. Projects Organize Everything: Projects are workspaces that contain all your automations
  2. APIs are Functions: Browser automation APIs are just parametrized functions that control browsers
  3. Runs Execute APIs: Each API call creates a Run with one or more Attempts
  4. Jobs Orchestrate: Use Jobs for batch processing and scheduling
  5. Everything is Tracked: Comprehensive records enable debugging and monitoring
  6. Built for Scale: From single executions to thousands of runs

​
Next Steps