Perplexity API for Local Business: AI-Powered Competitor Research

What Is the Perplexity API?

• sonar-small — Optimized for speed and cost. Uses a smaller language model but still performs live web searches. Best for high-volume, simple queries like "what are the current hours for [business name]?"
• sonar-large — The main workhorse. Strong synthesis quality, reliable citations, good at multi-part research tasks. This is what you will use for most competitor intelligence work.
• sonar-reasoning — The premium tier. Applies chain-of-thought reasoning before answering, which improves quality on complex comparative questions like "which hair salon in Austin has the strongest recent review trajectory?"

Getting Started: API Key, Python Setup, and Your First Request

pip install openai python-dotenv

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    api_key=os.environ["PERPLEXITY_API_KEY"],
    base_url="https://api.perplexity.ai"
)

def search_perplexity(query: str, model: str = "sonar-large") -> dict:
    """
    Send a research query to Perplexity and return the response with citations.
    """
    response = client.chat.completions.create(
        model=model,
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a local business market research assistant. "
                    "Provide specific, factual information with citations. "
                    "Focus on actionable insights for small business owners."
                )
            },
            {
                "role": "user",
                "content": query
            }
        ]
    )

    result_text = response.choices[0].message.content
    citations = getattr(response, "citations", [])

    return {
        "answer": result_text,
        "citations": citations,
        "model": model,
        "tokens_used": response.usage.total_tokens if response.usage else 0
    }

# Quick test
if __name__ == "__main__":
    result = search_perplexity(
        "What are the most popular coffee shops in Austin, Texas right now, "
        "and what do customers say about them in recent reviews?"
    )
    print(result["answer"])
    print("\nSources:")
    for citation in result["citations"]:
        print(f"  - {citation}")

5 Competitor Research Automation Use Cases

1. Weekly Competitor Review Tracker

COMPETITOR_TRACKER_PROMPT = """
Search for recent Google reviews (last 30 days) for these businesses in {city}:
{competitor_list}

For each business, summarize:
1. Overall recent sentiment (positive/negative/mixed)
2. The top 2-3 things customers praise
3. The top 2-3 complaints
4. Any mentions of price increases, new services, or staff changes

Format as a structured comparison I can act on.
"""

competitors = [
    "The Daily Grind Coffee, Austin TX",
    "Brew & Bloom Coffee Bar, Austin TX",
    "Houndstooth Coffee, Austin TX"
]

result = search_perplexity(
    COMPETITOR_TRACKER_PROMPT.format(
        city="Austin, TX",
        competitor_list="\n".join(f"- {c}" for c in competitors)
    )
)

2. Local Keyword Trend Monitor

TREND_MONITOR_PROMPT = """
What are people in {city} currently searching for and discussing related to {niche}?

Include:
- Trending service types or treatments people are asking about
- Seasonal factors affecting demand right now
- Any viral social media content driving local interest
- Emerging preferences (e.g., specific ingredients, techniques, brands)

Focus on trends from the last 60 days.
"""

result = search_perplexity(
    TREND_MONITOR_PROMPT.format(
        city="Brooklyn, New York",
        niche="hair salons and hair care services"
    )
)

3. Price Benchmarking: What Are Competitors Charging?

PRICE_BENCHMARK_PROMPT = """
What do hair salons in {city} currently charge for {service}?

Search for:
- Menu prices from salon websites in this area
- Price mentions in recent Google and Yelp reviews
- Any recent price increase discussions on local community forums (Nextdoor, Reddit r/{city})

Provide a price range (low, mid, high) with specific examples and sources.
"""

result = search_perplexity(
    PRICE_BENCHMARK_PROMPT.format(
        city="Austin, Texas",
        service="full balayage with toner"
    ),
    model="sonar-reasoning"  # Use reasoning model for structured comparison
)

4. New Competitor Detection

NEW_COMPETITOR_PROMPT = """
Are there any new {business_type} businesses that have opened or are opening soon 
in {neighborhood}, {city}? 

Search for:
- Recent local news coverage of new openings
- New Google Business Profile listings in this area (indicated by "newly opened" labels)
- Social media announcements from new businesses
- Local permit announcements or development news

Focus on the last 90 days.
"""

result = search_perplexity(
    NEW_COMPETITOR_PROMPT.format(
        business_type="coffee shops or cafes",
        neighborhood="South Congress",
        city="Austin, TX"
    )
)

5. Weekly Industry Trend Digest

INDUSTRY_DIGEST_PROMPT = """
Summarize the most important local marketing and small business news from the past 7 days.

Focus on:
- Changes to Google Business Profile features or ranking factors
- Meta/Instagram algorithm updates affecting local businesses
- New AI tools specifically useful for small local businesses
- Consumer behavior shifts in the {niche} industry
- Any regulatory changes affecting local advertising

Format as a bullet-point digest I can read in 3 minutes.
"""

result = search_perplexity(
    INDUSTRY_DIGEST_PROMPT.format(niche="food & beverage"),
    model="sonar-small"  # Speed and cost optimized — this is a volume task
)

Python: Automated Weekly Competitor Intelligence Report

import os
import smtplib
from datetime import datetime
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["PERPLEXITY_API_KEY"],
    base_url="https://api.perplexity.ai"
)

# --- Configuration ---
BUSINESS_CONFIG = {
    "name": "Bella Hair Studio",
    "type": "hair salon",
    "city": "Austin, Texas",
    "neighborhood": "South Lamar",
    "niche": "hair salons and beauty services",
    "competitors": [
        "Salon Botticelli, Austin TX",
        "Bird's Barbershop South Lamar, Austin TX",
        "Colorlab Salon, Austin TX"
    ]
}

EMAIL_CONFIG = {
    "smtp_server": "smtp.gmail.com",
    "smtp_port": 587,
    "sender": os.environ["REPORT_EMAIL_SENDER"],
    "password": os.environ["REPORT_EMAIL_PASSWORD"],
    "recipient": os.environ["REPORT_EMAIL_RECIPIENT"]
}

def run_query(prompt: str, model: str = "sonar-large") -> str:
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": "You are a local business intelligence analyst. Be specific, cite sources, and focus on actionable insights."},
                {"role": "user", "content": prompt}
            ]
        )
        return response.choices[0].message.content
    except Exception as e:
        return f"[Query failed: {str(e)}]"

def build_weekly_report(config: dict) -> dict:
    c = config
    competitor_list = "\n".join(f"- {comp}" for comp in c["competitors"])

    sections = {
        "Competitor Review Summary": run_query(
            f"Summarize recent Google and Yelp reviews (last 30 days) for these {c['type']} businesses in {c['city']}: {competitor_list}. "
            f"For each: overall sentiment, top praises, top complaints, any notable changes."
        ),
        "Local Trend Report": run_query(
            f"What {c['niche']} trends are currently popular in {c['city']}? "
            f"Include emerging services, viral treatments, and seasonal demand shifts from the last 60 days.",
            model="sonar-small"
        ),
        "Pricing Benchmark": run_query(
            f"What do {c['type']} businesses in {c['city']} currently charge for their most popular services? "
            f"Provide a price range with specific examples from local businesses.",
            model="sonar-reasoning"
        ),
        "New Competitors": run_query(
            f"Have any new {c['type']} businesses opened or announced openings in {c['neighborhood']}, {c['city']} "
            f"in the last 90 days? Include any relevant news or social media announcements.",
            model="sonar-small"
        ),
        "Industry News Digest": run_query(
            f"Summarize the top local marketing and small business news from the past 7 days, "
            f"especially anything affecting {c['niche']} businesses.",
            model="sonar-small"
        )
    }
    return sections

def send_html_report(sections: dict, config: dict, biz_config: dict):
    today = datetime.now().strftime("%B %d, %Y")
    html_parts = [f"<h1>Weekly Intelligence Report — {biz_config['name']}</h1><p><em>{today}</em></p>"]

    for section_title, content in sections.items():
        # Convert markdown-ish content to basic HTML
        content_html = content.replace("\n\n", "</p><p>").replace("\n", "<br>")
        html_parts.append(f"<h2>{section_title}</h2><p>{content_html}</p><hr>")

    html_body = "<html><body>" + "".join(html_parts) + "</body></html>"

    msg = MIMEMultipart("alternative")
    msg["Subject"] = f"Weekly Competitor Intel: {biz_config['name']} — {today}"
    msg["From"] = config["sender"]
    msg["To"] = config["recipient"]
    msg.attach(MIMEText(html_body, "html"))

    with smtplib.SMTP(config["smtp_server"], config["smtp_port"]) as server:
        server.starttls()
        server.login(config["sender"], config["password"])
        server.sendmail(config["sender"], config["recipient"], msg.as_string())
        print(f"Report sent to {config['recipient']}")

if __name__ == "__main__":
    print("Running weekly competitor intelligence queries...")
    report_sections = build_weekly_report(BUSINESS_CONFIG)
    send_html_report(report_sections, EMAIL_CONFIG, BUSINESS_CONFIG)

# Run every Monday at 7:00 AM
0 7 * * 1 /usr/bin/python3 /home/user/competitor_report.py >> /var/log/competitor_report.log 2>&1

Perplexity vs Manual Research vs Other AI APIs

When NOT to Use Perplexity API

• Booking automation — Confirming appointments, sending reminders, managing waitlists. Use a dedicated model like Claude Haiku or GPT-4o Mini via a simple API call. Perplexity's web search adds latency and cost with no benefit for tasks that do not require live information.
• Review reply generation — Crafting replies to customer reviews. A static model like Qwen 2.5-72B or Claude Haiku will produce better, more tonally controlled replies at a fraction of the cost. Perplexity will try to search the web for context it does not need.
• Social media caption writing — Creative writing tasks benefit from Claude or GPT-4o's larger creative training, not from real-time web access.
• Email marketing copy — Same as above. Static models with strong instruction-following (Claude Sonnet, GPT-4o) consistently outperform web-connected models for creative writing.
• FAQ answer generation — If you already know the answers, you do not need web search. A static model is faster and cheaper.

FAQ

Related Articles

• OpenRouter Complete Guide for Local Business Automation 2026
• Best Free OpenRouter Models for Business Automation
• GPT-4o Mini vs Groq LLaMA: Cost Comparison for Local Business 2026
• AI Agent for Google Reviews Management
• Local Marketing Budget Guide: How Much Should a Small Business Spend?