The Agentic Component for Web Content Intelligence

Ulfom is more than just a web scraper - it's an intelligent agent that understands, processes, and structures web content. Powered by AI and built for developers, Ulfom transforms messy web content into clean, structured data with minimal configuration.

Start Building View API Examples

Why Choose Ulfom?

AI-Powered Intelligence

Our agentic component uses advanced AI to understand and structure web content, adapting to different layouts and formats automatically.

Enterprise-Grade Performance

Built-in rate limiting, error handling, and async processing ensure reliable operation at any scale.

Developer-First Design

Simple API, comprehensive documentation, and flexible integration options make Ulfom a joy to work with.

Agentic Capabilities

Intelligent Content Processing

Unlike traditional scrapers, Ulfom understands content context and structure. Perfect for:

AI training data preparation
Knowledge base enrichment
Content recommendation systems
Research and analysis platforms

Adaptive Crawling

Smart crawling that adapts to website structures and handles dynamic content. Ideal for:

Market research automation
Competitive analysis
Content aggregation
Website migration

Structured Data Extraction

Extract and structure data using custom schemas and AI-powered analysis. Perfect for:

E-commerce price monitoring
Product catalog management
News and article aggregation
Data enrichment pipelines

Seamless Integration

Designed for easy integration into your existing workflows:

LLM training pipelines
Data analysis platforms
Content management systems
Business intelligence tools

Agentic API Reference

Intelligent Content Processing

Let our AI agent understand and structure content for you:

curl -X POST "https://www.ulfom.com/api/v1/task/structured_task" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -d '{
        "url": "https://example.com/article",
        "parameters": {
            "prompt": "Extract key points and conclusions",
            "json_schema": {
                "type": "object",
                "properties": {
                    "key_points": {"type": "array", "items": {"type": "string"}},
                    "conclusion": {"type": "string"}
                }
            }
        }
    }'

Adaptive Crawling

Smart crawling that adapts to any website structure:

curl -X POST "https://www.ulfom.com/api/v1/task/sitemap_crawl" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -d '{
        "url": "https://example.com",
        "parameters": {
            "concurrent_requests": 5,
            "max_pages": 1000,
            "adaptive_mode": true,
            "dynamic_content": true
        }
    }'

Intelligent Recursive Crawling

Smart recursive crawling with built-in rate limiting and error handling:

curl -X POST "https://www.ulfom.com/api/v1/task/recursive_crawl" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -d '{
        "url": "https://example.com",
        "parameters": {
            "max_pages": 100,
            "concurrent_requests": 5,
            "allowed_backward_links": false,
            "rate_limit": {
                "requests_per_second": 2,
                "burst_size": 5
            }
        }
    }'

Agentic Integration Examples

Python Integration

Integrate Ulfom's agentic capabilities into your Python applications:

import asyncio
from ulfom import UlfomClient

async def process_content():
    client = UlfomClient(api_key="YOUR_API_KEY")
    
    # Create an intelligent content processing task
    task_id = await client.create_task(
        service="structured_task",
        url="https://example.com/article",
        parameters={
            "prompt": "Extract key information and structure it",
            "json_schema": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "summary": {"type": "string"},
                    "key_points": {"type": "array", "items": {"type": "string"}},
                    "conclusion": {"type": "string"}
                }
            }
        }
    )
    
    # Wait for results
    result = await client.wait_for_result(task_id)
    print(result)

asyncio.run(process_content())

Node.js Integration

Use Ulfom's agentic capabilities in your Node.js applications:

const { UlfomClient } = require('ulfom');

async function processContent() {
    const client = new UlfomClient('YOUR_API_KEY');
    
    // Create an adaptive crawling task
    const taskId = await client.createTask({
        service: 'sitemap_crawl',
        url: 'https://example.com',
        parameters: {
            concurrentRequests: 5,
            maxPages: 1000,
            adaptiveMode: true,
            dynamicContent: true
        }
    });
    
    // Wait for results
    const result = await client.waitForResult(taskId);
    console.log(result);
}

processContent();