This works until the site redesigns. Then your selectors return None and your pipeline breaks.

## Request the Format You Need

AlterLab's scraping API converts HTML to structured output server-side. You specify the format, get back clean data.



```python title="scraper.py" {3-5}

client = alterlab.Client("YOUR_API_KEY")
response = client.scrape(
    "https://example-store.com/product/123",
    formats=["json"]
)
print(response.json)

No BeautifulSoup. No XPath. No maintenance when the site changes its CSS classes.

<div data-infographic="steps">
  <div data-step data-number="1" data-title="Install SDK" data-description="pip install alterlab"></div>
  <div data-step data-number="2" data-title="Send Request" data-description="POST to /v1/scrape with formats parameter"></div>
  <div data-step data-number="3" data-title="Get Structured Data" data-description="Receive clean JSON or Markdown"></div>
  <div data-step data-number="4" data-title="Use in Pipeline" data-description="Load into database, analytics, or LLM"></div>
</div>

## JSON Output for Data Pipelines

JSON output works best when you are feeding data into a database, analytics system, or downstream API. The API extracts common structured data patterns automatically:

- Product listings with prices and SKUs
- Article content with titles, authors, and dates
- Contact information from business pages
- Table data converted to arrays of objects
- Navigation links and metadata



```python title="pipeline.py" {6-10}

client = alterlab.Client("YOUR_API_KEY")

# Scrape and get JSON directly
response = client.scrape(
    "https://news-site.com/articles/latest",
    formats=["json"]
)

# Insert directly into your database
conn = psycopg2.connect("dbname=news user=writer")
cur = conn.cursor()
for article in response.json["articles"]:
    cur.execute(
        "INSERT INTO articles (title, author, published) VALUES (%s, %s, %s)",
        (article["title"], article["author"], article["published_date"])
    )
conn.commit()

## Markdown Output for Content and LLMs

Markdown output strips everything except the readable content. Scripts, styles, navigation bars, footers, and ads disappear. What remains is the article text, properly formatted.

This matters for two use cases:

**Content aggregation.** You want the article text, not the surrounding chrome. Markdown gives you clean text with heading hierarchy preserved.

**LLM context.** Language models process Markdown more efficiently than HTML. Tokens spent on `<div class="sidebar-widget">` are wasted tokens. Markdown removes the noise.



```python title="markdown_for_llm.py" {4-7}

from openai import OpenAI

client = alterlab.Client("YOUR_API_KEY")
response = client.scrape(
    "https://tech-blog.com/post/understanding-distributed-systems",
    formats=["markdown"]
)

# Feed clean markdown to an LLM
llm = OpenAI()
completion = llm.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "Summarize this technical article."},
        {"role": "user", "content": response.markdown}
    ]
)
print(completion.choices[0].message.content)

No `<script>` tags. No cookie consent banners. No navigation menus. Just the content.

<div data-infographic="try-it" data-url="https://example.com" data-description="Try scraping this page with AlterLab to get JSON or Markdown output"></div>

## Handling JavaScript-Rendered Sites

Many sites render content client-side. The initial HTML response contains almost nothing. The actual data loads via JavaScript after the page renders.

Raw HTTP requests cannot handle this. You need a headless browser.

AlterLab handles this automatically through its tiered rendering system. T1 handles static HTML. T3 and above execute JavaScript. You control the minimum tier:



```python title="javascript_render.py" {5}

client = alterlab.Client("YOUR_API_KEY")
response = client.scrape(
    "https://spa-app.com/dashboard",
    formats=["json"],
    min_tier=3
)

Cortex reads the page like a human would and extracts the fields you specify. No selectors. No regex. Just describe the data you want.

This works well for:

- Real estate listings with non-standard layouts
- Job boards with varying card structures
- Restaurant menus in image-heavy layouts
- Government data in poorly structured tables

## Multiple Formats in One Request

You can request multiple formats simultaneously. Useful when different parts of your pipeline need different representations:



```python title="multi_format.py" {5}

client = alterlab.Client("YOUR_API_KEY")
response = client.scrape(
    "https://product-page.com/item/456",
    formats=["json", "markdown", "text"]
)

# JSON for your database
save_to_db(response.json)

# Markdown for your LLM pipeline
summarize(response.markdown)

# Plain text for search indexing
index(response.text)

Full [API documentation](https://alterlab.io/docs) covers all parameters, tier options, and advanced features like scheduling and webhooks.

## Takeaway

Stop writing parsers. Request the format you need directly. One parameter changes the output from raw HTML to clean JSON or Markdown. No selectors to maintain. No breakage when sites redesign. Your pipeline gets the data it actually needs.