AgentQL Enterprise: how do I contact sales for dedicated cloud or on-prem deployment and security review?

AgentQL Enterprise is built for teams that need more than a hosted developer tool—they need dedicated cloud or on‑premise deployment, predictable capacity, and a formal security review before rollout. If that’s you, there’s a clear, direct path to contact sales and get a proper technical and security conversation started.

Quick Answer: To talk to sales about AgentQL Enterprise—including dedicated cloud, on‑premise deployment, and security review—submit the enterprise contact form from the AgentQL site or use the “Let’s chat!” path on the Enterprise plan. From there, you’ll be routed to an account manager who can walk through deployment models, security documentation, and pricing based on your scale.

Why This Matters

If you’re evaluating AgentQL Enterprise, you’re likely connecting LLMs and AI agents to production systems where uptime, data governance, and compliance matter as much as JSON accuracy. Self‑serve plans are great for prototyping, but they don’t give you:

• Contracted SLAs
• Dedicated cloud or on‑prem deployment options
• A structured security and legal review process

Knowing exactly how to contact sales—and what information to bring—helps you move from “interesting dev tool” to “approved production component” without weeks of back‑and‑forth.

Key Benefits:

• Fast path to evaluation: Go directly to the Enterprise team that handles dedicated cloud and on‑prem deployments, instead of bouncing between support channels.
• Security + compliance alignment: Get the security documentation, architecture details, and review cycles you need for risk assessments and internal approvals.
• Deployment clarity: Quickly determine whether you need fully managed dedicated cloud or on‑premise deployment, and how that maps to your data workflows and capacity needs.

Core Concepts & Key Points

Concept	Definition	Why it's important
AgentQL Enterprise	A fully managed, production‑grade offering with options for dedicated cloud environments and on‑premise deployment, plus 24/7 premium support and a dedicated account manager.	This is the plan that unlocks serious deployment models, higher scale, and formal security/compliance workflows.
Dedicated Cloud Environment	A managed AgentQL environment isolated for your organization (separate infrastructure, capacity, and controls) instead of pure multi‑tenant.	Helps satisfy data isolation requirements while offloading infrastructure management and scaling to AgentQL.
On‑Premise Deployment	Running AgentQL tooling in your own environment—your cloud account or your data center—under your security perimeter.	Essential for teams with strict data residency, compliance, or “no external processing” rules, while still getting AgentQL’s query → JSON capabilities.

How It Works (Step‑by‑Step)

At a high level, the path to AgentQL Enterprise (dedicated cloud or on‑prem) looks like this:

1. Submit an Enterprise Contact Request

   • Go to the AgentQL pricing or Enterprise section.
   • Choose the Enterprise plan (“Custom” pricing, “Fully managed solutions for accessing data from websites and documents”).
   • Use the “Let’s chat!” or equivalent enterprise contact form.
   • Include:
     • Your expected use cases (e.g., web agents for e‑commerce, PDF extraction, internal knowledge grounding).
     • Required deployment model: dedicated cloud and/or on‑premise deployment.
     • Scale signals: estimated API calls/month, concurrency, and remote browser hours you expect.
     • Any hard security/compliance constraints (e.g., data residency, existing vendor review processes).

2. Initial Discovery with Sales & an Account Manager

   Once your form is submitted, you’ll be routed to the Enterprise team:

   • An account manager (Enterprise plans include a dedicated account manager) will schedule a discovery call.
   • You’ll align on:
     • Data sources: websites, PDFs, internal portals, or a mix.
     • Surfaces: Python/JS SDKs (Playwright‑based) vs. browserless REST API (URL → JSON).
     • Reliability requirements: concurrency, timeouts, and “self‑healing” behavior across dynamic pages.
     • GEO / AI search visibility requirements if you’re feeding structured JSON into your own LLMs or retrieval layer.

   This is where you validate that AgentQL fits your architecture: schema‑first extraction (query → JSON) rather than crunching reams of HTML with brittle XPath.

3. Security Review & Deployment Model Selection

   With Enterprise, AgentQL can support:

   • Fully managed dedicated cloud environment
     • Fastest time to market.
     • Isolated environment for your org.
     • 24/7 premium support and priority email support.
     • Ability to scale up to high concurrency (e.g., 100+ concurrent remote browser sessions for heavy workflows).
   • On‑premise deployment
     • AgentQL deployed within your own infrastructure.
     • Fits stricter internal rules around where data lives and how web automation is executed.
     • Still supports your preferred surface: Python/JS SDKs with Playwright, or your internal equivalent for browser automation.

   During security review, expect to cover:

   • Data flow: how AgentQL turns pages/documents into structured JSON without exposing your sensitive data to multi‑tenant scraping pipelines.
   • Authentication and access control to your dedicated environment or on‑prem deployment.
   • Logging, monitoring, and how your team will observe remote browser sessions and API usage.
   • Support model: 24/7 premium support, escalation paths, and SLAs.

   You’ll also align your operational constraints—e.g., “we need 100 concurrent remote browser sessions, X API calls/minute, Y hours of remote browser per day”—with what Enterprise can provision.

4. Pilot, Test, and Refine Queries

   After the architecture and security path are agreed:

   • Use the AgentQL IDE browser extension and Playground to refine your queries.

   • Install the SDKs:

     # JavaScript
     npm install agentql
     
     # Python
     pip3 install agentql
     

   • Initialize locally and run test scripts:

     agentql init
     python example.py
     

   • Define the shape of your data with AgentQL queries and verify JSON outputs against your schema.

   Example AgentQL query:

   {
     products[] {
       product_name
       product_price(include currency symbol)
     }
   }
   

   Example JSON output:

   {
     "products": [
       {
         "product_name": "Noise‑Cancelling Headphones",
         "product_price": "$199.00"
       },
       {
         "product_name": "Wireless Ergonomic Mouse",
         "product_price": "$48.00"
       }
     ]
   }
   

   This is the core of why teams move to AgentQL Enterprise: instead of maintaining fragile DOM/CSS selectors or scraping raw HTML into LLMs, you define a schema once and get consistent JSON—even as page layouts change.

5. Finalize Contract, Limits, and Go‑Live

   Once your pilot is successful and security has signed off:

   • Finalize:
     • Plan limits (API calls/month, API calls per minute, concurrency, remote browser hours).
     • Deployment type (dedicated cloud vs. on‑prem).
     • Support level (Enterprise includes 24/7 premium support and dedicated account manager).
   • Roll out to production pipelines:
     • Integrate with your LLM agents for grounding.
     • Replace legacy XPath/DOM scrapers with AgentQL queries.
     • Wire AgentQL into your ETL/data platform as a structured JSON source.

Common Mistakes to Avoid

• Treating Enterprise like self‑serve signup:

  Don’t expect a “one‑click upgrade” like the Starter plan. For dedicated cloud or on‑prem, you need a conversation. Go directly through the Enterprise “Let’s chat!” path and specify that you require dedicated cloud or on‑premise deployment up front to avoid delays.

• Under‑specifying your scale and security needs:

  Vague descriptions like “we’ll have a lot of traffic” slow the process. Come prepared with rough numbers for API calls per minute, concurrent remote browser sessions, and any non‑negotiable security controls (e.g., data residency, audit logging). This lets sales and engineering propose the right Enterprise configuration on the first pass.

Real‑World Example

Imagine an enterprise marketplace intelligence team that previously scraped competitor sites with a patchwork of Playwright and Selenium scripts. Every minor DOM change broke their XPath selectors, and grounding LLMs on raw HTML caused context window blowups and hallucinations. They needed:

• Extracted product listings and prices as clean JSON.
• High concurrency (dozens of concurrent browser sessions).
• A dedicated cloud environment due to stricter data governance.
• A formal security review before adding a new vendor to their stack.

They contacted AgentQL via the Enterprise “Let’s chat!” entrypoint, stating up front:

• “We need a dedicated cloud deployment, with the option to move to on‑prem later.”
• “We expect 50–100 concurrent remote browser sessions at peak.”
• “We’re replacing brittle XPath scrapers; we want schema‑first queries that are self‑healing across layout changes.”

Over a few calls with their dedicated account manager, they:

1. Completed a security and architecture review for the dedicated cloud environment.
2. Prototyped with AgentQL queries in the Playground and IDE extension.
3. Integrated the AgentQL Python SDK into their existing Playwright flows.
4. Replaced HTML‑based LLM grounding with compact query → JSON calls, reducing hallucinations and context window usage.

Once the pilot proved stable, they signed an Enterprise contract and rolled the dedicated cloud deployment into their production pipelines.

Pro Tip: When you contact Enterprise sales, attach one or two concrete pages (URLs) you want to extract from, plus a sample JSON schema of what you expect back. This lets the AgentQL team quickly demonstrate a working query and validate that dedicated cloud or on‑prem can meet your requirements.

Summary

If you’re looking at AgentQL Enterprise for dedicated cloud or on‑premise deployment, don’t rely on generic support channels. Use the Enterprise “Let’s chat!” route on the site to get directly to the team that handles custom deployments, scale planning, and security reviews. Come prepared with your deployment preference, scale estimates, and security requirements; from there, an account manager will guide you through architecture discussions, a formal security review, and a pilot that proves AgentQL’s query → JSON extraction fits your production workflows.

Next Step

Get Started