**Equivalent cURL command**


```bash title="Terminal" {2-6}
curl -X POST https://api.alterlab.io/api/v1/extract \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://scholar.google.com/citations?user=EXAMPLE_USER",
    "schema": {
      "name": "string",
      "affiliation": "string",
      "total_citations": "string",
      "h_index": "string",
      "i10_index": "string",
      "recent_articles": [{"title": "string", "year": "string", "citations": "string"}]
    }
  }'

[AlterLab pricing](/pricing) scales with successful extractions—agents pay only for usable structured data, not failed attempts or bandwidth.

## Using the Search API for Google Scholar queries
For query-based data retrieval (e.g., finding recent papers on a topic), AlterLab's Search API (/api/v1/search) abstracts the complexity of interacting with Scholar's search interface.

**Python example: Query-based paper extraction**


```python title="agent_scholar-search.py" {3-7}

client = alterlab.Client("YOUR_API_KEY")

# Search Google Scholar via AlterLab's Search API
result = client.search(
    query='large language models "reasoning" 2024',
    num_results=10,
    filters={"year": "2024"}
)

# Extract structured results for RAG ingestion
for paper in result.data:
    print(f"Title: {paper['title']}")
    print(f"Authors: {', '.join(paper['authors'])}")
    print(f"Snippet: {paper['snippet']}\n")

The Search API returns normalized JSON including title, authors, venue, year, snippet, and URL—eliminating the need to parse search result pages or handle pagination logic in your agent.

## MCP integration
AlterLab provides an MCP (Model Context Protocol) server that exposes Scholar data as a tool for LLM agents. Agents built with Claude, GPT, or Cursor can call `alterlab_search_scholar` or `alterlab_extract_scholar_profile` as native tools, receiving structured data directly in their reasoning loop.

See the [AlterLab for AI Agents](https://alterlab.io/docs/tutorials/ai-agent) tutorial for MCP setup instructions. This integration reduces agent complexity by handling anti-bot measures, data extraction, and formatting at the infrastructure layer—allowing agents to focus solely on reasoning tasks like "Compare citation trends between these two researchers."

## Building an academic intelligence pipeline
Here's an end-to-end example of an agentic pipeline for automated literature surveillance:

1. **Agent triggers data collection**: An LLM agent (via MCP tool call) requests recent papers on "quantum machine learning" from AlterLab's Search API.
2. **AlterLab delivers structured data**: The API returns JSON with paper metadata, handled entirely by AlterLab's infrastructure (anti-bot, rendering, extraction).
3. **Agent processes and enriches**: The agent feeds the structured data into an LLM to:
   - Generate one-sentence summaries of each paper
   - Identify common themes across the result set
   - Flag papers with high citation velocity (using historical data from prior runs)
4. **Knowledge base update**: Structured summaries and insights are stored in a vector database for future RAG queries.
5. **Action triggering**: If a breakthrough pattern is detected (e.g., 3+ papers citing a new technique), the agent drafts a research brief for human review.

**Pipeline code snippet**


```python title="academic-pipeline.py" {5-12,15-20}

from typing import List, Dict

def research_surveillance_agent(topic: str) -> List[Dict]:
    client = alterlab.Client("YOUR_API_KEY")

    # Step 1: Get fresh scholar data via MCP-compatible tool
    search_result = client.search(
        query=topic,
        num_results=20,
        filters={"year": "2024"}
    )

    # Step 2: Agent processes structured data (no HTML handling)
    papers = []
    for paper in search_result.data:
        summary_prompt = f"""
        Summarize this academic paper in one sentence for a technical audience:
        Title: {paper['title']}
        Authors: {', '.join(paper['authors'])}
        Venue: {paper['venue']}
        Snippet: {paper['snippet']}
        """
        summary = your_llm.invoke(summary_prompt)

        papers.append({
            "title": paper['title'],
            "authors": paper['authors'],
            "year": paper['year'],
            "summary": summary.text,
            "url": paper['url']
        })

    # Step 3: Agent analyzes trends (example: citation velocity)
    # [In practice, would compare against historical data from knowledge base]
    high_impact = [p for p in papers if "breakthrough" in p['summary'].lower() or "novel" in p['summary'].lower()]

    return {
        "topic": topic,
        "total_papers": len(papers),
        "high_impact_count": len(high_impact),
        "papers": papers,
        "timestamp": datetime.utcnow().isoformat()
    }

# Agent invokes this as part of its reasoning cycle
survey_results = research_surveillance_agent("quantum machine learning 2024")