Set up and activate your engine

Follow these four steps to go from a configured engine to a live API integration.

Organizations and multiple customers

Each integration must use the approved business-to-tenant mapping. Builder ownership or assignment alone does not establish pricing API access. An agency serving multiple businesses should ask Quotix to confirm the correct location mapping and authorized credential for each business. Do not use a demonstration tenant or another customer's key.

What activation means today

API onboarding and engine registration are currently assisted by Quotix. Publishing a form, renaming its title or receiving a new key does not by itself register a service. You are ready when your own schema and sample calculation have been verified.

Get and manage your API key

Your Quotix API key is a secret used to authorize requests to the pricing service. Quotix issues it during onboarding. It is not a GoHighLevel credential, database key, form-sharing token or your Quotix login password.

Store and send the key

Store it in your workflow credential manager or server-side secret store. Send it in the Authorization header on authenticated requests:

Authorization: Bearer <YOUR_QUOTIX_API_KEY>

Replace the placeholder with your supplied key. Keep the space after Bearer. Do not send the key in the request URL, public form, browser JavaScript, screenshot, chat message or generated proposal.

Check that the key works

GET https://mcp.quotix.ai/v1/status
Authorization: Bearer <YOUR_QUOTIX_API_KEY>

A successful response reports status, auth_scope and tenant_id. A normal customer integration should use tenant-scoped access to the intended business. Save the confirmed tenant ID for engine discovery. A successful status check proves authentication; it does not prove that a particular engine is registered.

Request or replace a key

Contact Quotix if you have not received a key, need another authorized connection, suspect exposure or need access removed. Key creation and old-key deactivation are operator-assisted; do not look for an undocumented self-service button.

For planned replacement: obtain a replacement key, update your authorized consumers, verify their access and then have Quotix deactivate the previous key. For suspected exposure, contact Quotix promptly to agree immediate revocation and recovery. Do not include the full secret in the support request.

Separate environments and providers

Use the endpoint and credential supplied for the intended environment. Do not assume a production key works against a test server. A provider such as GoHighLevel requires its own authorized credential for contact or record access; a Quotix key only authorizes Quotix pricing requests.

Connection addresses

The health endpoint checks service/database availability without a key. Use /v1/status to test your credential, followed by the selected service schema to verify engine access.

Discover your engines and inputs

Before calculating a quote, discover which services are active on your tenant and what inputs each one requires.

List the active services for your tenant

GET /v1/tenants/<YOUR_TENANT_ID>/engines
Authorization: Bearer <YOUR_QUOTIX_API_KEY>

Use the tenant ID confirmed during onboarding or returned by your authenticated status check. The response lists active engines with their service_type, engine ID and name. Select the exact service_type you need. Your key cannot be assumed to access other tenants.

If an engine is missing, check that Quotix has activated the intended builder version on the correct tenant. Do not guess a service name from a form title or change the API key merely because the engine is missing.

Request the selected service schema

GET /v1/engines/schema

Query parameters:
  platform     = <YOUR_PLATFORM>
  external_id  = <YOUR_MAPPED_ACCOUNT_ID>
  service_type = <YOUR_REGISTERED_SERVICE_TYPE>

Use the same Authorization header. Query-parameter fields in your HTTP client help encode spaces and special characters correctly. The schema response identifies the engine and provides input_schema and required_fields.

How to use the schema response

Collect enough information for the job

Ask for missing answers rather than inventing them. Some schemas allow optional fields or contain no required fields. That does not establish that a partial request is a complete job specification. Agree which business questions must be answered before presenting a final price.

Connect n8n with HTTP requests

Before starting, obtain your key, mapped platform/account identity, active service_type and an approved sample quote. Create HTTP Request nodes for Check Access, Get Schema and Calculate. Store credentials once and reuse them.

{
  "platform": "<YOUR_PLATFORM>",
  "external_id": "<YOUR_MAPPED_ACCOUNT_ID>",
  "service_type": "<YOUR_REGISTERED_SERVICE_TYPE>",
  "inputs": {
    "<KEY_FROM_SELECTED_SCHEMA>": "<ANSWER_MATCHING_ITS_TYPE>"
  }
}

Test the approved sample before using real leads. When selecting another engine, change service_type in both schema and calculate requests and rebuild the answer mapping from its schema.

Use MCP or curl

For AI agent frameworks and compatible clients, connect directly to the Quotix MCP server.

Connect a compatible MCP client

Add Quotix as a remote MCP server using https://mcp.quotix.ai/mcp, Streamable HTTP transport and your Bearer credential. Use the client's supported secret-storage mechanism. Exact setup controls vary between clients and versions; legacy SSE and local stdio settings are not interchangeable with Streamable HTTP.

Allow the client to initialize the MCP connection and discover its tools. Call get_quote_schema first, collect the answers and then call calculate_quote. Inspect tool errors as well as the transport status. A successful connection does not establish that a particular customer engine is activated.

Instructions for your agent

Use only the account and service authorized for this workflow. Retrieve the selected schema before asking pricing questions. Collect valid answers without guessing. Call Calculate for monetary results. Present its returned total and breakdown. If an error occurs, ask for corrected inputs or route the issue to support — do not invent a price. Keep credentials out of conversations.

Test REST using curl

Set QUOTIX_API_KEY, QUOTIX_PLATFORM, QUOTIX_ACCOUNT_ID and QUOTIX_SERVICE_TYPE privately in your environment to the supplied values. The schema request below encodes query values correctly:

curl --get "https://mcp.quotix.ai/v1/engines/schema" \
  -H "Authorization: Bearer $QUOTIX_API_KEY" \
  --data-urlencode "platform=$QUOTIX_PLATFORM" \
  --data-urlencode "external_id=$QUOTIX_ACCOUNT_ID" \
  --data-urlencode "service_type=$QUOTIX_SERVICE_TYPE"

Save your completed Calculate request body as quote-request.json. Include the same identity and schema-matching inputs; do not put the API key in this file.

curl "https://mcp.quotix.ai/v1/quotes/calculate" \
  -H "Authorization: Bearer $QUOTIX_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @quote-request.json

For a full endpoint reference, see the interactive API reference. Use the REST path if your automation does not support a compatible MCP client.

Use the price in your workflow

After a successful calculation, use the returned JSON to drive your downstream provider steps.

Understand the response

The result reflects the active configuration and the submitted inputs. It does not guarantee that your configuration contains all intended charges or that you supplied every business detail. Confirm sample results with the owner of the pricing rules.

Connect your destination provider

After a successful calculation, use a separate authorized provider connection to store or deliver the result. For example, a GoHighLevel workflow needs permission for the intended location. The Quotix key cannot create that authorization.

• Carry the customer's contact details forward from the intake step
• Create or update the correct contact using a stable identifier or provider-supported upsert
• Map the returned total and service information to agreed custom fields, notes or a quote record. Use the actual destination field IDs for your account
• If needed, generate a proposal from the returned values, then send it through the authorized delivery channel
• Confirm the record or message exists in the intended account and contains the same price returned by Quotix

Handle downstream failures

If pricing succeeds but contact creation or proposal delivery fails, report that specific failure. Retry the failed step with appropriate duplicate protection rather than repeating successful customer messages. Preserve the verified response and original contact context so you can recover without inventing or accidentally changing the price.

For provider access or destination-field problems, work with your provider administrator or integrator. For Quotix account mapping, engine activation or pricing errors, contact Quotix with the details listed in Troubleshooting.

Change engines and pricing safely

Follow these steps when switching services, updating pricing rules, or retiring an integration.

Switch to a different active service

List your tenant's active engines and select the exact new service_type. Retrieve its schema. Replace the old input mapping with the new engine's keys and valid values. Keep schema and Calculate requests pointed at the same account and service. Test an approved quote before using the new service for customers.

Update an existing builder engine

Edit and review the builder configuration, then contact Quotix to activate or re-sync the intended version for API use. Include the engine link/ID, changed fields or rules, the current registered service name and expected test results.

After Quotix confirms the update, retrieve the schema again. Refresh any cached questions, options and mappings. Compare the same inputs against the agreed rules and verify the downstream result.

Remove or stop an API service

Ask Quotix to confirm API deactivation separately when retiring a service. Do not assume unpublishing or deleting a builder form automatically removes its API registration. Update workflows that still call that service and confirm they no longer offer it to customers.

Verify the complete integration

• Access: your key resolves to the intended tenant and location
• Discovery: your exact service appears as active and its schema is correct
• Pricing: representative option combinations produce approved totals
• Validation: missing mandatory inputs, invalid types and invalid options are handled correctly
• Completeness: optional fields and conditional questions follow the agreed business flow
• Destination: the correct contact/quote/proposal is saved or sent with the returned price
• Recovery: a failed downstream step can be retried without duplicate customer records or messages

Keep a verification record

Record the engine/version reviewed, registered service name, test inputs, expected/actual result and verification date. Exclude secrets. Repeat relevant checks after pricing changes, account remapping or provider integration changes.

If builder and API results differ for the intended same version and answers, investigate the configuration and mapping. Do not treat a discrepancy as an acceptable default or silently replace the API amount with another calculation.

Troubleshooting and support

Work through these checks in order before contacting support.

Use these checks in order

What to send Quotix

Include the date/time, endpoint or tool, failing workflow step, HTTP status and error body, engine ID/version, service_type and relevant account identifier through the approved support channel. Include a sanitized sample input and expected result for pricing issues. Never include the full API key or unnecessary customer personal information.

Contact Quotix support through the contact form for account and pricing configuration issues. Contact your integrator/provider administrator for provider authorization and write-back failures. Do not assume a configuration error automatically created a support ticket; send the details so the issue can be tracked.

Frequently asked questions

Common questions about Quotix setup, engines, and integrations.

Quotix MCP

Deterministic pricing your AI agents can trust. Quotix MCP is a pricing brain for chat and automation workflows. Your agent asks for a quote — Quotix returns a verified total from fixed rules. No model guesses the number.

Connection details

How it works

Quickstart

Pick your client. All of them need the endpoint URL and the Authorization header.

n8n (HTTP Request nodes)

Use Header Auth credential. Set header name to Authorization, value to Bearer <QUOTIX_API_KEY>. Create two nodes — Get Schema (GET) and Calculate Quote (POST).

Claude Desktop / generic MCP client

{
  "mcpServers": {
    "quotix-pricing": {
      "url": "https://mcp.quotix.ai/mcp",
      "headers": {
        "Authorization": "Bearer <QUOTIX_API_KEY>"
      }
    }
  }
}

If your client only supports stdio MCP servers, bridge to the HTTP endpoint:

{
  "mcpServers": {
    "quotix-pricing": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.quotix.ai/mcp",
               "--header", "Authorization: Bearer <QUOTIX_API_KEY>"]
    }
  }
}

Python (fastmcp Client)

from fastmcp import Client

async with Client("https://mcp.quotix.ai/mcp", auth="<QUOTIX_API_KEY>") as client:
    schema = await client.call_tool("get_quote_schema", {
        "platform": "<YOUR_PLATFORM>",
        "external_id": "<YOUR_MAPPED_ACCOUNT_ID>",
        "service_type": "<YOUR_REGISTERED_SERVICE_TYPE>",
    })
    print(schema.structured_content["required_fields"])

curl (connectivity check)

curl -sS https://mcp.quotix.ai/mcp \
  -H "Authorization: Bearer $QUOTIX_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Tools reference

Quotix MCP exposes two tools. Call get_quote_schema first, then calculate_quote with the collected inputs.

{
  "engine_id": "<ENGINE_ID>",
  "engine_name": "<ENGINE_NAME>",
  "service_type": "<YOUR_REGISTERED_SERVICE_TYPE>",
  "tenant_id": "<YOUR_TENANT_ID>",
  "input_schema": {
    "type": "object",
    "properties": {
      "tonnage_capacity": { "type": "number" },
      "us_state_location": { "type": "string" },
      "site_accessibility": { "type": "string" }
    },
    "required": ["tonnage_capacity", "us_state_location", "site_accessibility"]
  },
  "required_fields": ["tonnage_capacity", "us_state_location", "site_accessibility"]
}

{
  "engine_used": "<ENGINE_NAME>",
  "engine_id": "<ENGINE_ID>",
  "service_type": "<YOUR_REGISTERED_SERVICE_TYPE>",
  "tenant_id": "<YOUR_TENANT_ID>",
  "total": 6416.25,
  "breakdown": {
    "line_items": [
      { "key": "equipment", "label": "Base Equipment",    "amount": 4900.00 },
      { "key": "labor",     "label": "Installation Labor", "amount": 1000.00 }
    ],
    "modifiers": [],
    "subtotal": 5900.00,
    "tax": 516.25,
    "tax_rate": 0.0875,
    "total": 6416.25
  }
}

Schema-gate workflow

Use this loop so the agent never invents missing job details.

Errors

MCP tool errors return isError: true with a structured payload. The REST API returns the same body with an HTTP status.

Also expect standard 401 Unauthorized when the Bearer token is missing or wrong.

Error payload

{
  "error": "VALIDATION_ERROR",
  "message": "Required quote inputs are missing or invalid.",
  "details": { "missing_fields": ["site_accessibility"] }
}

Worked example

An illustrative calculation showing how an engine's rules produce a total. It is not a live account: the identifiers are placeholders, and your engine's fields, options and prices will differ. Use your own activated service and an approved sample to test.

Request — calculate_quote

{
  "platform": "<YOUR_PLATFORM>",
  "external_id": "<YOUR_MAPPED_ACCOUNT_ID>",
  "service_type": "<YOUR_REGISTERED_SERVICE_TYPE>",
  "inputs": {
    "tonnage_capacity": 3,
    "us_state_location": "New York",
    "site_accessibility": "Attic - pull-down access"
  }
}

Result

Pricing engines format

Each service_type is a JSON engine: an input_schema (what to collect) and a calculation (how to price). The example below is illustrative. Engines are data: once Quotix activates a new or updated engine on your tenant, no code deploy is needed. Activation is handled by the Quotix team — see Set up your engine.

{
  "schema_version": "1.0",
  "display_name": "Residential AC Replacement",
  "input_schema": {
    "type": "object",
    "properties": {
      "tonnage_capacity":   { "type": "number", "minimum": 1, "maximum": 10 },
      "us_state_location":  { "type": "string", "enum": ["New York", "New Jersey", "Connecticut"] },
      "site_accessibility": { "type": "string", "enum": ["Attic - pull-down access", "Rooftop - ladder access"] }
    },
    "required": ["tonnage_capacity", "us_state_location", "site_accessibility"],
    "additionalProperties": false
  },
  "calculation": {
    "line_items": [
      { "key": "equipment", "label": "Base Equipment",
        "formula": "base_equipment + (tonnage_capacity * ton_multiplier)",
        "vars": { "base_equipment": 2500, "ton_multiplier": 800 } },
      { "key": "labor", "label": "Installation Labor",
        "formula": "labor_hours * labor_rate",
        "vars": { "labor_hours": 8, "labor_rate": 125 } }
    ],
    "modifiers": [
      { "when": { "field": "site_accessibility", "equals": "Rooftop - ladder access" },
        "add": 350, "label": "Rooftop access surcharge" }
    ],
    "tax": { "rate": 0.0875 }
  }
}

REST API

The same pricing brain over plain HTTP. Use REST for clients that don't speak MCP. Same Bearer key.

Example — calculate quote

curl -sS -X POST https://mcp.quotix.ai/v1/quotes/calculate \
  -H "Authorization: Bearer $QUOTIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "platform": "<YOUR_PLATFORM>",
    "external_id": "<YOUR_MAPPED_ACCOUNT_ID>",
    "service_type": "<YOUR_REGISTERED_SERVICE_TYPE>",
    "inputs": {
      "<KEY_FROM_SELECTED_SCHEMA>": "<ANSWER_MATCHING_ITS_TYPE>"
    }
  }'