AI4Pricing2Yaml: Automated SaaS Pricing to YAML

• AI4Pricing2Yaml is an automated system that transforms static SaaS pricing data into dynamic, YAML-based intelligent pricing configurations.
• The system combines Selenium web scraping with advanced large language models to extract, validate, and normalize pricing elements from diverse SaaS pages.
• Its structured YAML output facilitates programmatic integration, continuous analysis, and rapid adaptation in DevOps and product management workflows.

AI4Pricing2Yaml is an automated system for transforming static software-as-a-service (SaaS) pricing data from web pages into dynamic, machine-readable “intelligent pricing” (iPricing) configurations, facilitating programmatic analysis, optimization, and rapid evolution of SaaS pricing models (Cavero et al., 16 Jul 2025). The system employs web scraping and LLMs to extract plans, features, usage limits, and add-ons, subsequently validating and converting these extracted elements into a structured YAML syntax (Pricing2Yaml), aiming to streamline SaaS pricing management—an increasingly complex challenge for DevOps and product teams given the proliferation of bespoke pricing structures.

1. System Architecture and Workflow

AI4Pricing2Yaml's architecture consists of three principal components:

1. Information Extractor: Utilizes Selenium-based web scraping to fetch pricing-relevant HTML content from SaaS product pages. This data, often encompassing extensive, JavaScript-driven interfaces, is passed in entirety to an LLM (notably Gemini 1.5 Flash, chosen for its large $10^6$–token context window), which is prompted to identify and extract relevant pricing schema elements (plans, features, usage limits, add-ons).
2. Process Engine: Applies postprocessing and validation logic to the extracted data. This module addresses potential LLM hallucinations, resolves duplications, and enforces structural consistency. For example, discrepancies between nominal annual and computed monthly pricing are flagged, and missing or conflicting features are annotated with warnings.
3. Results Modeler: Transforms the cleaned, validated extraction results into a structured YAML file adopting the Pricing2Yaml syntax. The YAML representation encodes the iPricing model as a hierarchy of plans, with each plan specifying associated features, limits, periodicity, and optional add-on groupings, enabling downstream automated consumption.

This modular pipeline ensures that complex SaaS pricing websites, with variable layouts and dynamically rendered elements, are parsed methodically, and the resulting data are normalized for further automation or integration.

2. Intelligent Pricing (iPricing) Paradigm

Intelligent pricing (iPricing) is defined in this context as the representation of SaaS product pricing in a dynamic, machine-readable form. Unlike static, manually curated HTML tables or unstructured text, iPricing treats pricing information as a first-class software artifact: versionable, programmatically queryable, and adaptable to real-time business or market signals. Such representations facilitate:

• Automated competitive analysis (e.g., mass comparison and benchmarking of subscription models across vendors)
• Continuous pricing evolution in response to observed market dynamics, usage analytics, or cost changes
• Systematic enforcement of consistency and avoidance of manual update errors (especially relevant for SaaS offerings with a combinatorially complex configuration space)

The iPricing concept is operationalized as YAML files compatible with the Pricing2Yaml schema (formerly Yaml4SaaS), making pricing logic accessible to orchestration pipelines, dashboard tools, and testing frameworks.

3. Algorithmic Implementation and Extraction Logic

The extraction workflow is implemented in Python due to its robust ecosystem for web automation, data parsing, and LLM API integration. The key steps include:

• Web Scraping: Selenium is used to drive a headless browser, interact with complex page elements, and retrieve fully rendered HTML, including hidden or JavaScript-dependent content where feasible. The system is designed to handle static and dynamic content, but certain interactive elements (e.g., pop-up or modal dialogs requiring JavaScript events) may still present difficulties.
• Prompt-Based LLM Extraction: The scraped HTML is fed as a prompt to Gemini 1.5 Flash, with instructions targeting extraction of plans (name, periodicity, price), features (including differentiating core from optional elements), usage limits, and add-ons. The LLM's extended context window is critical for accurately processing modern, verbose SaaS pricing layouts in a single pass.
• Postprocessing: The Process Engine deduplicates entries, reconciles inconsistencies (such as conflicting plan periodicity descriptions), and applies heuristic filters to identify and annotate likely hallucinated or ambiguous content produced by the LLM.
• Modeling and Output: Cleaned extractions are mapped onto the Pricing2Yaml schema, emitting structured YAML ready for integration into pricing APIs or developer workflows.

This workflow leverages advances in LLM prompt engineering but presently relies on “basic” prompts and linear postprocessing. The potential for “tool calling” LLM paradigms and richer structural output is identified as a future enhancement.

4. Validation, Performance, and Evaluation Metrics

The effectiveness of AI4Pricing2Yaml was empirically validated against a testbed of 30 SaaS products, totaling over 150 pricing models (Cavero et al., 16 Jul 2025). The evaluation employed a granular scoring approach:

Extraction Target	Mean Accuracy	Mean Precision	Mean Recall
Plans	High (often perfect recall)	High	High
Features	88–96%	High	High
Usage Limits	Variable	Variable	Moderate
Add-ons	~50%+	Strong recall	Variable

Points were assigned by classifying extraction elements as true positives, false positives, false negatives, or true negatives, allowing the calculation of accuracy, precision, and recall for each target type. The results indicate robust plan and feature extraction, with greater extraction variability in limits and add-ons—primarily due to nonstandard HTML structures and the semantic ambiguity of SaaS “add-ons” as presented on many commercial sites.

5. Practical Challenges and Current Limitations

The paper identifies two principal sources of extraction error and operational challenge:

• Internal (LLM-related): Hallucinated outputs (e.g., fabrication of features not present in the source), misclassification (such as confusion between add-ons and entire plans), and difficulty recognizing deeply nested or ambiguous groupings within complex pricing tables.
• External (web data): Nonstandard or inconsistent HTML layouts, unlabeled or semantically ambiguous tables, and content accessible only via user-driven dynamic interactions (not accessible to headless browsing without additional scripting).

Addressing these complications is central to further improvements. The system already applies some postprocessing and error correction, but usage of more advanced LLM architectures (e.g., Gemini 1.5 Pro) and richer prompt engineering is anticipated to improve both extraction fidelity and semantic alignment.

6. YAML Representation and Integration

The output of AI4Pricing2Yaml is a YAML file structured for direct consumption by iPricing management systems. A typical schema fragment may include:

plans: - name: "Pro" periodicity: "monthly" price: 49.00 features: - "Unlimited projects" - "Priority support" usage_limits: api_calls: 10000 - name: "Enterprise" periodicity: "annual" price: 499.00 features: - "Dedicated manager" - "Custom integrations" add_ons: - "Advanced reporting"

This structure—parameters, usage limits, hierarchical feature groupings—parallels typical SaaS pricing configurations, enabling downstream business logic, automated analysis, and deployment of A/B test configurations.

7. Outlook and Future Research

While AI4Pricing2Yaml represents a functional advance in automating the SaaS pricing transformation pipeline, the research underscores several future directions:

• Enhancing LLM prompt engineering, possibly leveraging structured “tool calling” functionality and agent-based navigation to interactively reveal dynamic content
• Incorporating knowledge graphs to reduce input noise and improve context-aware extraction
• Extending the range of supported SaaS website architectures, with improved robustness to non-canonical or evolving HTML/CSS standards
• A plausible implication is that as the system improves, it may form the basis for continuous and autonomous pricing management systems for SaaS vendors, reducing manual effort and minimizing the risk of pricing inconsistencies as product portfolios expand.

In summary, AI4Pricing2Yaml operationalizes the conversion of static SaaS pricing into dynamic, intelligent pricing data via a pipeline that combines web scraping, LLM-based semantic extraction, and YAML-based modeling. The system achieves high accuracy in plan and feature extraction and establishes a replicable framework for intelligent pricing management, with ongoing challenges in complex content extraction and hallucination mitigation remaining active areas for research development (Cavero et al., 16 Jul 2025).