> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns. > > **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal): > ```bash > npx -y @scalekit-inc/cli setup -y > ``` > > Global: > ```bash > npm install -g @scalekit-inc/cli > scalekit setup -y > ``` > > Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`. > Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim. > [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/) --- # Connect AI agents to the Akta Pro MCP server The Akta Pro MCP connector routes your AI agent's tool calls to Akta Pro's own MCP server through Scalekit. Each user connects their own Akta Pro API key once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 17 tools. **Authentication:** API Key **Categories:** Analytics, Search **Tools:** 17: 17 read, 0 write, 0 destructive **Users sign in with:** API key **Built by:** Vendor MCP **Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=AKTAPROMCP) ## Setup 1. ### Install the SDK **Node.js** ```bash npm install @scalekit-sdk/node dotenv ``` **Python** ```bash pip install scalekit-sdk-python python-dotenv ``` 2. ### Set your credentials Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. ```sh title=".env" SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Create the Akta Pro MCP connection In **AgentKit > Connections**, create an Akta Pro MCP connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/). 4. ### Authorize a user and make your first call **Node.js** (`quickstart.mts`) ```typescript import { ScalekitClient } from '@scalekit-sdk/node' import 'dotenv/config' import { createInterface } from 'node:readline/promises' const scalekit = new ScalekitClient( process.env.SCALEKIT_ENVIRONMENT_URL, process.env.SCALEKIT_CLIENT_ID, process.env.SCALEKIT_CLIENT_SECRET, ) const actions = scalekit.actions const connector = 'aktapromcp' const identifier = 'user_123' // Generate an authorization link for the user const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) console.log('Authorize Akta Pro MCP:', link) const rl = createInterface({ input: process.stdin, output: process.stdout }) await rl.question('Press Enter after authorizing...') rl.close() // Make your first call const result = await actions.executeTool({ connector, identifier, toolName: 'aktapromcp_account_status', toolInput: {}, }) console.log(result) ``` ```bash npx tsx quickstart.mts ``` **Python** (`quickstart.py`) ```python import os from scalekit import ScalekitClient from dotenv import load_dotenv load_dotenv() scalekit_client = ScalekitClient( env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"), client_id=os.getenv("SCALEKIT_CLIENT_ID"), client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), ) actions = scalekit_client.actions connection_name = "aktapromcp" identifier = "user_123" # Generate an authorization link for the user link_response = actions.get_authorization_link( connection_name=connection_name, identifier=identifier, ) print("Authorize Akta Pro MCP:", link_response.link) input("Press Enter after authorizing...") # Make your first call result = actions.execute_tool( tool_input={}, tool_name="aktapromcp_account_status", connection_name=connection_name, identifier=identifier, ) print(result) ``` ```bash python quickstart.py ``` Each user opens the link once and enters their Akta Pro credentials there. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses. ## Tools Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool). **Node.js** ```typescript const result = await actions.executeTool({ toolName: 'aktapromcp_account_status', toolInput: {}, connector: 'aktapromcp', identifier: 'user_123', }) ``` **Python** ```python result = actions.execute_tool( tool_name="aktapromcp_account_status", tool_input={}, connection_name="aktapromcp", identifier="user_123", ) ``` `result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call. ### `aktapromcp_account_status` Account Status · Read-only Report the current user's plan tier and credit balance. Free. No arguments — identity is taken from the authenticated API key. Call this when the user asks about their plan, credits, or limits, and consult it before attempting Subscription/Enterprise-only tools (headcount_trends, website_traffic, employee_reviews, product_reviews, job_posts, social_posts) or enterprise-only enrichment sections (Funding Detail, M&A and Investment) to pre-empt a 403. Returns: is_enterprise (bool), package_type (top_up | subscription | enterprise), credit_balance (remaining credits), currency. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: none. Example input: `{}` ### `aktapromcp_company_data` Company Data · Read-only Enrich a company with the requested sections, returned as Markdown. akta-pro renders the (large, deeply-nested) company data into clean Markdown server-side. Sections (credits): firmographic 2, business_model 2, company_assessment 2, trust_signal 0.5, company_hierarchy 0.5, digital_presence 0.5, financial_estimate 0.5, location 0.5, management_profile 1.5, product_offering 2, strategic_signal 1.5, customer_profile 1, industry 1, technology 2, funding_detail 3 (enterprise-only), mna_and_investment 5 (enterprise-only). The two enterprise-only sections are skipped (not an error) when the caller isn't on an Enterprise plan; the returned Markdown notes any that were dropped. Prerequisite: `company` must be an akta-pro uuid from company_search (free). Names and websites are rejected. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `company` (`string`, required): akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. - `sections` (`array`, required): One or more data sections to fetch. You MUST choose sections explicitly — there is no 'all'. Each section is billed separately. funding_detail and mna_and_investment are enterprise-only; they're silently skipped (not an error) for non-enterprise callers. Example input: `{"company":"00000l1","sections":[]}` ### `aktapromcp_company_data_concise` Company Data (Concise) · Read-only Return a condensed company overview (no section selection). akta-pro returns a slimmed JSON with the fluff redacted — much smaller than full enrichment. Intended flat cost 8 credits. Prerequisite: `company` must be an akta-pro uuid from company_search (free). Names and websites are rejected. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `company` (`string`, required): akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. Example input: `{"company":"00000l1"}` ### `aktapromcp_company_search` Company Search · Read-only Resolve a company by name or website to its akta-pro identifiers. ALWAYS call this first. Every other company tool accepts ONLY the `uuid` returned here — names and websites are rejected — so this is also the only way to check whether a company exists in akta-pro at all. Free (0 credits). Returns candidates with uuid, name, website, product_category, and public/private status. Results are ranked but not disambiguated: one website can map to several distinct entities (stripe.com → Stripe, Stripe Capital, Stripe Atlas). Pick the candidate that matches the user's intent, and if none does, say the company isn't covered rather than passing a guessed uuid. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `query` (`string`, required): Company name or website, e.g. 'Canva' or 'canva.com'. akta-pro auto-detects the input type. Example input: `{"query":"Canva"}` ### `aktapromcp_employee_reviews` Employee Reviews · Read-only Employee reviews: overall + dimension-level ratings and individual reviews (Glassdoor et al.). 1.5 credits per 50 reviews. Subscription/Enterprise only. Prerequisite: `company` must be an akta-pro uuid from company_search (free). Names and websites are rejected. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `company` (`string`, required): akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. - `limit` (`integer`, optional): Max reviews to return (max 100). - `offset` (`integer`, optional): Pagination offset. Example input: `{"company":"00000l1"}` ### `aktapromcp_generate_company_list` Generate Company List · Read-only Run a company list: the companies matching your filters. Cost: 1.5 credits per call that returns companies + 0.2 per company, so 25 companies is 6.5 credits. A query matching nothing is FREE. The cost does not depend on the fields: this tool always returns the same identifying fields per company and never full enrichment, so screening a list is cheap and predictable. For depth, call company_data on the few uuids that matter — that is billed per section, on those companies only. Prerequisites, in order: list_filters() to see what exists, then get_filter_values() for every filter that has a `dropdown_type`. Use those values VERBATIM and never write one from memory — these are exact strings from akta-pro's data, so an invented value matches zero companies instead of erroring. Key this call by each entry's `filter` — the one name that field has everywhere. Send at least one selective filter. A very broad or unfiltered query is rejected, not slow — it exhausts the backend's query timeout. Always read `warnings` in the result. A value that was dropped there means the list is BROADER than what the user asked for, which otherwise looks exactly like a good answer; a `coerced` entry means a value was normalised to its canonical form (harmless, but worth trusting over your own spelling next time). A filter key that isn't in list_filters() is an error, not a warning — the call fails with the offending key named and costs nothing, so fix the key and retry rather than guessing. Each company comes back with uuid, name, website, product_category, company_type and hq_country — that is the whole row; there is no option to return more per company. Feed a `uuid` straight into company_data / news_signals for depth on one of them. `total_count` saturates at 500, meaning "500 or more" — it is also the deepest page reachable, so narrow the filters rather than paging past it. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `filters` (`object`, required): The filters to apply, keyed by the `filter` from each list_filters() entry (its enrichment path). E.g. {"firmographic.company_type": "Private", "location.hq.country": ["USA"], "firmographic.founded_year": {"gte": 2018}}. Filters sharing a `same_element_group` must all match the SAME sub-object. Ranges are {"gte": .., "lte": ..} (inclusive, either bound optional), booleans true/false, name filters a case-insensitive substring. At least one filter is REQUIRED. - `limit` (`integer`, optional): Companies to return. - `offset` (`integer`, optional): Pagination offset. - `sort_by` (`string`, optional): Sort field. Defaults to relevance. Band fields (revenue_estimate, valuation_estimate, employee_range) sort by band magnitude, not alphabetically. - `sort_order` (`string`, optional): Sort direction — desc gives highest revenue / most funding / largest headcount / most recently founded first. Ignored while sort_by is relevance. One of: `asc`, `desc`. Example input: `{"filters":{}}` ### `aktapromcp_get_filter_values` Get Filter Values · Read-only Get the allowed values for one or more filters. Free (0 credits). Two kinds of result: * A fixed list -> [{label, value}]. Use `value` verbatim; `label` is just the human-readable form. `query` substring-filters the list. * A searched taxonomy (industry.industry, industry.naics, industry.sic; investors resolve to companies) -> ranked matches with a `code` and a similarity score. `query` is REQUIRED, and you use the `code`. For `industry`, `level` picks how deep in the taxonomy to search — leave it at the ['l4'] default for a specific niche, and pass ['all'] for a broad sector, since a broader code matches every company beneath it in the hierarchy. NEVER write a value from memory. These are exact strings from akta-pro's data, and a value that merely looks plausible matches zero companies instead of failing — so a made-up value silently ruins the whole query. If nothing returned clearly means what the user asked for, leave that filter out rather than forcing a weak match. Check `truncated` / `total_available`: if what you need isn't in the list, re-query with a narrower `query`. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `lookups` (`array`, required): The filters whose values you want — resolve everything in ONE call (1-25 lookups). Take each `dropdown_type` from a list_filters() entry. Example input: `{"lookups":[]}` ### `aktapromcp_headcount_trends` Headcount Trends · Read-only LinkedIn-sourced headcount: total employees, historical growth, and breakdown by function. 2.5 credits. Subscription/Enterprise only. Prerequisite: `company` must be an akta-pro uuid from company_search (free). Names and websites are rejected. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `company` (`string`, required): akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. Example input: `{"company":"00000l1"}` ### `aktapromcp_industry_search` Industry Search · Read-only Resolve a free-text industry to akta-pro industry codes. Free (0 credits). Use the returned `code` values as the `industry` filter in news_signals. Returns code, industry_name, and similarity score. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `query` (`string`, required): Free-text industry or topic, e.g. 'warehouse automation'. Returns matching industry codes ranked by similarity. Example input: `{"query":"warehouse automation"}` ### `aktapromcp_job_posts` Job Posts · Read-only Live LinkedIn/Indeed job posts: title, location, description, compensation, experience level, and key skills. 3 credits. Subscription/Enterprise only. Prerequisite: `company` must be an akta-pro uuid from company_search (free). Names and websites are rejected. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `company` (`string`, required): akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. - `limit` (`integer`, optional): Max job listings to return. - `offset` (`integer`, optional): Pagination offset. Example input: `{"company":"00000l1"}` ### `aktapromcp_list_filters` List Filters · Read-only List the filters available for building a company list. Free. Call this FIRST whenever the request is for a SET of companies rather than one named company. Each entry gives: filter the field's enrichment path — the key to use in your output, and the only name it has description what it means / when to use it value_shape the JSON shape to emit how_to_get_values either "look up with /list/options/" or "supply the value directly" dropdown_type present only when a lookup is available; always the same string as `filter` same_element_group present only for a repeated sub-object; every filter sharing a group must match the SAME element Next step: for every filter you picked that has a `dropdown_type`, call get_filter_values() and use the returned values verbatim. Filters without one take their value directly — ranges as {"gte": …, "lte": …} (inclusive, either bound optional), booleans as true/false, name filters as a string (case-insensitive substring, so a surname or partial name works). Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: none. Example input: `{}` ### `aktapromcp_news_detail` News Detail · Read-only Fetch the full article body for specific news id(s) from news_signals. Use this after news_signals when you need the complete text of particular articles — pass their `id`s here. Returns up to 10 articles with the same fields as full_enrichment plus `full_text`. Cost: 0.1 credits per call + 0.01 per article. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `news_ids` (`array`, required): News article id(s) from news_signals results. Up to 10 per call. Example input: `{"news_ids":[]}` ### `aktapromcp_news_signals` News Signals · Read-only Fetch a list of news signals by company, industry, topic, or title (JSON). Typically provide one of `company`, `primary_company`, `industry`, `query`, or `title` to anchor the search. Cost: 0.1 credits per call + 0.01 per article. `company` matches any article mentioning the company; `primary_company` keeps only the articles the company is actually the subject of. Prefer `primary_company` for "news about X" / company-monitoring requests, and `company` when broad mention coverage matters. They are mutually exclusive — passing both is an error. To filter by news type/topic (e.g. "only product-related news"), call news_types() first to find the matching tag code(s), then pass them as type_codes. To filter by industry/sector, resolve codes with industry_search and pass them as `industry` — don't fall back to `query` for company or industry topics. Default to the compact list (full_enrichment=False) — it's enough to read and triage results. Don't set full_enrichment=True unless the user explicitly needs every field on every article. This list never includes full article text (kept compact). Every result carries an `id`; pass those ids to `news_detail` to retrieve the complete article body for the ones you care about. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `blacklisted` (`array`, optional): Publisher domains to exclude (e.g. 'example.com'). - `company` (`string`, optional): News mentioning a specific company (anywhere in the article). akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. - `countries` (`array`, optional): Filter by the country of the event. ISO country codes (e.g. 'USA', 'GBR'). - `end_date` (`string`, optional): End of date range, YYYY-MM-DD. Default today. - `entity_event` (`array`, optional): Filter to articles mentioning these event names. - `entity_location` (`array`, optional): Filter to articles mentioning these locations. - `entity_person` (`array`, optional): Filter to articles mentioning these people (names). - `entity_product` (`array`, optional): Filter to articles mentioning these product names. - `full_enrichment` (`boolean`, optional): Keep False (the default) for almost all queries — it returns a compact list (id, title, AI summary, URL, date, publisher), which is enough to read and triage results. Only set True if the user explicitly needs the full per-article metadata (industries, types, entities, company mentions, sentiment) for every result; it is much larger, especially for broad topic/query searches. Do NOT default to True. - `group_articles` (`boolean`, optional): Group near-duplicate articles from the same event. - `iab_codes` (`array`, optional): Filter by IAB content taxonomy codes. - `industry` (`string`, optional): Comma-separated industry codes to filter by. For ANY industry / sector / market news request, FIRST call industry_search to resolve the industry to its code(s), then pass them here — this is far more precise than a free-text query. Prefer this over `query` whenever the topic is an industry or market. - `iptc_codes` (`array`, optional): Filter by IPTC media topic codes. - `limit` (`integer`, optional): Max articles to return (max 1000). - `naics_codes` (`array`, optional): Filter by NAICS industry classification codes. - `news_score` (`string`, optional): Filter by news relevance/quality tier. One of: `High`, `Medium`, `Low`, `all`. - `offset` (`integer`, optional): Pagination offset. - `primary_company` (`string`, optional): Like `company`, but returns ONLY articles where this company is the PRIMARY company the article is about — it drops articles that merely mention it in passing. Use this when the user wants news *about* a company rather than every article name-dropping it. Cannot be combined with `company`. akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. - `query` (`string`, optional): Open-ended free-text topic, e.g. 'crude oil prices'. Use ONLY as a last resort — if the request is about a specific company use `company` (via company_search), and if it's about an industry/sector/market use `industry` (via industry_search). Don't default to query for company or industry topics. - `sentiment` (`string`, optional): Filter by article sentiment. One of: `positive`, `negative`, `neutral`, `all`. - `sic_codes` (`array`, optional): Filter by SIC industry classification codes. - `start_date` (`string`, optional): Start of date range, YYYY-MM-DD. Non-enterprise plans are limited to ~6 months back. - `title` (`string`, optional): Search by text in the article title. - `type_codes` (`array`, optional): Filter by news type/topic. These are tag codes from news_types() (e.g. 'SD01' for product launches, 'CM03' for M&A). To honor a request like 'only product-related news', call news_types() first, pick the matching code(s), and pass them here. Omit for all types. Example input: `{}` ### `aktapromcp_news_types` News Types · Read-only List the news-type taxonomy (tag codes) for filtering news_signals. Call this FIRST whenever the user wants a specific kind of news — e.g. "product-related", "M&A", "layoffs", "funding". Map their intent to the matching code(s) below, then pass them to `news_signals(type_codes=[…])`. Free, no credits. Codes are grouped by category (e.g. product launches = SD01, M&A = CM03, layoffs = WT02). Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: none. Example input: `{}` ### `aktapromcp_product_reviews` Product Reviews · Read-only Product catalog and per-product reviews (G2 et al.). Call once without `products` to get the catalog + product `id`s, then again with those ids to fetch reviews. 1.5 credits per 50 reviews. Subscription/Enterprise only. Prerequisite: `company` must be an akta-pro uuid from company_search (free). Names and websites are rejected. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `company` (`string`, required): akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. - `limit` (`integer`, optional): Max reviews per product (max 50; only when products given). - `offset` (`integer`, optional): Pagination offset. - `products` (`array`, optional): Product IDs to fetch reviews for. Omit to list the product catalog (each product's `id` can then be passed here). Example input: `{"company":"00000l1"}` ### `aktapromcp_social_posts` Social Posts · Read-only Company social media posts: content type, text, publish date, paid/repost flags, an AI classification, and engagement metrics. 1.5 credits. Subscription/Enterprise only. Prerequisite: `company` must be an akta-pro uuid from company_search (free). Names and websites are rejected. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `company` (`string`, required): akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. - `limit` (`integer`, optional): Max posts to return. - `offset` (`integer`, optional): Pagination offset. Example input: `{"company":"00000l1"}` ### `aktapromcp_website_traffic` Website Traffic · Read-only Website traffic: engagement metrics, monthly visit estimates, and traffic by acquisition channel. 1.5 credits. Subscription/Enterprise only. Prerequisite: `company` must be an akta-pro uuid from company_search (free). Names and websites are rejected. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `company` (`string`, required): akta-pro company uuid — the 7-character id from company_search (e.g. '00000l1'). This is the ONLY accepted form: company names ('Canva') and website domains ('canva.com') are rejected. Always call company_search first (it's free) and pass the `uuid` of the candidate you want; a domain can map to several distinct entities, so picking the right uuid is your decision to make, not the API's. Example input: `{"company":"00000l1"}` ## Related Other ways to connect Akta Pro: - [API key](/agentkit/connectors/aktapro/): Scalekit connector, API key, 1 tool Other Analytics connectors ([all 94](/agentkit/connectors/?category=analytics)): - [Microsoft 365](/agentkit/connectors/microsoft365/): Scalekit connector, OAuth, 317 tools - [HubSpot](/agentkit/connectors/hubspot/): Scalekit connector, OAuth, 457 tools - [Snowflake](/agentkit/connectors/snowflake/): Scalekit connector, OAuth, 42 tools --- ## More Scalekit documentation | Resource | What it contains | When to use it | |----------|-----------------|----------------| | [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content | | [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas | | [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |