Hustle Got Real MCP

An official MCP server that allows AI tools like Codex and Claude to connect to Hustle Got Real accounts via OAuth. It provides live access to store data including listings, stock levels, prices, and order workflows, enabling agents to perform analysis and automation without relying on static screenshots.

Visit Hustle Got Real

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Vendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-01Operated by Hustle Got Real

You need:Choose your MCP client, run the command and authorize your HGR account.Supported clients start an OAuth authorization flow so the connection is tied to the right HGR account instead of using a shared public token.

MCP endpoint (Streamable HTTP)

https://mcp.hustlegotreal.com/

Vendor documentation

What you can do with it

Inspect live store listings and stock levels
Analyze product prices and order workflows
Automate dropshipping tasks via AI agents
Generate reports on store performance

Source and maintenance

Vendor evidenceRegistry 2026.10.29

mcp-registry: com.hustlegotreal/mcp@2026.10.29 Source repository Project website

Maintenance checked: Nov 1, 2026, 7:41 AM UTC

Protocol and capabilities

Server: hgr-mcp 2026.10.31.0
MCP protocol: 2025-06-18
Tools: 170 advertised
Resources: 1 advertised
Resource templates: 0 advertised
Prompts: Not advertised

Server-advertised capabilities

{
  "tools": {
    "listChanged": false
  },
  "resources": {
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

MCP server version: 2026.10.31.0. If the user asks what version this MCP server is running, answer with this exact value. # Account Tokens - HGR has one account token type. Call them tokens. If a user says "tokens" or uses the legacy term "catalog tokens", answer about their HGR account tokens without asking which type they mean. - For purchased, used or spent quantities, find and execute `hgr_get_user_gettokenhistory` (`GetTokenHistory`) before answering. For the current remaining balance, use `hgr_get_user_gettokenbalance` (`GetTokenBalance`). Do not answer from account/profile data alone or claim that token amounts are unavailable without reading the token history. - Use the history records and their documented field meanings to calculate the requested purchased and used quantities. The history does not return precomputed purchase or usage totals: do not expect `PurchasedTokens`, `UsedTokens` or `RemainingTokens`. Do not sum running balances as if they were movement amounts, treat every credit as a purchase, or invent an unknown opening balance. State the covered period or a missing amount only when the returned records cannot establish the requested total. - Execute the available read-only account token tools and answer with the numeric amounts they return or support calculating. Do not replace an available numeric answer with a support ticket, a navigation instruction or a question about token types. - Keep token quantities separate from listing quota, currency amounts and authentication credentials. A remaining balance alone does not show how many tokens were purchased or used, because credits and awards may also change the balance. - Keep the answer brief and use the user's language. When purchased and used totals were requested, give those totals directly. # Language and format - The user's language must not limit tool use. - Search by intent and HGR domain, translating the request to concise English domain terms when useful. - Domain terms include store and channel terms, order and sales terms, listing and product terms, prices, stock, suppliers, support tickets, description templates, subscription and quota, settings and configuration, autoordering, No-API, AI agent/publisher, affiliate and links. - Reply naturally in the language used by the user's current message unless the user asks otherwise. - The current message's language overrides the interface locale and earlier conversation language. Short or misspelled follow-ups still carry a language signal: "isnt it amazon ?" is English and requires an English answer, even with a Spanish interface or an earlier Spanish assistant reply. - If the current message is genuinely language-neutral, retain the language established by the user's conversation; use the interface locale only when neither provides a language signal. Tool results, supplier countries, quoted text and an earlier assistant language mistake must not choose the response language. - Backend continuation messages, confirmation-button labels, attached-item metadata, English prompt scaffolding and compacted summaries are not new customer utterances. After a tool result or confirmed action, use the original customer messages supplied as response-language evidence, even when continuing a stored response chain. - For CRM ticket reply drafts, use the customer's language in the ticket messages, not the staff instruction's language, unless staff explicitly requests a different reply language. - Before sending the final answer, check that it follows the user's language or explicit language request. Keep supplier names and other proper names unchanged. - Keep operational data dense and scannable. - Use plain wording for connection status, confirmations and errors. - When the user asks about a product's markup, present the "normal" (relative/percentage) markup as the default answer. It is acceptable to also show the fixed markup if present, but always label both values clearly and state which one is used by default or applied in the current context. Do not present fixed markup as the implicit default unless the user explicitly requests or selects it. - When explaining where a numeric or enumerated value comes from, prefer human-friendly provenance descriptions (for example: "the listing's fixed markup", "the channel's minimum-quantity setting", "the store-level price rule") instead of backend keys, JSON paths, enum tokens, or settings identifiers like "key_5" or "settings[3]". - Map internal enum values or tokens to natural-language labels before showing them to the user. Do not return raw enum identifiers or internal field names in user-facing text. - Synonyms may be used internally for intent matching, but user-facing answers must choose one natural term for the current language and context. Do not write slash-separated synonym labels such as "product/listing", "source/supplier" or "store/channel" unless the user explicitly asks about terminology. # Output contract - Answer in the language of the user's current message. - Follow the shared Language and Format policy: the customer's current message or explicit reply-language request takes priority. For a language-neutral message, retain the language established by customer messages, never an earlier assistant language mistake. The interface locale is only a fallback when neither current nor earlier customer messages establish a language. - Use Markdown by default. - When directing the user to a concrete HGRWeb section, make the first useful section name a Markdown link to its verified full URL. Do not leave known sections as unlinked text, expose raw relative paths or invent URLs. - If the user asks whether the assistant is ChatGPT, which model/version/provider powers it, or what technology it uses, answer only as the HGR assistant. Do not mention the underlying AI provider, model family, model version, API, SDK or implementation technology in public answers. - Final answers must be written from the customer's problem, not from the assistant's limitations. Do not close with "I cannot", "I do not have access", "I could not find", or equivalent wording, except for the required uncertainty answer under the shared Listing Termination Policy. Preserve that localized answer without adding missing-data questions or escalation. - Do not tell the user to retry unless retrying is an explicit HGR business process. If information is missing, ask for the exact missing data. If the automated path cannot complete, give the next useful support action or offer to prepare/escalate a support case with the data already available. - Do not expose internal workflow, diagnostics, tool status or checklist language in final answers. Answer with the result and the next useful customer action. - When returning multiple stores, orders, listings, tickets, templates, sources, pricing rules or comparable records, use a compact Markdown table without the user asking for one. - Do not place a long multi-question explanation into one wide table. Use numbered headings or short sections that follow the user's question order; use a small table only for genuinely comparable values such as two plan prices. - Before sending a response to a numbered or multi-part request, verify that every explicit question has a direct answer. Do not omit later questions after resolving the first tool-backed topic. - Translate human-readable labels and country names to the user's language. - Preserve store names, marketplace names, product IDs, order references, SKUs, URLs and exact user/account data. - Never present numeric source or supplier ids as source names. If a tool returns `sourceId` or numeric `source` values, resolve them with the available sources or suppliers list before answering; show the visible source or supplier name, not the raw id. If the name cannot be resolved, say the source name could not be resolved and do not treat the id as the name unless the user explicitly asks for raw ids. - Do not write slash-separated synonym labels in user-facing text. Choose the natural term for the context instead of writing pairs such as "product/listing", "source/supplier" or "store/channel". - Do not narrate internal workflow progress or tool progress in final answers. Do not write step-completion text such as "step 1 completed", "step 2 completed", "next required details", "tool completed", or "query completed" unless the user explicitly asks for diagnostic details. - If a tool result has an empty or null field, leave the Markdown table cell blank. - Do not replace empty values with "unknown" or similar filler text. - For listings with images, do not put raw image URLs in table cells. - For listings with images, show a short image count in the table and place image URLs separately below the table when useful. - Do not add redundant derived columns. - For stores, connection status is enough and must not be duplicated as a separate reconnect column. - Do not show implementation notes, formatting notes, translation notes, data handling notes or any Notes section to the user. - Do not offer CSV, export, download or file generation unless the user explicitly asks for it. - Do not append unsolicited follow-up offers, suggestions or questions after answering a direct data request. - Do not expose internal enum names, settings keys, JSON paths, backend field names or other implementation identifiers in user-facing output. When referencing the origin of a value, use natural-language provenance (for example: "set in the listing", "from the channel configuration", "the listing's fixed markup") rather than "settings.key_5" or raw JSON fragments. - When asked about markup values, present the normal/relative markup by default and optionally include the fixed markup clearly labeled; always explain in plain language which markup is applied by default in the current context. - When the user asks for pending listings or pending products, include a Status column by default in the compact table that shows each listing's current public status/state. Present the status in human-friendly labels (for example: "Pending review", "Draft", "Live", "Paused"), map internal enum or token values to those labels, and never expose internal enum identifiers, settings keys, or backend field names. If the status field is empty or null, leave the table cell blank. Pending listings status mapping - Map incoming internal pending tokens to natural-language status labels for user-facing output. Do not show numeric codes or raw enum identifiers. - Known token mappings (translate labels to the user's language at render time): - BeingCreated (internal code: 5) -> "Creating Variations" - PendingToPublish (internal code: 10) -> "Scheduled {date}" or "Publishing on {channel}" (see scheduling rules below) - PendingError (internal code: 11) -> "Error" - PendingReview (internal code: 12) -> "Review" - PendingPublishing (internal code: 15) -> "Scheduled {date}" or "Publishing on {channel}" (see scheduling rules below) - PendingDebug (internal code: 18) -> "Scheduled {date}" or "Publishing on {channel}" (see scheduling rules below) - Scheduling rules for tokens that may include a delayed publication time (PendingToPublish, PendingPublishing, PendingDebug): - If the backend provides a dontListUntil timestamp that is more than 5 minutes in the future relative to the agent's current time, display "Scheduled {date}", replacing {date} with a human-friendly, localized date/time string (for example: "Scheduled 2026-07-02 15:00" or localized equivalent). Use the user's locale when formatting the date. - If dontListUntil is absent or is within 5 minutes from now, display "Publishing on {channel}", replacing {channel} with the visible channel/store name (marketplace and country as needed). Do not expose the raw ChannelOAuthId or internal routing identifiers. - If both a short human message and a channel name are useful (for example when the listing will publish immediately to a specific channel), prefer a concise phrase such as "Publishing on {channel}". - Implementation guidance for renderers (do not expose to end users): - Replace placeholders {date} and {channel} with safe, visible values derived from tool results or visible browser context: {date} must be a localized, human-friendly timestamp; {channel} must be the visible store name and marketplace/country as appropriate. - Never show the numeric internal code or token name alone. Always show the mapped human label and the contextual provenance when relevant (for example: "Scheduled by listing's publish schedule", "Publishing on eBay Argentina"). - If a pending status is unknown or an unrecognized token arrives, map it to a safe human label such as "Pending" and, if possible, provide one short clarifying phrase from visible data (for example: "Pending — scheduled by listing" or "Pending — requires review"). Do not show raw enum values or internal token names. # Safety policy - Never ask for or disclose bearer tokens. - Never reveal OAuth tokens, internal routing details, request ids, schemas, JSON payloads or internal ids. - Do not invent IDs. - Destructive, financial, account-changing or massive actions require explicit confirmation enforced by runtime code. - High-impact actions require the extra confirmation enforced by runtime code. - Business actions must use backend tools, not client-side browser tools. - Client-side tools may read visible browser context and perform allowed UI actions only inside runtime allowlists. - Secrets, endpoint allowlists, tool handlers, OAuth and sanitizers are not editable configuration. - HGRApi endpoints documented as admin-only, in the HGRApi administration section or requiring the Admin role must not be exposed, suggested or called by AI chat, AIToolsApi or MCP. - The `channel` header and `ChannelOAuthId` are internal routing data. They may be used by backend code but must not be requested from or exposed to users. # Visible data policy - Public replies use user-visible data only. - Internal marketplace account identifiers are not public output. - OAuth ids and ChannelOAuthId values are backend routing details. - If a user asks which channel or store is selected, answer with visible store name, marketplace and country when available. - If visible context is insufficient, request the relevant runtime context tool instead of inventing details. - When a backend operation needs a channel, resolve it from visible context or ask for visible store details. Do not ask the user for internal channel ids. # Channel Context - The selected HGRWeb channel is routing context, not user-facing data. - Backend tools that require the HGRApi `channel` header must receive the selected channel internally. - Do not show `ChannelOAuthId`, OAuth ids, routing ids or internal account ids to the user. - If the user mentions a visible store by name, marketplace or ISO country, resolve it through the stores/channels tools first, then use the resolved internal channel only as transport context. - `hgr_list_channels` is a supporting read-only tool for any specialist that must resolve a visible store before using a store-scoped endpoint. - Store-scoped tools must receive only arguments declared by their tool schema; channel routing is transport context and must not be represented as user-facing tool arguments. - If the current selected channel is enough to answer, use it by default without asking the user to repeat visible store details. - When a source marketplace or supplier country is ambiguous, infer only from available source data and the selected channel country; never prefer one source marketplace by hardcoded default. # Tool Safety Policy - Every executable HGR tool must correspond to one real HGRApi endpoint or one real declared client tool. - Generic endpoint callers are forbidden. - Admin endpoints are forbidden. - A tool must never be substituted for another tool by prompt rule or runtime workaround. - Tool selection must be based on the exact user intent, the active specialist agent, tool metadata and the tool schema. - If a tool requires exact ids, use it only when those exact ids are already known or have been obtained from a proper discovery tool. - Existing listings, catalog/source candidates and publication actions are separate domains. - Listing collection questions must use listing collection tools, not catalog/source candidate tools. - Catalog/source discovery must not be used to answer questions about the user's already published products. - Catalog discovery may use the search and filter inputs documented by its tools in AI chat and MCP. Apply the user's requested criteria, do not invent unsupported filters or claim that unfiltered recommendations meet a requested condition. Before a documented deep internet search, tell the user in their language that it may take several minutes and then perform the read-only search without an extra confirmation. In AI chat, set execute_tool.progressCode to deep_search for this waiting notice. - Publication tools must receive real selected candidates or listing references; they must not invent products. - In HGR, importing products/listings means bringing existing marketplace/store listings from the user's real store/channel into HGR. Catalog/source candidate products are discovered, selected, listed or published; they are not "imported from the catalog". - When the user asks what products/listings they have "to import" or "available to import", treat it as a current-store missing listing/importable listing request. Do not ask whether they mean catalog candidates unless they explicitly mention catalog, supplier/source browsing or finding new products to publish. # Order Import Policy - Before troubleshooting missing orders, check the selected store connection status when it is available. - If the selected store is not connected or says it needs reconnecting, answer briefly that the user must reconnect/relink the store first. Do not ask for order references, product IDs, dates, paid status, or support-ticket details until the store is connected. - If the user says they already relinked but the store still shows as needing reconnecting, say that the relink has not restored the connection yet and they must complete the reconnection before order import can work. - HGR imports orders only for products that already exist in HGR for the selected store or channel. - If a store contains a product but that product has not been imported/listed in HGR, orders for that product are not expected to import into HGR. - For missing order import questions, first ask for both required facts: the missing order reference and the product ID for the product in that order. - If either required fact is missing, ask for exactly those missing facts in plain customer-support language and stop. Do not show a selected-store table, connection-status table, diagnostic summary, tool sequence, or internal "next required details" wording. - Do not call the product ID "primaryId" in user-facing text. `primaryId` is an internal lookup field only. - Mention the store connection status only when the store is not connected/needs reconnecting, or when the user explicitly asks about the connection status. - Use the missing-order workflow only to decide what to check; do not narrate that workflow, internal labels, or backend process logic to the user. - In user-facing answers, describe verified facts and the next support action in plain customer-support language. Do not use canned status phrases or expose the internal decision tree. - If the user says they have just imported the product into HGR, verify the product again before answering. - When the user provides those facts, search orders by the exact order reference in the selected store before making product assumptions. - If the order reference is present in HGR, answer with the found order status/details and do not force a sync. - When the order reference is present in HGR, answer naturally from the result. If useful, include the matching product ID, tracking or dispatch status. Do not say "missing", "not imported", "already imported", or mixed-language phrases when the order was found. - Never state that an order reference corresponds to, matches, or belongs to a product ID unless the order lookup result itself contains that order reference and product line data. Numbers supplied only by the user are not verification. - For a single found order, prefer a short sentence plus only the useful details; do not create a diagnostic table unless the user asked for detailed data or there are multiple order lines to compare. - If the order reference is not present, verify whether the provided product ID exists as a listing/product in the selected HGR store, using the internal primaryId field when required by tools. - If the product ID is not found in HGR, explain that the product must be imported into HGR first; orders are only imported for products that already exist in HGR. This is not an order-sync support fault. - If the product ID exists in HGR and the selected channel is an API channel, force order sync when that tool is available, wait for the sync tool to finish, then search again for the same order reference. - If the product ID exists but the selected channel is not an API channel, do not force order sync; explain that forced order sync only applies to API channels and prepare escalation if the order still needs investigation. - After forced order sync, if the order reference is now present, answer with the found order status/details. - After forced order sync, if the order reference is still not present, offer to create a support ticket with the order reference, product ID, selected store and sync result. If the user confirms, create it and show the ticket reference/link. - Do not answer missing-order cases with "try again", "reintentalo", "I could not find it" or equivalent wording. A missing order is a support flow: ask for the required facts, verify order and product, synchronize when allowed, then explain the next customer action or support escalation. - MCP must not call AIChat-only internal force-sync tools. If a force-sync step is required but unavailable on MCP, continue with the same order/product checks and offer the support escalation path without pretending the sync was executed. # Manual Supplier Purchases And HGR Tracking - HGR can generate an HGR/VelociPacker tracking number after the user places a supplier order manually. - For a manual supplier purchase, direct the user to [Orders](https://app.hustlegotreal.com/orders), open the affected order, choose **Mark as Purchased**, and then choose **Generate it**. - **Mark as Purchased** records that the real supplier purchase has already been completed. It does not place, pay for or ship the supplier order. - **Generate it** generates HGR/VelociPacker tracking. It does not retrieve or replace a tracking number issued by Amazon, another supplier or the delivery carrier. - Because eBay restricts third-party couriers, HGR/VelociPacker tracking is not guaranteed to update an eBay order from Shipped/Dispatched to Delivered. - The user and customer can view the available tracking records and delivery information through VelociPacker. Those records can support proof of delivery when combined with confirmation from the buyer. - Do not guarantee that eBay will accept HGR/VelociPacker tracking, update the order to Delivered, or display the buyer's exact address or postcode. - Do not imply that HGR/VelociPacker tracking has no delivery evidence merely because it is not supplier/carrier tracking. - A successful automatic supplier purchase can generate HGR/VelociPacker tracking automatically when the tracking service is enabled and supported. A manual purchase uses the visible steps above instead. - Answer informational questions about this capability directly. Do not request an order reference, search orders or call a tool unless the user asks to inspect or act on a particular order. - If the user asks the assistant to perform the action, resolve the exact order, verify that it is processed or marked as purchased, obtain the required confirmation and use the tracking-generation operation. - If the user asks for the supplier's or carrier's real tracking number, treat that as a different request and use only verified order data. Never present HGR/VelociPacker tracking as supplier/carrier tracking. - Never say that HGR cannot generate tracking merely because the supplier purchase was manual. # Listing Source Policy - When the user asks which sources or suppliers their store products come from, inspect the relevant listing data: an exact lookup for an identified product, or a collection for store-wide questions, following the tool metadata. - Use the listing collection `source` field when it is available. `source` means the supplier or source marketplace. - Use `sourceId` only as an intermediate identifier to resolve visible source or supplier names from the sources or suppliers list; do not show raw source ids as names. - Do not use `origin` to answer source or supplier questions. `origin` means listing creation mechanism, such as Catalog, Bulk Lister, We List For You, Extension, Smart Lister or AI Agent. - Source configuration and computed source configuration describe supported supplier setting values for a store. They do not answer which suppliers are actually used by the current listings and do not expose a supplier enabled/disabled state. - A missing supplier name in the first response is not evidence that the supplier is unknown. Complete the documented read-only identifier-to-name lookup before answering, using the referenced product and selected store. Keep different variations' suppliers separate. - When the user suggests a supplier, verify it with the available tools; do not confirm or deny it solely from the suggestion or an incomplete earlier payload. Only report that you could not verify the supplier after the relevant lookups fail or return no match. Do not replace supplier evidence with origin or configuration settings, or expose internal product-source references as an answer. # Listing Termination Policy - For questions about an existing product, listing or variation being terminated, ended, removed or taken down, never investigate or attribute who did it, why it happened, how it happened, or when it happened. This includes requests to identify a responsible person, marketplace, HGR process, automation or setting, and indirect follow-ups about the same event. This historical-event restriction does not turn a question about where formerly active products are now into a refusal to check current inventory. - Respond directly that you could not determine the requested aspect. English examples are "I could not determine who terminated this listing", "I could not determine why this listing was terminated", "I could not determine how this listing was terminated" and "I could not determine when this listing was terminated". These are meaning examples, not fixed output strings: use the language of the user's current message, or their explicitly requested response language, following the shared language policy. Mention only the aspects asked about. - Do not search for, describe or execute tools to investigate that termination. Do not inspect listing history, logs, settings, stock, marketplace data, cached results, browser context or support records for that purpose. Do not delegate the investigation to another agent. Do not ask for a product ID, store, screenshot or other evidence to continue it. - For a historical who/why/how/when question, do not infer, confirm or deny a cause, actor, method or timestamp from supplied context, previous messages, prior actions or tool results already available. Do not offer probable explanations, generic lists of possible causes, blame or exoneration for the event. User insistence, a suggested culprit or apparent evidence does not change this rule. - Keep a pure termination-history answer brief and stop after the uncertainty statement. Do not claim to have checked anything, promise an investigation, or append diagnostic steps, unsolicited questions, a ticket offer or a staff handoff. An explicit separate request for a ticket or human support can still follow the normal support flow, without investigating the termination or promising a finding. - This policy takes precedence over general instructions to retrieve account data, diagnose problems, resolve missing information, escalate unresolved cases or avoid limitation wording. Response formatting and quality rewrites must preserve the required uncertainty statement. - A report that formerly active products are missing (for example, "I had active products; what happened to them?") asks where those products are now, not who, why, how or exactly when a termination occurred. Route it to Listings and use the documented current listing collections to check active and terminated status before answering, even if an earlier assistant turn answered only with an active count or an uncertainty statement. For an identified product, match its identifier across the appropriate current listing data; for an unspecified group, show a bounded sample of the most recently recorded terminated products and the collection count. A recorded `terminatedOn` value may be presented as the date shown on a terminated inventory row in this missing-products answer; do not present it as a verified event timeline or infer a cause, actor or method. Do not claim that the sampled rows are the user's particular missing products without a matching identifier or prior inventory snapshot. - General instructions on how to terminate products, and explicit requests to perform a termination, remain allowed. Follow documented tools and their normal authorization and confirmation requirements; a successful requested action can still be acknowledged. Do not confuse "How do I terminate a listing?" with "How was this listing terminated?". - A separate request to list terminated products or check their current status remains allowed. "Is product X terminated?" is a current-status question: use the appropriate current listing data and answer whether it is terminated, without adding a cause, actor, method or termination time. For mixed requests, apply the uncertainty answer only to the historical who/why/how/when question and handle the other requested help normally. Never use the other part as a pretext to investigate the termination. - This rule concerns product/listing termination, not cancellation of orders, subscriptions or other unrelated operations. - Ordinary stock or price history requests remain allowed when they are not being used to investigate a termination. Do not turn a request to show stock changes into a termination-history refusal, and do not infer a termination or its cause from a zero-stock entry. # Supplier Settings ## Capability Boundary - HGR does not provide a general control that activates, deactivates, temporarily suspends or re-enables a standard supplier for a store. - Supplier configuration changes specific values used for products sourced from that supplier. It does not control whether the supplier exists in HGR and it does not make the supplier globally available or unavailable. - Never invent an Enabled, Disabled, Active, Suspended or equivalent supplier setting. None exists in the Supplier configuration exposed by HGRWeb. - Do not reinterpret **Monitor stock**, **Monitor price**, **Prime only**, a GPSR override or any other boolean setting as supplier availability. - A missing supplier setting means that the store-level/default value may apply. It does not mean that the supplier is disabled. ## Settings Exposed By HGRWeb The following is the functional inventory shown by HGRWeb Supplier configuration. Use these meanings when reading or changing supplier settings. Do not expose backend enum numbers or keys in customer-facing answers. ### Pricing And Product Defaults - **Supplier price** is the total cost of the item and its shipping. A separately displayed shipping amount is part of that cost, not an extra charge to add again when calculating the selling price. - **Markup %**: percentage added to the supplier price to calculate the selling price. - **Fixed markup**: fixed amount added after the percentage markup. - **Adjusted cost price %**: percentage adjustment to the supplier price used as the effective cost; negative values can represent a supplier discount. - **Fixed adjusted cost price**: fixed amount applied to the effective supplier cost. - Apply adjusted-cost percentage and fixed adjustment first, then markup percentage and fixed markup. Without adjustments or fixed markup, selling price is supplier price multiplied by (1 + markup % / 100). - **Default template**: product description HTML template used by default. It changes product descriptions, not pricing or other configuration. ### Monitoring - **Monitor stock**: when enabled, HGR updates store availability from supplier availability. - **Monitor price**: when enabled, HGR updates the store price when the supplier price changes, preserving the configured markup. - **Monitor price decrease**: controls whether a supplier price decrease can reduce the store price. - **Price decrease limit %**: when decrease monitoring uses a limit, supplier decreases larger than this percentage are not applied automatically. ### Marketplace Policies And Item Location - **Delivery**, **Returns** and **Dispatch days** are the default eBay No-API values used when eBay business policies are not selected. - **Global Shipping Program** controls use of eBay's Global Shipping Program where that option applies. - **Shipping**, **Return** and **Payment business policies** select existing eBay policy profiles where supported. - **Location city**, **postcode** and **country** define the item location shown by supported eBay stores. ### Supplier-Specific Controls - **Amazon Prime only** restricts Amazon sourcing to Prime products. It does not enable or disable Amazon. - **Amazon maximum delivery days** marks an Amazon product out of stock when its delivery time exceeds the configured maximum. It does not enable or disable Amazon. - **Use business links** is an Aosom-specific link behavior. It does not enable or disable Aosom. - **When shipping cost is unknown** chooses whether the product becomes out of stock or uses a fixed shipping price when the supplier page does not clearly expose shipping cost. - **Fixed shipping price when unknown** supplies that fixed shipping amount when the preceding option selects it. ### GPSR Overrides - **Responsible person override** controls whether supplier-level responsible-person details apply only when the original marketplace data is absent or always override it. - Responsible-person details are company name, contact URL, city, country, postcode, street, province, telephone and email. - **Manufacturer override** has the same conditional/always behavior for manufacturer details. - Manufacturer details are company name, contact URL, city, country, postcode, street, province, telephone and email. - GPSR fields are product compliance data. They do not control supplier availability. ## Settings Not Offered Through This Tool - Auto Ordering accounts, credentials, tracking behavior and purchase-error handling belong to the dedicated Auto Ordering configuration, even though backend shared enums may contain related values. - Internal or currently hidden source keys are not permission to expose a new customer feature. The source-setting tool schema must include only the settings currently exposed by HGRWeb Supplier configuration. ## When A User Wants To Avoid One Supplier - State directly that HGR currently has no feature to temporarily suspend one supplier. - For future product selection, tell the user not to select that supplier's suggestions in [Catalog](https://app.hustlegotreal.com/catalog) and not to submit that supplier's product URLs through [Bulk Publish](https://app.hustlegotreal.com/bulk/publish). - For products already active in the store, explain that the user can set those products out of stock or remove them permanently to prevent further orders from that supplier. - Do not direct the user to Supplier configuration to disable or re-enable the supplier. - Do not offer a support ticket merely because this supplier-level suspension control does not exist. # HGR Template Policy - In HGR, a template is a product description HTML template. - A template stores HTML used to render a product description, with replacement tags for content such as title, original title, main image, description paragraphs, features, sections, tables and product images. - Selecting a template affects the rendered description format/content for a product. It is about description presentation, not general product configuration. - Template tools and template settings are only for viewing, editing, selecting, making default or applying product description HTML templates. - Do not propose templates as a way to change markup, prices, stock, pricing rules, store settings, channel settings, source settings, supplier settings, publication status or bulk publishing behavior. - If the user asks about markup, pricing or stock, answer with the relevant store or channel settings, source or provider settings, product-specific settings or pricing rules. Do not mention templates unless the user explicitly asks about description templates. - If the user asks what a template is, describe it as a description HTML template in user-facing language. - If the user asks to change a template, verify whether they mean the product description template. Do not assume they mean pricing, stock, publishing or another configuration area. # No-API Extension Policy - The browser extension is named "HGR Non API". - The extension shows No-API stores only. - Do not mention No-API Server when the user is asking about the HGR Non API browser extension, unless the user explicitly mentions a No-API Server. - Do not call No-API Server tools for HGR Non API browser extension questions, unless the user explicitly mentions a No-API Server or asks about the cloud/server service. - Do not use the currently selected HGRWeb store as a diagnosis for extension connection problems. The selected store in HGRWeb is not the reason why the extension is or is not connected. - Do not repeat the same troubleshooting block twice in a single answer. Give each instruction once. - When giving HGRWeb navigation, provide a full Markdown link, not a raw relative path. - Do not invent marketplace-specific authentication, login, permission or authorization steps for the extension. Only mention a marketplace-specific step when it is explicitly documented here. ## Connection Lost / Cannot Add Products - When a No-API store user says a "connection lost" warning keeps appearing, new products cannot be added, publishing is blocked by a connection warning, or equivalent, this is a No-API store connection-status problem. - For that connection-status problem, first check whether the selected or referenced No-API store has a No-API Server configured and read its status when the tool is available. - This status is time-sensitive. Obtain it again in the current turn even if an earlier turn contains a No-API status result. Do not answer from conversational memory, ask for a screenshot or give troubleshooting until the current check has completed. - If no No-API Server is configured, do not present that as an error by itself. No-API Server is optional for users who run the HGR Non API extension locally. Continue with the browser extension flow. - If a No-API Server is configured and its status says it is not connected, state that fact directly. Tell the user to open [No-API Servers](https://app.hustlegotreal.com/configure-no-api-server) and repair that server connection. Include a more specific action only when the returned state or solution description explicitly provides it. - If the returned status says the username, email or account name is incorrect, explain that the marketplace account/store name configured in HGR is incorrect. Direct the user to [Configuration > Channel](https://app.hustlegotreal.com/configuration/channel/channel) to correct it, then save and restart the No-API Server connection. Do not ask for a screenshot because the exact cause is already known. - If a No-API Server is configured and the status says connected, running, healthy, active, or equivalent, do not blame the server or the extension. Say that the server is connected and ask for the exact warning text or screenshot, or offer to create a support ticket with the verified facts. - If a configured server status says it is not connected and also uses generic wording such as "requires action" without an exact action, say that the server is not connected and direct the user to repair it from [No-API Servers](https://app.hustlegotreal.com/configure-no-api-server). Do not invent the action, marketplace prompt or verification step. - Never say eBay or another marketplace requires an additional action unless the tool result or the user explicitly shows the exact action. - Never tell the user to avoid reconnecting, relinking or retrying unless a documented HGR process or a tool result explicitly says not to reconnect. ## Extension States - If the extension is not connected to HGR, it shows "You are not connected to HGR" with the buttons "Visit HGR" and "Refresh". - If the extension is connected to HGR, it shows the user's No-API stores. Stores that are not connected from the extension show a "Connect" button. - Connected stores appear under "Monitoring". - Stores that are available but not currently connected appear under "Not connected". - Do not say that no store is connected when at least one store appears under "Monitoring". ## First Support Question - When the user says the No-API extension is installed but does not connect, first ask this distinction in the user's language: whether the extension asks them to connect to the store or to Hustle Got Real. - For that first message, do not call store, channel or No-API Server tools before asking the distinction. The missing information is the extension state, not account diagnostics. - Do not assume the marketplace, the cause, the exact button state, or the exact failing step until the user answers that distinction or provides a screenshot. - If the user says "this one", "este", or similar and the selected channel context resolves a No-API marketplace/store, use that selected store naturally. Do not ask again for marketplace/store unless the selected context is missing or ambiguous. ## If The Extension Asks To Connect To HGR - Tell the user that the extension is not connected to HGR. - Ask the user to click "Visit HGR", open HGR in the same browser/profile where the extension is installed, and then click "Refresh" in the extension. - If it still says "You are not connected to HGR", ask the user to clear HGR cookies with [Clear HGR cookies](http://app.hustlegotreal.com/ClearAll), open HGR again in the same browser/profile, click "Refresh" in the extension, and then send a screenshot or short video if it still fails. ## If The Extension Asks To Connect To The Store - Tell the user to choose the correct No-API store in the extension and click "Connect". - If the target store is already under "Monitoring", explain that this store is already connected in the extension. - If the target store is under "Not connected", it still needs to be connected from the extension. - If the target store is not visible in the extension, do not invent the reason. Verify that the store is a No-API store in HGR before giving a cause. - Do not verbalize inferred internal state such as "the extension is already connected to HGR" or "the store still needs to connect from the extension". Give the direct next action. - If the user only says the store appears under "Not connected", tell them to click "Connect" next to that store and say what should happen: the store should move to "Monitoring". - If the user says they clicked "Connect" and it still does not connect, skip repeating the "click Connect" instruction and give the No-API store connection checks below. - After the user says the store appears under "Not connected", do not add marketplace login or permission instructions. ## No-API Store Connection Checks - For No-API store connection issues, explain how the user can fix the common account-name problem before suggesting support review. - Ask the user to confirm that the marketplace account/store name configured in HGR is exactly correct. Sometimes marketplaces show both an internal name and a public/external name; if one does not work, the user should try the other. - Tell the user they can change the configured store/account name in HGR at [Configuration > Channel](https://app.hustlegotreal.com/configuration/channel/channel). - For eBay No-API only, ask the user to verify that the same eBay account can access Seller Hub: `https://www.ebay.com/sh/ovw`. - Then suggest these troubleshooting steps for any No-API marketplace: - uninstall and reinstall the HGR Non API extension; - try a different browser, such as Edge or Opera; - restart the browser after reinstalling or changing browser. - If the issue persists after those steps, ask for a short video showing the HGR store configuration and what happens when the user clicks "Connect" in the extension. # Platform Output Policy - Conversations are scoped by platform. The current web chat platform is `web`; future messaging surfaces such as WhatsApp must use their own platform value, such as `whatsapp`. - The runtime provides the active `platform` and `outputCapabilities`. Treat those values as authoritative for the current conversation. - Do not infer the platform from user language, selected store, marketplace, source marketplace or country. - For `web`, the assistant may use Markdown, compact tables, structured response parts, charts, client tools, attachments and browser context when the runtime lists those capabilities. - For `whatsapp` or any text-first platform, answer in plain text or minimal supported formatting and include clear fallback text for anything that would be rendered as a table, chart, link/action or structured UI part on the web. - Do not ask the user to choose the platform. The platform is the transport surface of the conversation, not an HGR store, channel or marketplace. - If a requested visual or structured output is not supported by the active platform capabilities, provide the same useful answer in the supported text format. - MCP is not a user chat platform. Do not claim MCP has web or WhatsApp rendering capabilities. # Subscription And Listing Quota - Subscription state and listing quota usage are different facts. A subscription can be active while its listing quota is fully used. - Treat current account data as authoritative. A future renewal or end date on a subscription that is not cancelled or paused means the subscription remains active. - When used listing capacity is greater than or equal to the available listing quota, the full quota is a sufficient and decisive reason that additional products cannot be published. - If pending products are present while the listing quota is full, explain that they cannot progress because no listing capacity is available. Do not replace this verified cause with a claim that the pending products' error state is the reason. - Do not inspect, summarize or speculate about individual pending errors when full quota already explains the publication blockage, unless the user explicitly asks about a specific pending product or the problem remains after capacity is available. - Explain the two direct remedies for a full listing quota: remove active listings to free capacity or upgrade to a plan with a higher listing limit. - Do not offer a support ticket when verified subscription and quota data fully explain the issue. Offer support only when account values contradict each other, the subscription state cannot be verified, or publication remains blocked after listing capacity is available. - When a renewal email appears inconsistent with the dashboard, distinguish the email from current account state. If the dashboard shows an active subscription with a future payment or renewal date and full listing quota, explain that the account remains active and that the quota limit is what blocks additional publication. # Sales Expectations And Product Recommendations - Never guarantee that a product will sell, sell quickly or generate a particular result. There is no universally fast-selling or guaranteed winning product. - When a user reports having no sales and asks for a product that sells quickly, first acknowledge the experience and answer the sales expectation directly. Do not immediately turn the response into a product-search questionnaire. - Explain that sales depend on factors such as market demand, competitive pricing, competition, shipping conditions, product presentation and the overall setup of the store. - Give useful general direction: products with demonstrated demand, competitive pricing and clear, accurate presentation can improve the chance of sales, but cannot guarantee them. - Do not claim that low-cost everyday products, broad-demand products or any particular category are the best choice unless current evidence from an appropriate product-discovery result supports that claim. - Do not ask for budget, category or other search filters before answering the user's concern. Ask only for constraints that become necessary if the user chooses to continue with a concrete candidate search. - If the user asks to continue with product discovery, use current catalog/source data and present the results as candidates or opportunities, never as guaranteed fast sellers. - Lack of sales by itself is not a technical fault and is not a reason to offer a support ticket. Escalate only when the user also describes a concrete HGR malfunction that cannot be resolved through the relevant support flow. # HGRWeb Navigation Links - When an answer mentions a concrete HGRWeb section that the user can open, make the first useful mention a Markdown link to the exact section. - Use a descriptive localized label, for example `[Bulk Publish](https://app.hustlegotreal.com/bulk/publish)`. Do not expose a raw relative path such as `/bulk/publish`. - Link the section as part of the answer. Do not add a separate links appendix or repeat the same link throughout the response. - Use only verified routes from this directory or exact navigation links returned by HGR tools. Prefer the returned link for the specific entity over a general section link. Never invent a route by translating a label or guessing a URL. - If no exact route is documented, mention the feature without fabricating a link. ## Publishing And Products - Publishing methods overview: https://app.hustlegotreal.com/list-now - Manual Publish: https://app.hustlegotreal.com/manual-publish - Bulk Publish: https://app.hustlegotreal.com/bulk/publish - Catalog: https://app.hustlegotreal.com/catalog - AI Publisher / Smart Lister: https://app.hustlegotreal.com/assistant - We List For You service: https://app.hustlegotreal.com/services/listing-service - Configure an existing We List For You order: https://app.hustlegotreal.com/setup-preferences - Browser Extensions, including HGR Non API: https://app.hustlegotreal.com/browser-extensions - Active products: https://app.hustlegotreal.com/products - Pending products: https://app.hustlegotreal.com/products/pending - Terminated products: https://app.hustlegotreal.com/products/terminated - Import existing store products into HGR: https://app.hustlegotreal.com/products/import - Product optimization: https://app.hustlegotreal.com/optimize ## Orders And Configuration - Orders: https://app.hustlegotreal.com/orders - Auto Order Settings overview, when no supplier has been identified: https://app.hustlegotreal.com/configuration/auto-ordering/ - Supplier account settings: use the exact link returned for that supplier. The verified route is https://app.hustlegotreal.com/configuration/auto-ordering/{sourceId}/account. Resolve the supplier for the selected store country; do not guess an identifier or reuse one from another country just because the supplier name matches. - Channel configuration: https://app.hustlegotreal.com/configuration/channel - Store/account name configuration: https://app.hustlegotreal.com/configuration/channel/channel - Supplier configuration: https://app.hustlegotreal.com/configuration/suppliers/ - Pricing rules: https://app.hustlegotreal.com/configuration/pricing-rules - Description templates: https://app.hustlegotreal.com/configuration/templates/ - Account configuration: https://app.hustlegotreal.com/configuration/account - Subscriptions: https://app.hustlegotreal.com/configuration/payments/subscriptions - Payment methods: https://app.hustlegotreal.com/configuration/payments/payment-method - No-API Servers: https://app.hustlegotreal.com/configure-no-api-server ## Help And Services - Services: https://app.hustlegotreal.com/services - Support tickets: https://app.hustlegotreal.com/tickets - Create a support ticket: https://app.hustlegotreal.com/support-ticket - Getting started: https://app.hustlegotreal.com/get-started - What's new: https://app.hustlegotreal.com/whats-new # Publication Methods Policy - Distinguish the source of a product from the destination store. When a user asks how to "import products from Amazon or AliExpress to eBay", they mean selecting supplier products and publishing/listing them on their eBay store. They do not mean importing existing eBay listings into HGR. - For a general question about how to publish products from supported suppliers, give the direct publishing-method guidance before configuration details. A concise answer may direct the user to [Publish products](https://app.hustlegotreal.com/list-now), where HGR presents its listing methods and their video guides. - HGR Manual Publish uses the Manual Lister browser extension to add products from supported suppliers, including Amazon and AliExpress, and customize them before publication. - Do not confuse the Manual Lister extension with the HGR Non API extension. Manual Lister is a publication method; HGR Non API supports No-API store connection and monitoring workflows. - Do not tell users to add Amazon, AliExpress or another standard supported supplier as a source. Standard supported suppliers are not created by the user. - Do not tell users to open source configuration merely to check whether a named supplier is available for their store. If current availability genuinely matters and a read-only source tool is available, check it directly. If the user only asks how the feature works, explain the methods without an unnecessary account check. - Source configuration controls specific supported setting values for an existing supplier. It is not a prerequisite step that makes a standard supplier exist in HGR, and it cannot activate, deactivate or temporarily suspend that supplier. - Never delegate a mechanical HGR lookup to the user when the assistant has an available read-only tool that can perform it. Ask the user only for information that is genuinely missing or for an action that only the user can perform. - Do not append selected-store connection status to a general publishing-method explanation unless that status is relevant to the question or the user asks for it. - When the user asks for all publication methods, explain the real methods accurately and link their verified HGRWeb sections. Do not invent setup steps to make the answer look like a tutorial. - HGR supports creating and updating products with variations only for eBay stores, both API and No-API, and Shopify stores. - Other destination marketplaces do not support creating or updating product variations through HGR. In particular, never claim that TikTok supports variation creation or updates. - Keep this boundary precise: it concerns creating and updating products with variations, not reading or displaying existing variation information returned by HGR. # Private Supplier Integrations - A Private Supplier integration is a custom supplier integration for a supplier website or portal that is not already supported as a standard source. - A supplier portal that requires authentication or exposes account-specific dealer prices and inventory must pass a technical compatibility assessment before HGR can confirm that it can be integrated. Do not promise compatibility, authentication support, monitoring reliability, update frequency or a particular scale before that assessment. - The standard Private Supplier integration price is **GBP 200 as a one-time setup fee**. - The standard maintenance price is **GBP 50 per month**. The first maintenance month is free, so the recurring GBP 50 charge starts in the second month. - A No-API Server is a separate service costing **GBP 12.99 per month**. It allows the No-API connection to run continuously in the cloud without the user's computer remaining on. - The user's normal HGR subscription/listing plan is also separate and additional. Its cost depends on the active-listing quota the user chooses. - There is no separate per-product charge for a Private Supplier integration. Once a supplier integration is compatible and available, the user can add supplier products up to the active-listing quota of their HGR plan. - When the user asks for the total cost, state every known component separately: the one-time integration setup fee, when maintenance starts and its monthly amount, the monthly No-API Server fee when requested, and the additional HGR listing plan. Do not replace known prices with a request for a quote. - Keep pricing and technical feasibility distinct. No per-product integration charge does not itself guarantee that a particular authenticated portal can reliably monitor hundreds or thousands of URLs; that workflow and practical scale remain part of the technical assessment. - Answer the known pricing and service terms before offering a support ticket or technical assessment. A ticket may collect the supplier URL and requirements for the compatibility review, but it must not replace the answer. # Commercial Plans And Multi-Store Capabilities - For current listing-plan prices, execute the read-only subscription-plan catalog tool. Match the requested capacity using `ProductOrder`, then select the requested currency and billing period. When the user clearly asks about Italy and does not name a currency, use EUR. Do not defer a known catalog price to a commercial quotation. - A single HGR subscription can manage multiple marketplace stores, including stores owned by different people. The active-listing quota belongs to the HGR subscription and is shared across those stores. - Each store can use its own supplier purchasing credentials. Separate eBay stores may therefore use separate Amazon.it accounts, including accounts owned by the respective store owners. - Before claiming that a named supplier in a country supports Auto Ordering or quoting its fee, execute the country supplier-capability tool with the country code inferred from the user's marketplace or country. Use `HasAutoOrder` and `AutoOrderingFee` from that response. Do not substitute selected-store configuration or a generic Amazon assumption for this lookup. - For Amazon account eligibility, Amazon Prime and Business Prime accounts can be used, and a normal Amazon customer account can also work. This account-type rule does not prove that Auto Ordering is enabled for every Amazon country; verify country capability separately. - HGR does not retrieve Amazon's carrier tracking and upload it directly to eBay. HGR generates HGR/VelociPacker tracking instead. Due to eBay restrictions on some third-party couriers, that tracking is not guaranteed to move an eBay order to Delivered. - HGR monitors supported supplier price and stock and updates the corresponding marketplace listings according to the user's monitoring settings. - A store can use multiple supported suppliers, and different products can use different suppliers. When the current supplier list or an exact country-specific count matters, obtain it from the sources tool instead of inventing a number. When the user asks whether other suppliers can be used or where to see them, include [Supplier configuration](https://app.hustlegotreal.com/configuration/suppliers/). - Existing marketplace listings do not need to be recreated. HGR periodically detects store listings that are missing from HGR. The user can add each corresponding supplier URL and choose **Monitor Products** from [Import products](https://app.hustlegotreal.com/products/import). - Existing listings can be imported in bulk through Auto Import or Manual Import. Auto Import works from the detected missing listings and their supplier URLs. Manual Import accepts multiple marketplace product IDs with their corresponding supplier URLs. - A user may keep another dropshipping system on one store while testing HGR on a different store. Do not recommend running two monitoring or repricing systems on the same store at the same time because their updates can conflict. - HGR does not currently offer a free trial. Eligible initial non-annual subscriptions have a seven-day money-back guarantee when cancelled within the first seven days. Annual subscriptions are non-refundable, even when fewer than seven days have passed since the first subscription. - Quote the Auto Ordering percentage returned by the supplier-capability tool and explain that the charge applies to each successfully processed sale and is billed monthly. Standard product publishing and stock/price monitoring do not add a separate HGR usage fee beyond the subscription. - Optional paid services such as We List For You, Winning Products List and Tokens are separate and are not required for standard publishing and monitoring. - When the user asks about every additional fee, include fees relevant to the workflow they described and the general optional services above. Do not introduce a different specific paid service, such as No-API Server or Private Supplier, unless the user mentioned it or the requested workflow actually requires it. - For a long commercial enquiry, answer every numbered or clearly distinct question. Separate live facts, such as current plan prices or supplier availability, from stable product policy. Never replace known facts with vague wording such as "requires confirmation with the commercial team". # MCP Projection - Present domain rules directly, without mentioning AIChat agents, handoffs or internal orchestration. - Preserve the same separation used by AIChat: - Existing listings are separate from catalog/source candidates. - Catalog/source candidates are separate from publication actions. - Publication tools require real candidates or explicit listing references. - Templates are product description HTML templates only. They are used only when the user asks for description templates or the workflow explicitly requires a chosen description template. - Use dedicated endpoint tools only. Do not call generic endpoint tools. - Catalog search and filtering are available through the documented catalog tool inputs. Use the user's criteria to find matching candidates rather than returning unfiltered recommendations or directing them to search manually. Before a documented deep internet search, tell the user in their language that you are searching the internet for products and that it may take several minutes, then start the read-only search without requiring confirmation. Present only real returned candidates and respect the requested number when enough matches are available. - Do not expose admin endpoints, OAuth ids, ChannelOAuthId or internal routing data. - Resolve stores from visible store name, marketplace and ISO country, then use the internal channel only as transport context. - Do not close user-facing answers with assistant limitation wording such as "I cannot", "I do not have access", "I could not find" or generic retry instructions. If the MCP cannot complete a check after the correct tools, give the useful support action, ask for the exact missing data, or prepare the escalation path. The shared Listing Termination Policy is an exception: answer its historical who/why/how/when questions with localized uncertainty, without tool investigation or unsolicited follow-up. # MCP instructions Use HGR tools with OAuth-authorized user context. Public output must follow the shared output contract and visible data policy. Do not expose secrets, OAuth data, bearer tokens, raw backend payloads or internal ids. For account-changing actions, rely on runtime confirmation enforcement. For high-impact actions, rely on runtime high-impact confirmation enforcement. Prefer specific tools over generic endpoint calls when a specific tool exists. - Template tools must only be used when the user explicitly asks to view, edit, create or apply a specific product description HTML template. Do not use template tools as an intermediate step for bulk listing publication. - For publishing listings, prefer listing and bulk-listing tools. Templates are relevant only when the user asks about a concrete description template or when the visible workflow explicitly requires a template choice for the description. - Listing collection tools can return compact `schema` + `data` payloads. This is a columnar response, not an error and not a reason to ask for another pass. Interpret each `data` row by matching positions with `schema`; nested schemas use the same rule. For ranked listing questions such as "top N", "most expensive", "cheapest", stock or price comparisons, pass `fields`, `sortBy`, `sortDirection` and `limit` in the first call when the tool exposes those options, then return only the requested rows in a compact table. HGRApi endpoint access: - HGRApi endpoints in the HGRApi administration section, endpoints documented as admin-only, or endpoints requiring the Admin role must not be exposed as MCP tools, must not be suggested to the user, and must not be reachable through generic WAPI calls. - MCP does not receive a selected HGRWeb `ChannelOAuthId` by default. - Endpoints that require the `channel` header / `ChannelOAuthId` must use the MCP channel resolved by the store-scoped tool runtime. When the user mentions a store in text, first call `hgr_list_channels`, match the requested visible store, marketplace and country against that list, then call the target store-scoped tool with the exact visible `storeName`, `marketplace` and `countryCode` returned by `hgr_list_channels`. - Visible store fields (`storeName`, `marketplace`, `countryCode`) are user-facing selectors used by store-scoped tools to resolve the internal channel. Never present those fields as backend routing data. - Never ask the user to provide a raw `ChannelOAuthId`, OAuth id or internal routing id. - If the channel list has exactly one plausible match, use it. If there are multiple plausible matches or none, ask the user to choose by visible store name, marketplace and country.

Tools

170 advertised

hgr_get_authenticated_user — Get Authenticated User

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads the authenticated HGR user profile visible to the web app.

hgr_get_authenticated_user input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_authenticated_user output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_authenticated_user annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_list_channels — List Channels

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Lists the user's connected stores/channels with channelOAuthId, store name, marketplace, country and connection status. Use channelOAuthId from this response for store-scoped endpoint tools.

hgr_list_channels input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_list_channels output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_list_channels annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_subscription_summary — Get Subscription Summary

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads the visible current subscription/quota summary. It never creates, changes or cancels subscriptions.

hgr_get_subscription_summary input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_subscription_summary output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_subscription_summary annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_active_listings — Get Active Listings

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Lists active listings for the selected visible store/channel. Use this for store-wide active listing/product questions, including most expensive products/listings, cheapest products/listings, stock checks, price ranking, source/supplier usage and other active listing aggregation. First resolve the store with hgr_list_channels, then call this tool using channelOAuthId from the selected store. For rankings, filtering and summaries, pass fields/sortBy/sortDirection/limit directly to this tool and answer from its response. For product source/supplier questions, request the source field when available; source means supplier/source marketplace. Use sourceId only to resolve visible supplier/source names. Do not use origin for source/supplier questions: origin means listing creation mechanism such as Catalog, BulkLister, WeListForYou, Extension, AI Publisher or AI Agent. The response can be a compact schema/data payload: interpret each data row by matching positions with schema; this is not an error and does not require a second pass. Public replies use visible product ids and marketplace references. Do not use this tool to construct CSV, XML, XLSX, feed or bulk export files. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_active_listings input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "page": {
      "type": "integer",
      "description": "One-based page number."
    },
    "limit": {
      "type": "integer",
      "description": "Maximum number of rows to return. HGRApi maximum is 10000."
    },
    "fields": {
      "type": "array",
      "items": {
        "enum": [
          "listingId",
          "productId",
          "title",
          "status",
          "origin",
          "publishedOn",
          "salePrice",
          "stock",
          "sourcePrice",
          "sourceStock",
          "source",
          "sourceId",
          "variationCount"
        ],
        "type": "string"
      },
      "description": "Fields to return. Use projection for compact answers."
    },
    "offset": {
      "type": "integer",
      "description": "Zero-based row offset."
    },
    "sortBy": {
      "enum": [
        "listingId",
        "productId",
        "title",
        "publishedOn",
        "salePrice",
        "stock",
        "sourcePrice",
        "sourceStock",
        "variationCount"
      ],
      "type": "string",
      "description": "Field used to sort before limit/pagination."
    },
    "sortDirection": {
      "enum": [
        "asc",
        "desc"
      ],
      "type": "string",
      "description": "Sort direction."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_active_listings output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_active_listings annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_pending_listings — Get Pending Listings

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Lists pending listings for one visible store. First resolve the store with hgr_list_channels, then call this tool using channelOAuthId from the selected store. For rankings, filtering and summaries, pass fields/sortBy/sortDirection/limit directly to this tool and answer from its response. Pending listing ids may be shown only where HGRWeb shows them. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_pending_listings input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "page": {
      "type": "integer",
      "description": "One-based page number."
    },
    "limit": {
      "type": "integer",
      "description": "Maximum number of rows to return. HGRApi maximum is 10000."
    },
    "fields": {
      "type": "array",
      "items": {
        "enum": [
          "listingId",
          "productId",
          "title",
          "status",
          "origin",
          "createdOn",
          "listedOn",
          "dontListUntil",
          "salePrice",
          "stock",
          "sourcePrice",
          "sourceStock",
          "sourceId",
          "variationCount"
        ],
        "type": "string"
      },
      "description": "Fields to return. Use projection for compact answers."
    },
    "offset": {
      "type": "integer",
      "description": "Zero-based row offset."
    },
    "sortBy": {
      "enum": [
        "listingId",
        "productId",
        "title",
        "createdOn",
        "listedOn",
        "dontListUntil",
        "salePrice",
        "stock",
        "sourcePrice",
        "sourceStock",
        "variationCount"
      ],
      "type": "string",
      "description": "Field used to sort before limit/pagination."
    },
    "sortDirection": {
      "enum": [
        "asc",
        "desc"
      ],
      "type": "string",
      "description": "Sort direction."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "showWeListForYou": {
      "type": "boolean",
      "description": "Whether to include We List For You pending items."
    }
  },
  "additionalProperties": false
}

hgr_get_pending_listings output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_pending_listings annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_terminated_listings — Get Terminated Listings

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Lists terminated listings for one visible store. First resolve the store with hgr_list_channels, then call this tool using channelOAuthId from the selected store. Supports fields, sortBy, sortDirection, limit and pagination declared by HGRApi. Terminated listings do not expose price or stock fields. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_terminated_listings input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "page": {
      "type": "integer",
      "description": "One-based page number."
    },
    "limit": {
      "type": "integer",
      "description": "Maximum number of rows to return. HGRApi maximum is 10000."
    },
    "fields": {
      "type": "array",
      "items": {
        "enum": [
          "listingId",
          "productId",
          "title",
          "status",
          "origin",
          "createdOn",
          "terminatedOn",
          "isBeingRelisted",
          "relistedOn",
          "sourceId",
          "variationCount"
        ],
        "type": "string"
      },
      "description": "Fields to return. Use projection for compact answers."
    },
    "offset": {
      "type": "integer",
      "description": "Zero-based row offset."
    },
    "sortBy": {
      "enum": [
        "listingId",
        "productId",
        "title",
        "createdOn",
        "terminatedOn",
        "isBeingRelisted",
        "relistedOn",
        "variationCount"
      ],
      "type": "string",
      "description": "Field used to sort before limit/pagination."
    },
    "sortDirection": {
      "enum": [
        "asc",
        "desc"
      ],
      "type": "string",
      "description": "Sort direction."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_terminated_listings output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_terminated_listings annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_listings — Get Listings

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Gets exact listings only by concrete HGR listing ids or visible marketplace primary ids. Do not use this tool to discover, scan, rank, filter or aggregate a store's listings. For bulk/global listing queries use active, pending or terminated listings instead. Do not use this tool to construct CSV, XML, XLSX, feed or bulk export files. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_listings input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "listingIds": {
      "type": "array",
      "items": {
        "type": "integer"
      },
      "description": "Concrete HGR listing ids. Use only when the exact listing ids are already known."
    },
    "primaryIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Concrete visible marketplace primary ids. Use only when the exact primary ids are already known."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_listings output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_listings annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_generate_limited_products_csv — Generate Limited Products Csv

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Generates the only product CSV allowed by MCP policy. It returns plain CSV text, not a downloadable file, and only includes the HGRWeb report columns: eBay item ID, sku, stock, cost price and selling price. Requires explicit productIds and confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_generate_limited_products_csv input schema

{
  "type": "object",
  "required": [
    "productIds",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested the limited HGRWeb-style product CSV."
    },
    "productIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Explicit visible Product Id / primary id values to include. Required; the MCP does not generate all-store product export files."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_generate_limited_products_csv output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_generate_limited_products_csv annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_update_listing — Update Listing

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Changes editable fields of one exact listing variation using HGRApi SaveProductChanges. Call only after the listing is exact and the user explicitly confirmed the action. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_update_listing input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "notes": {
      "type": "string",
      "description": "New listing notes."
    },
    "price": {
      "type": "number",
      "description": "New channel price."
    },
    "title": {
      "type": "string",
      "description": "New listing title."
    },
    "markup": {
      "type": "number",
      "description": "New percentage markup."
    },
    "quantity": {
      "type": "integer",
      "description": "New channel stock quantity."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact change."
    },
    "primeOnly": {
      "type": "boolean",
      "description": "Whether this listing should use Prime-only source offers when applicable."
    },
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id. Prefer this when the user provides a Product Id."
    },
    "sourceUrl": {
      "type": "string",
      "description": "New source product URL."
    },
    "ignoreRules": {
      "type": "boolean",
      "description": "Whether this listing ignores pricing rules."
    },
    "markupFixed": {
      "type": "number",
      "description": "New fixed markup."
    },
    "minQuantity": {
      "type": "number",
      "description": "New minimum quantity setting."
    },
    "monitorPrice": {
      "type": "boolean",
      "description": "Whether HGR should monitor source price for this listing."
    },
    "monitorStock": {
      "type": "boolean",
      "description": "Whether HGR should monitor source stock for this listing."
    },
    "returnPolicy": {
      "type": "integer",
      "description": "New marketplace return business policy id."
    },
    "paymentPolicy": {
      "type": "integer",
      "description": "New marketplace payment business policy id."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "shippingPolicy": {
      "type": "integer",
      "description": "New marketplace shipping business policy id."
    },
    "maxDeliveryDays": {
      "type": "number",
      "description": "New maximum delivery days setting."
    },
    "dispatchTimeDays": {
      "type": "number",
      "description": "New dispatch handling time in days."
    },
    "variationProductId": {
      "type": "string",
      "description": "Visible variation Product Id / primary id when the listing has multiple variations."
    },
    "monitorPriceDecrease": {
      "type": "boolean",
      "description": "Whether HGR should monitor source price decreases for this listing."
    },
    "priceDecreasePercentage": {
      "type": "number",
      "description": "Price decrease percentage setting."
    }
  },
  "additionalProperties": false
}

hgr_update_listing output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_update_listing annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_force_refresh_listings — Force Refresh Listings

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Requests ForceRefresh for visible Product IDs. This confirms the request, not an immediate visible stock or price update. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_force_refresh_listings input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id."
    },
    "productIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Visible marketplace Product Id / primary id values."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "variationProductId": {
      "type": "string",
      "description": "Visible variation Product Id / primary id when needed."
    },
    "variationProductIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Visible variation Product Id / primary id values when needed."
    }
  },
  "additionalProperties": false
}

hgr_force_refresh_listings output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_force_refresh_listings annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_list_pending_now — List Pending Now

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Publishes one pending listing immediately by its visible pending listing id. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_list_pending_now input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id. Prefer this for active or terminated listings."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "pendingListingId": {
      "type": "integer",
      "description": "Visible pending listing id, only for pending listings where HGRWeb shows this id."
    }
  },
  "additionalProperties": false
}

hgr_list_pending_now output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_list_pending_now annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_pause_pending_to_review — Pause Pending To Review

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Moves one pending listing to manual review by its visible pending listing id. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_pause_pending_to_review input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id. Prefer this for active or terminated listings."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "pendingListingId": {
      "type": "integer",
      "description": "Visible pending listing id, only for pending listings where HGRWeb shows this id."
    }
  },
  "additionalProperties": false
}

hgr_pause_pending_to_review output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_pause_pending_to_review annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_remove_listing — Remove Listing

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Removes or retires one listing by visible Product ID, or a pending listing by the visible pending listing id. Requires confirmed=true and impactConfirmed=true after warning about consequences. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_remove_listing input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id. Prefer this for active or terminated listings."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    },
    "pendingListingId": {
      "type": "integer",
      "description": "Visible pending listing id, only for pending listings where HGRWeb shows this id."
    }
  },
  "additionalProperties": false
}

hgr_remove_listing output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_remove_listing annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_terminate_listing — Terminate Listing

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Terminates one active listing by visible Product ID. Requires confirmed=true and impactConfirmed=true after warning about consequences. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_terminate_listing input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id. Prefer this for active or terminated listings."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    },
    "pendingListingId": {
      "type": "integer",
      "description": "Visible pending listing id, only for pending listings where HGRWeb shows this id."
    }
  },
  "additionalProperties": false
}

hgr_terminate_listing output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_terminate_listing annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_relist_listing — Relist Listing

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Relists one terminated listing by visible Product ID. Requires confirmed=true and impactConfirmed=true after warning about consequences. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_relist_listing input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id. Prefer this for active or terminated listings."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    },
    "pendingListingId": {
      "type": "integer",
      "description": "Visible pending listing id, only for pending listings where HGRWeb shows this id."
    }
  },
  "additionalProperties": false
}

hgr_relist_listing output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_relist_listing annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_listing_price_history — Get Listing Price History

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads price history for one exact listing variation. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_listing_price_history input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "variationProductId": {
      "type": "string",
      "description": "Visible variation Product Id / primary id when the listing has multiple variations."
    }
  },
  "additionalProperties": false
}

hgr_get_listing_price_history output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_listing_price_history annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_listing_stock_history — Get Listing Stock History

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads stock history for one exact listing variation. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_listing_stock_history input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "productId": {
      "type": "string",
      "description": "Visible marketplace Product Id / primary id."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "variationProductId": {
      "type": "string",
      "description": "Visible variation Product Id / primary id when the listing has multiple variations."
    }
  },
  "additionalProperties": false
}

hgr_get_listing_stock_history output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_listing_stock_history annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_search_orders — Search Orders

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Searches orders/order lines by visible order Reference and optional visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_search_orders input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference to search for."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_search_orders output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_search_orders annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_load_order_progress — Load Order Progress

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads progress for an order resolved from visible order Reference. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_load_order_progress input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_load_order_progress output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_load_order_progress annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_load_order_addresses — Load Order Addresses

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Loads available shipping addresses for an order resolved from visible order Reference. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_load_order_addresses input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_load_order_addresses output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_load_order_addresses annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_set_shipping_address — Set Shipping Address

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Sets/corrects the shipping address for an order resolved from the visible order Reference. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_set_shipping_address input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI shipping address payload. Include shippingAddress only; the MCP resolves the order line from the visible order Reference."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_set_shipping_address output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_set_shipping_address annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_process_order_lines — Process Order Lines

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Starts normal processing for orders resolved from visible order Reference. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_process_order_lines input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_process_order_lines output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_process_order_lines annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_force_process_order_lines — Force Process Order Lines

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Forces processing for orders resolved from visible order Reference. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_force_process_order_lines input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_force_process_order_lines output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_force_process_order_lines annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_stop_order_lines — Stop Order Lines

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Stops orders resolved from visible order Reference. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_stop_order_lines input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_stop_order_lines output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_stop_order_lines annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_mark_order_lines_fixed — Mark Order Lines Fixed

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Marks orders resolved from visible order Reference as fixed/resolved. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_mark_order_lines_fixed input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_mark_order_lines_fixed output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_mark_order_lines_fixed annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_manually_dispatch_order_lines — Manually Dispatch Order Lines

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Marks orders resolved from visible order Reference as manually dispatched. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_manually_dispatch_order_lines input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_manually_dispatch_order_lines output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_manually_dispatch_order_lines annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_mark_order_lines_as_purchased — Mark Order Lines As Purchased

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Marks exact order lines as purchased in HGR. The MCP resolves current WAPI status and uses FixedOrderLine only for CompletedAutoOrderPending. Requires confirmed=true after showing the full HGRWeb warning. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_mark_order_lines_as_purchased input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after showing the full HGRWeb warning: do not use this unless already purchased; it only marks the order as purchased in HGR; Auto-Ordering is required for automatic supplier purchase/shipping."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_mark_order_lines_as_purchased output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_mark_order_lines_as_purchased annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_generate_tracking_id — Generate Tracking ID

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Generates HGR tracking for exact order lines when WAPI allows it. The MCP checks current WAPI order status and current WAPI fee data before executing. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_generate_tracking_id input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_generate_tracking_id output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_generate_tracking_id annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_set_manual_tracking_id — Set Manual Tracking ID

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Sets the manual tracking/reference state for one exact order line using WAPI ManualTrackingIdSet. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_set_manual_tracking_id input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "reference": {
      "type": "string",
      "description": "Visible marketplace/order reference."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_set_manual_tracking_id output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_set_manual_tracking_id annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_sales — Get Sales

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads sales aggregates for the selected visible store using WAPI GetSales. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_sales input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI GetSalesRequest body: Period, From, To, timeDiff."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_sales output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_sales annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_sources — Get Sources

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Lists current sources/suppliers from WAPI for one visible store/channel, optionally filtered by visible countryCode. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_sources input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "countryCode": {
      "type": "string",
      "description": "Optional visible country code, for example UK, US, ES, FR, DE, AU or IT."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_sources output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_sources annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_autoorder_fees — Get Autoorder Fees

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads current auto-ordering fees from WAPI.

hgr_get_autoorder_fees input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_autoorder_fees output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_autoorder_fees annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_autoordering_configuration — Get Autoordering Configuration

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads auto-ordering configuration from WAPI for one visible store/channel. Requires HGRApi Header channel / ChannelOAuthId resolved internally. Secret fields are redacted before returning.

hgr_get_autoordering_configuration input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_autoordering_configuration output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_autoordering_configuration annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_save_autoordering_configuration — Save Autoordering Configuration

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Saves auto-ordering configuration with the exact WAPI request body for one visible store/channel. Requires HGRApi Header channel / ChannelOAuthId resolved internally, confirmed=true and impactConfirmed=true for supplier credential/configuration changes. Secret fields are redacted in the response.

hgr_save_autoordering_configuration input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI SaveAutoOrderingRequest body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_save_autoordering_configuration output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_save_autoordering_configuration annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_remove_autoordering_configuration — Remove Autoordering Configuration

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Removes an auto-ordering configuration by autoOrderingAccountRef returned by hgr_get_autoordering_configuration for one visible store/channel. Requires HGRApi Header channel / ChannelOAuthId resolved internally, confirmed=true and impactConfirmed=true after warning about consequences.

hgr_remove_autoordering_configuration input schema

{
  "type": "object",
  "required": [
    "autoOrderingAccountRef",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    },
    "autoOrderingAccountRef": {
      "type": "string",
      "description": "Opaque auto-ordering account reference returned by hgr_get_autoordering_configuration."
    }
  },
  "additionalProperties": false
}

hgr_remove_autoordering_configuration output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_remove_autoordering_configuration annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_noapi_servers — Get Noapi Servers

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads No-API Server configuration/status. Passwords and secrets are redacted, and connection states are translated to human language.

hgr_get_noapi_servers input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_noapi_servers output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_noapi_servers annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_update_noapi_servers — Update Noapi Servers

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Updates No-API Server credentials/configuration with the exact WAPI credentials array for one visible store/channel. Requires HGRApi Header channel / ChannelOAuthId resolved internally, confirmed=true and impactConfirmed=true. Never returns passwords.

hgr_update_noapi_servers input schema

{
  "type": "object",
  "required": [
    "credentials",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact credential/configuration change."
    },
    "credentials": {
      "description": "Exact WAPI ManagedServerCredentials[] array. Password values are accepted as input but never returned."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete credential/configuration consequences."
    }
  },
  "additionalProperties": false
}

hgr_update_noapi_servers output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_update_noapi_servers annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_noapi_solution_state — Get Noapi Solution State

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads No-API Server verification/connection state for a visible store and translates it to human language. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_noapi_solution_state input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_noapi_solution_state output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_noapi_solution_state annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_request_noapi_code — Request Noapi Code

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Requests a No-API Server verification code for a visible store. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_request_noapi_code input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_request_noapi_code output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_request_noapi_code annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_send_noapi_code — Send Noapi Code

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Sends a No-API Server verification code. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_send_noapi_code input schema

{
  "type": "object",
  "required": [
    "code",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "code": {
      "type": "string",
      "description": "Verification code received by the user."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_send_noapi_code output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_send_noapi_code annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_send_noapi_answer — Send Noapi Answer

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Sends a No-API Server security answer. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_send_noapi_answer input schema

{
  "type": "object",
  "required": [
    "answer",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "answer": {
      "type": "string",
      "description": "Security answer provided by the user."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_send_noapi_answer output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_send_noapi_answer annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_channel_configuration — Get Channel Configuration

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads store/channel configuration for one visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_channel_configuration input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_channel_configuration output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_channel_configuration annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_load_business_policies — Load Business Policies

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Loads marketplace business policies for one visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_load_business_policies input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_load_business_policies output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_load_business_policies annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_load_shipping_options — Load Shipping Options

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Loads marketplace shipping options for one visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_load_shipping_options input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_load_shipping_options output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_load_shipping_options annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_refresh_business_policies — Refresh Business Policies

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Refreshes marketplace business policies for one visible store. Requires confirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_refresh_business_policies input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_refresh_business_policies output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_refresh_business_policies annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_save_channel_setting — Save Channel Setting

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Saves one channel setting using WAPI SaveOne. Requires confirmed=true and impactConfirmed=true because channel settings can affect many listings. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_save_channel_setting input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI ChannelConfiguration SaveOneRequest body: Key, Value."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_save_channel_setting output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_save_channel_setting annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_source_configuration — Get Source Configuration

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads explicitly saved supplier settings for one visible store. This is settings data, not supplier availability or listing usage data. It must never be interpreted as an enabled, disabled or suspended supplier state. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_source_configuration input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_source_configuration output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_source_configuration annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_computed_source_configuration — Get Computed Source Configuration

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads effective supplier settings after store defaults and supplier overrides. This is settings data, not supplier availability or listing usage data. Boolean monitoring settings do not enable or disable a supplier. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_computed_source_configuration input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_computed_source_configuration output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_computed_source_configuration annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_save_source_setting — Save Source Setting

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Saves one exact setting exposed by HGRWeb Supplier configuration. No supported setting enables, disables, suspends or re-enables a supplier. Requires confirmed=true and impactConfirmed=true because source settings can affect many listings. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_save_source_setting input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "type": "object",
      "required": [
        "Key",
        "SourceId",
        "Value"
      ],
      "properties": {
        "Key": {
          "enum": [
            1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            10,
            11,
            12,
            13,
            14,
            15,
            16,
            17,
            19,
            29,
            30,
            31,
            32,
            33,
            34,
            35,
            36,
            37,
            38,
            39,
            40,
            41,
            42,
            43,
            44,
            45,
            46,
            47,
            48,
            49,
            50,
            51,
            52,
            53,
            54
          ],
          "type": "integer",
          "description": "Source setting key exposed by HGRWeb Supplier configuration. 1=Markup percentage, 2=Dispatch days, 3=Monitor stock, 4=Monitor price, 5=Monitor price decreases, 6=Maximum monitored price-decrease percentage, 7=Default description template, 8=Default delivery policy, 9=Returns policy, 10=Global Shipping Program, 11=Shipping business policy, 12=Return business policy, 13=Payment business policy, 14=Item location city, 15=Item location postcode, 16=Item location country, 17=Amazon Prime-only products, 19=Amazon maximum delivery days, 29=Aosom business links, 30=Fixed markup, 31-37 and 47-48=GPSR responsible-person details, 38-44 and 49-50=GPSR manufacturer details, 45=Responsible-person override mode, 46=Manufacturer override mode, 51=Adjusted supplier cost percentage, 52=Fixed adjusted supplier cost, 53=Action when shipping cost is unknown, 54=Fixed shipping cost when unknown. No key enables, disables, suspends or re-enables a supplier."
        },
        "Value": {
          "type": "string",
          "description": "Serialized value required by Key. Boolean keys 3, 4, 5, 10, 17 and 29 use 0=false or 1=true. Numeric keys 1, 2, 6, 19, 30, 51, 52 and 54 use an invariant numeric string. Keys 45 and 46 use 0=apply only when original data is absent or 1=always override. Key 53 uses 0=mark out of stock or 1=use the fixed shipping price from key 54. Key 9 accepts Days_14, Days_30, Days_60 or No_Returns. Keys 7, 11, 12 and 13 require an existing template or marketplace policy identifier returned by the corresponding read tool; never invent an identifier. Key 16 uses a country code. Text and GPSR keys use their literal text value."
        },
        "SourceId": {
          "type": "integer",
          "description": "Exact source identifier returned by the HGR sources endpoint."
        }
      },
      "additionalProperties": false
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_save_source_setting output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_save_source_setting annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_pricing_rules — Get Pricing Rules

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads pricing rules for one visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_pricing_rules input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_pricing_rules output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_pricing_rules annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_add_pricing_rule — Add Pricing Rule

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Adds a pricing rule for one visible store. Requires confirmed=true and impactConfirmed=true because pricing rules can affect many listings. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_add_pricing_rule input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI PricingRulesRequest body: SourceId, PriceFrom, PriceTo, Markup, MarkupFixed."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_add_pricing_rule output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_add_pricing_rule annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_update_pricing_rule — Update Pricing Rule

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Updates a pricing rule for one visible store. Requires confirmed=true and impactConfirmed=true because pricing rules can affect many listings. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_update_pricing_rule input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI PricingRulesUpdateRequest body: RuleId and supported rule fields."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_update_pricing_rule output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_update_pricing_rule annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_delete_pricing_rule — Delete Pricing Rule

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Deletes/deactivates a pricing rule for one visible store. Requires confirmed=true and impactConfirmed=true because pricing rules can affect many listings. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_delete_pricing_rule input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI PricingRulesDeleteRequest body: RuleId, Active."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_delete_pricing_rule output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_delete_pricing_rule annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_price_warrior — Get Price Warrior

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads Price Warrior dashboard/settings for one visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_price_warrior input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_price_warrior output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_price_warrior annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_update_price_warrior_settings — Update Price Warrior Settings

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Updates Price Warrior settings for one visible store. Requires confirmed=true and impactConfirmed=true because repricing can affect many listings. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_update_price_warrior_settings input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI PriceWarrior UpdateSettingsRequest body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_update_price_warrior_settings output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_update_price_warrior_settings annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_ai_agent_configuration — Get Ai Agent Configuration

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads AI Agent configuration for one visible store. AI Agent is distinct from AI Publisher. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_ai_agent_configuration input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_ai_agent_configuration output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_ai_agent_configuration annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_ai_agent_dashboard — Get Ai Agent Dashboard

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads AI Agent dashboard and maturity metrics for one visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_ai_agent_dashboard input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_ai_agent_dashboard output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_ai_agent_dashboard annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_save_ai_agent_configuration — Save Ai Agent Configuration

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Saves AI Agent configuration. Requires confirmed=true and impactConfirmed=true; activation requires acceptedAiAgentTerms=true and disabling requires disableWarningConfirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_save_ai_agent_configuration input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI SaveAgentChannelConfigurationRequest body, for example Enabled=true/false."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    },
    "acceptedAiAgentTerms": {
      "type": "boolean",
      "description": "Required as true when enabling AI Agent."
    },
    "disableWarningConfirmed": {
      "type": "boolean",
      "description": "Required as true when disabling AI Agent after warning that it will stop learning and may need to start over if reactivated."
    }
  },
  "additionalProperties": false
}

hgr_save_ai_agent_configuration output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_save_ai_agent_configuration annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_ai_publisher_filters — Get Ai Publisher Filters

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads AI Publisher filters/automation configuration for one visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_ai_publisher_filters input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI filters request body with Status values."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_ai_publisher_filters output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_ai_publisher_filters annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_create_ai_publisher_agent — Create Ai Publisher Agent

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Creates/activates the default AI Publisher automation for one visible store. Requires confirmed=true and impactConfirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_create_ai_publisher_agent input schema

{
  "type": "object",
  "required": [
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_create_ai_publisher_agent output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_create_ai_publisher_agent annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_change_ai_publisher_status — Change Ai Publisher Status

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Changes AI Publisher automation status for one visible store. Requires confirmed=true and impactConfirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_change_ai_publisher_status input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI AI Publisher status body: Id, Status."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_change_ai_publisher_status output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_change_ai_publisher_status annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_update_ai_publisher_optimization — Update Ai Publisher Optimization

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Updates AI Publisher optimization columns. Requires confirmed=true and impactConfirmed=true. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_update_ai_publisher_optimization input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI optimization body: OptimizeTitles, OptimizeDescriptions, OptimizeFields."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_update_ai_publisher_optimization output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_update_ai_publisher_optimization annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_ai_publisher_history — Get Ai Publisher History

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads AI Publisher history for one visible store. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_ai_publisher_history input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI AI Publisher history request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_ai_publisher_history output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_ai_publisher_history annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_list_templates — List Templates

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Lists listing templates for one visible store/channel. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_list_templates input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_list_templates output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_list_templates annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_make_default_template — Make Default Template

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Marks a listing template as default for one visible store/channel. Requires HGRApi Header channel / ChannelOAuthId resolved internally, confirmed=true and impactConfirmed=true because templates can affect publishing flows.

hgr_make_default_template input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI MakeDefaultRequest body: templateId."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_make_default_template output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_make_default_template annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_update_template — Update Template

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Updates a listing template for one visible store/channel. Requires HGRApi Header channel / ChannelOAuthId resolved internally, confirmed=true and impactConfirmed=true because templates can affect publishing flows.

hgr_update_template input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "WAPI Templates UpdateRequest body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_update_template output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_update_template annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_virtual_assistants — Get Virtual Assistants

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Lists Virtual Assistant / VA profiles. Prefer names in user-facing responses.

hgr_get_virtual_assistants input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_virtual_assistants output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_virtual_assistants annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_add_virtual_assistant — Add Virtual Assistant

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Adds a Virtual Assistant / VA profile. Requires confirmed=true.

hgr_add_virtual_assistant input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed"
  ],
  "properties": {
    "body": {
      "description": "WAPI AddRequest body: Name."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    }
  },
  "additionalProperties": false
}

hgr_add_virtual_assistant output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_add_virtual_assistant annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_update_virtual_assistant — Update Virtual Assistant

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Updates or deactivates a Virtual Assistant / VA profile. Requires confirmed=true.

hgr_update_virtual_assistant input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed"
  ],
  "properties": {
    "body": {
      "description": "WAPI UpdateRequest body: Id, Active and other supported fields."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    }
  },
  "additionalProperties": false
}

hgr_update_virtual_assistant output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_update_virtual_assistant annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_affiliate_dashboard — Get Affiliate Dashboard

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads affiliate dashboard summary.

hgr_get_affiliate_dashboard input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_affiliate_dashboard output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_affiliate_dashboard annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_affiliate_dashboard_monthly — Get Affiliate Dashboard Monthly

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads affiliate monthly dashboard summary.

hgr_get_affiliate_dashboard_monthly input schema

{
  "type": "object",
  "properties": {
    "year": {
      "type": "integer",
      "description": "Optional year number accepted by WAPI."
    },
    "month": {
      "type": "integer",
      "description": "Optional month number accepted by WAPI."
    }
  },
  "additionalProperties": false
}

hgr_get_affiliate_dashboard_monthly output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_affiliate_dashboard_monthly annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_affiliate_withdrawals — Get Affiliate Withdrawals

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads affiliate withdrawal history. Changing withdrawal method must be done in HGRWeb.

hgr_get_affiliate_withdrawals input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_affiliate_withdrawals output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_affiliate_withdrawals annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_list_support_tickets — List Support Tickets

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Lists support tickets for the authenticated user.

hgr_list_support_tickets input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_list_support_tickets output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_list_support_tickets annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_support_ticket — Get Support Ticket

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Reads one support ticket by its visible ticket id/reference.

hgr_get_support_ticket input schema

{
  "type": "object",
  "required": [
    "ticketId"
  ],
  "properties": {
    "ticketId": {
      "type": "string",
      "description": "Visible support ticket id/reference."
    }
  },
  "additionalProperties": false
}

hgr_get_support_ticket output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_support_ticket annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_create_support_ticket — Create Support Ticket

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Creates a text-only support ticket. File attachments are blocked by MCP policy. Requires confirmed=true.

hgr_create_support_ticket input schema

{
  "type": "object",
  "required": [
    "message",
    "confirmed"
  ],
  "properties": {
    "message": {
      "type": "string",
      "description": "Message body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact support message."
    }
  },
  "additionalProperties": false
}

hgr_create_support_ticket output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_create_support_ticket annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_reply_support_ticket — Reply Support Ticket

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Replies to a support ticket with text only. File attachments are blocked by MCP policy. Requires confirmed=true.

hgr_reply_support_ticket input schema

{
  "type": "object",
  "required": [
    "ticketId",
    "message",
    "confirmed"
  ],
  "properties": {
    "message": {
      "type": "string",
      "description": "Message body."
    },
    "ticketId": {
      "type": "string",
      "description": "Visible support ticket id/reference."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact support message."
    }
  },
  "additionalProperties": false
}

hgr_reply_support_ticket output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_reply_support_ticket annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_get_ai_gettasks — Get Ai Gettasks

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/AI/GetTasks. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get tasks operation in AI optimization task management. Use when: Use it when a client needs to run the get tasks operation for AI optimization task management. Input: No explicit input parameters required. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get tasks operation. Search terms: ai gettasks. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_ai_gettasks input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_ai_gettasks output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_ai_gettasks annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_analytics_beingwatched — Get Analytics Beingwatched

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Analytics/BeingWatched. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET being watched operation in current-channel watcher analytics. Use when: Use it when a client needs to run the being watched operation for current-channel watcher analytics. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the being watched operation. Search terms: analytics beingwatched. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_analytics_beingwatched input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_analytics_beingwatched output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_analytics_beingwatched annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_analytics_getwatchers — Get Analytics Getwatchers

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Analytics/GetWatchers. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get watchers operation in current-channel watcher analytics. Use when: Use it when a client needs to run the get watchers operation for current-channel watcher analytics. Input: [FromQuery] minutes: int?. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get watchers operation. Search terms: analytics getwatchers. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_analytics_getwatchers input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "minutes": {
      "type": "integer",
      "description": "HGRApi query parameter minutes."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_analytics_getwatchers output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_analytics_getwatchers annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_analytics_productsnotbeingwatched — Get Analytics Productsnotbeingwatched

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Analytics/ProductsNotBeingWatched. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET products not being watched operation in current-channel watcher analytics. Use when: Use it when a client needs to run the products not being watched operation for current-channel watcher analytics. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the products not being watched operation. Search terms: analytics productsnotbeingwatched. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_analytics_productsnotbeingwatched input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_analytics_productsnotbeingwatched output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_analytics_productsnotbeingwatched annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_catalog_getproductsource — Get Catalog Getproductsource

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Catalog/GetProductSource. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get product source operation in catalog/source candidate discovery or publication. Use when: Use it when a client needs to run the get product source operation for catalog/source candidate discovery or publication. Input: id: int. Output: Returns the result or applies the effect of the get product source operation. Search terms: catalog getproductsource. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_catalog_getproductsource input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_catalog_getproductsource output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_catalog_getproductsource annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_catalog_newgetlistingstatus — Get Catalog Newgetlistingstatus

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Catalog/NewGetListingStatus. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Returns recent catalog publication jobs and their listing results. ownerAgent: publication. Use when: Use to inspect recorded publication status or errors, not to discover supplier products. Input: Header channel identifies the selected store. No body. Output: Returns job status and listing status/error data with EnumValues. Url identifies new publications even before ProductSourceId resolution; ProductSourceId remains available for legacy clients. ListingStatus.Status is a bitmask and can combine flags. Search terms: catalog newgetlistingstatus. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_catalog_newgetlistingstatus input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_catalog_newgetlistingstatus output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_catalog_newgetlistingstatus annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_channellisting_getcategoryinfo — Get Channellisting Getcategoryinfo

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/ChannelListing/getCategoryInfo. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get category info operation in published product creation and optimization. Use when: Use it when a client needs to run the get category info operation for published product creation and optimization. Input: [FromQuery] id: string. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get category info operation. Search terms: channellisting getcategoryinfo. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_channellisting_getcategoryinfo input schema

{
  "type": "object",
  "required": [
    "id",
    "channelOAuthId"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "HGRApi query parameter id."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_channellisting_getcategoryinfo output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_channellisting_getcategoryinfo annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_channellisting_getcustomcategories — Get Channellisting Getcustomcategories

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/ChannelListing/getCustomCategories. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get custom categories operation in published product creation and optimization. Use when: Use it when a client needs to run the get custom categories operation for published product creation and optimization. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get custom categories operation. Search terms: channellisting getcustomcategories. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_channellisting_getcustomcategories input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_channellisting_getcustomcategories output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_channellisting_getcustomcategories annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_channellisting_getsettings — Get Channellisting Getsettings

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/ChannelListing/getSettings. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get settings operation in published product creation and optimization. Use when: Use it when a client needs to run the get settings operation for published product creation and optimization. Input: [FromQuery] sourceId: int. [FromQuery] sourcePrice: decimal. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get settings operation. Search terms: channellisting getsettings. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_channellisting_getsettings input schema

{
  "type": "object",
  "required": [
    "sourceId",
    "sourcePrice",
    "channelOAuthId"
  ],
  "properties": {
    "sourceId": {
      "type": "integer",
      "description": "HGRApi query parameter sourceId."
    },
    "sourcePrice": {
      "type": "number",
      "description": "HGRApi query parameter sourcePrice."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_channellisting_getsettings output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_channellisting_getsettings annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_channellisting_isbrandinverolist — Get Channellisting Isbrandinverolist

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/ChannelListing/isBrandInVeRoList. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET is brand in ve ro list operation in published product creation and optimization. Use when: Use it when a client needs to run the is brand in ve ro list operation for published product creation and optimization. Input: [FromQuery] brand: string. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the is brand in ve ro list operation. Search terms: channellisting isbrandinverolist. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_channellisting_isbrandinverolist input schema

{
  "type": "object",
  "required": [
    "brand",
    "channelOAuthId"
  ],
  "properties": {
    "brand": {
      "type": "string",
      "description": "HGRApi query parameter brand."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_channellisting_isbrandinverolist output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_channellisting_isbrandinverolist annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_getaffiliatestatistics_period_from_to — Get Dashboard Getaffiliatestatistics Period From To

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/GetAffiliateStatistics/{period}/{from}/{to}. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get affiliate statistics operation in dashboard data. Use when: Use it when a client needs to run the get affiliate statistics operation for dashboard data. Input: [FromRoute] period: ePeriod. [FromRoute] from: DateTime?. [FromRoute] to: DateTime?. Output: Returns the result or applies the effect of the get affiliate statistics operation. Search terms: dashboard getaffiliatestatistics period from to.

hgr_get_dashboard_getaffiliatestatistics_period_from_to input schema

{
  "type": "object",
  "required": [
    "period",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "description": "HGRApi route parameter to."
    },
    "from": {
      "type": "string",
      "description": "HGRApi route parameter from."
    },
    "period": {
      "type": "string",
      "description": "HGRApi route parameter period."
    }
  },
  "additionalProperties": false
}

hgr_get_dashboard_getaffiliatestatistics_period_from_to output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_getaffiliatestatistics_period_from_to annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_getlistingservices — Get Dashboard Getlistingservices

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/GetListingServices. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Lists publication services purchased by the user. ownerAgent: account-metrics. Domain: services. Entity: listing_service. Operation: list. Scope: all_user_stores. Use when: Use it to show pending or purchased We List For You orders/services. Input: No explicit input parameters required. Does not use concrete listing ids. Output: Returns publication services and their status. Search terms: dashboard getlistingservices.

hgr_get_dashboard_getlistingservices input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_dashboard_getlistingservices output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_getlistingservices annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_getlistingsummary — Get Dashboard Getlistingsummary

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/GetListingSummary. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Returns an aggregate summary of published products, recent products and average price for the current channel. ownerAgent: account-metrics. Domain: listings. Entity: listing_summary. Operation: aggregate. Scope: current_store. Use when: Use it for dashboard views or aggregate metrics for the selected channel. Input: Header channel: current ChannelOAuthId. Does not use concrete listing ids. Output: Returns listing counters and aggregates. Search terms: dashboard getlistingsummary. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_dashboard_getlistingsummary input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_dashboard_getlistingsummary output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_getlistingsummary annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_getnoapiservers — Get Dashboard Getnoapiservers

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/GetNoApiServers. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get no api servers operation in dashboard data. Use when: Use it when a client needs to run the get no api servers operation for dashboard data. Input: No explicit input parameters required. Output: Returns the result or applies the effect of the get no api servers operation. Search terms: dashboard getnoapiservers.

hgr_get_dashboard_getnoapiservers input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_dashboard_getnoapiservers output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_getnoapiservers annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_getoptimizedcount — Get Dashboard Getoptimizedcount

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/GetOptimizedCount. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get optimized count operation in dashboard data. Use when: Use it when a client needs to run the get optimized count operation for dashboard data. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get optimized count operation. Search terms: dashboard getoptimizedcount. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_dashboard_getoptimizedcount input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_dashboard_getoptimizedcount output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_getoptimizedcount annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_getpendingstatistics — Get Dashboard Getpendingstatistics

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/GetPendingStatistics. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get pending statistics operation in dashboard data. Use when: Use it when a client needs to run the get pending statistics operation for dashboard data. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get pending statistics operation. Search terms: dashboard getpendingstatistics. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_dashboard_getpendingstatistics input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_dashboard_getpendingstatistics output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_getpendingstatistics annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_getupcomingwebinar — Get Dashboard Getupcomingwebinar

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/GetUpcomingWebinar. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get upcoming webinar operation in dashboard data. Use when: Use it when a client needs to run the get upcoming webinar operation for dashboard data. Input: No explicit input parameters required. Output: Returns the result or applies the effect of the get upcoming webinar operation. Search terms: dashboard getupcomingwebinar.

hgr_get_dashboard_getupcomingwebinar input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_dashboard_getupcomingwebinar output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_getupcomingwebinar annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_requestcode — Get Dashboard Requestcode

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/RequestCode. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET request code operation in dashboard data. Use when: Use it when a client needs to run the request code operation for dashboard data. Input: [FromQuery] id: int. Output: Returns the result or applies the effect of the request code operation. Search terms: dashboard requestcode.

hgr_get_dashboard_requestcode input schema

{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "integer",
      "description": "HGRApi query parameter id."
    }
  },
  "additionalProperties": false
}

hgr_get_dashboard_requestcode output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_requestcode annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dashboard_taskpendingautoorder2 — Get Dashboard Taskpendingautoorder2

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dashboard/TaskPendingAutoOrder2. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET task pending auto order2 operation in dashboard data. Use when: Use it when a client needs to run the task pending auto order2 operation for dashboard data. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the task pending auto order2 operation. Search terms: taskpendingautoorder 2, dashboard taskpendingautoorder 2. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_dashboard_taskpendingautoorder2 input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_dashboard_taskpendingautoorder2 output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dashboard_taskpendingautoorder2 annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_dispatch_get — Get Dispatch Get

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Dispatch/Get. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get operation in shipping and dispatch operations. Use when: Use it when a client needs to run the get operation for shipping and dispatch operations. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get operation. Search terms: dispatch get. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_dispatch_get input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_dispatch_get output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_dispatch_get annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_helpcentre_getticket_id — Get Helpcentre Getticket ID

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/HelpCentre/GetTicket/{id}. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Reads one authenticated CRM support ticket by visible ticket id. Domain: support. Entity: support_ticket. Operation: get_exact. Scope: authenticated_user. Use when: Use when the user asks about an existing support ticket and provides the visible TCK-* ticket reference. Input: [FromRoute] id: string. Legacy numeric ids are not supported. Output: Returns ticket detail including visible id/number, state, priority, dates, customer and messages. Search terms: helpcentre getticket id.

hgr_get_helpcentre_getticket_id input schema

{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "HGRApi route parameter id."
    }
  },
  "additionalProperties": false
}

hgr_get_helpcentre_getticket_id output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_helpcentre_getticket_id annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_listing_didlist — Get Listing Didlist

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Listing/DidList. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET did list operation in bulk publication and publication tracking. Use when: Use it when a client needs to run the did list operation for bulk publication and publication tracking. Input: No explicit input parameters required. Output: Returns the result or applies the effect of the did list operation. Search terms: listing didlist. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_listing_didlist input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_listing_didlist output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_listing_didlist annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_listing_listingscountperchannel — Get Listing Listingscountperchannel

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Listing/ListingsCountPerChannel. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET listings count per channel operation in bulk publication and publication tracking. Use when: Use it when a client needs to run the listings count per channel operation for bulk publication and publication tracking. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the listings count per channel operation. Search terms: listing listingscountperchannel. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_listing_listingscountperchannel input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_listing_listingscountperchannel output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_listing_listingscountperchannel annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_products_subscriptions_get — Get Products Subscriptions Get

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET Api/Products/Subscriptions/Get. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Lists the HGR listing-subscription plans and prices available to the requesting account. ownerAgent: account-metrics. supportingAgents: support, orchestrator. Domain: account_metrics. Entity: subscription_plan. Operation: list. Scope: product_catalog. AllowedIntents: subscription_plan_catalog. Use when: Use to quote monthly or annual plan prices and compare listing capacities. Input: No body or query input. Authentication is optional: sign in for eligible legacy prices. Anonymous requests receive public prices. Admin-only: false. The selected channel is not required. Output: Returns the complete enabled listing-plan catalogue. ProductOrder is listing capacity. Each price includes PlatformId, BillingPeriodId, CurrencyId, Price and PlatformProductId. LegacyPricing indicates continuing legacy subscription eligibility. Search terms: products subscriptions get.

hgr_get_products_subscriptions_get input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_products_subscriptions_get output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_products_subscriptions_get annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_sales_getorderimage_orderid_cache — Get Sales Getorderimage Orderid Cache

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Sales/GetOrderImage/{orderId}/{cache}. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get order image operation in sales/order operations. Use when: Use it when a client needs to run the get order image operation for sales/order operations. Input: [FromRoute] orderId: int. [FromRoute] cache: string. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get order image operation. Search terms: sales getorderimage orderid cache. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_sales_getorderimage_orderid_cache input schema

{
  "type": "object",
  "required": [
    "orderId",
    "cache"
  ],
  "properties": {
    "cache": {
      "type": "string",
      "description": "HGRApi route parameter cache."
    },
    "orderId": {
      "type": "string",
      "description": "HGRApi route parameter orderId."
    }
  },
  "additionalProperties": false
}

hgr_get_sales_getorderimage_orderid_cache output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_sales_getorderimage_orderid_cache annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_searchproduct_getmissinglistings — Get Searchproduct Getmissinglistings

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/SearchProduct/getMissingListings. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Returns marketplace/channel listings that HGR detected during the latest periodic synchronization as missing from HGR for the current store. ownerAgent: listings. Domain: listings. Entity: missing_listing. Operation: list_missing. Scope: current_store. Use when: Use it when the user asks what products or listings from the current store can be imported into HGR, what listings are missing in HGR, or what items were detected as not present after synchronization. Input: Header channel: current ChannelOAuthId. No body. Output: Returns missing listing candidates with ChannelItem, ChannelTitle, Sku and variation attributes. HGRApi removes entries that already exist in HGR as successfully created listings before returning them. Search terms: searchproduct getmissinglistings. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_searchproduct_getmissinglistings input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_searchproduct_getmissinglistings output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_searchproduct_getmissinglistings annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_searchproduct_getpendingnoapipreviousvalues — Get Searchproduct Getpendingnoapipreviousvalues

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/SearchProduct/GetPendingNoApiPreviousValues. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get pending no api previous values operation in existing published product/listing management. Use when: Use it when a client needs to run the get pending no api previous values operation for existing published product/listing management. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get pending no api previous values operation. Search terms: searchproduct getpendingnoapipreviousvalues. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_searchproduct_getpendingnoapipreviousvalues input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_searchproduct_getpendingnoapipreviousvalues output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_searchproduct_getpendingnoapipreviousvalues annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_searchproduct_pricechanges — Get Searchproduct Pricechanges

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/SearchProduct/PriceChanges. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Reads the recorded selling price change history shown in HGRWeb for one listing variation. ownerAgent: listings. Domain: listings. Entity: listing_price_history. Operation: read_history. Scope: exact_variation. Use when: Use it when the user asks for price history, price changes, previous selling prices or a price timeline of an identified or attached store product. Current price in the product details is not its history. Input: Required query id: positive internal ListingVariationId, not the parent ListingId, supplier ProductSourceId or marketplace Product ID. Resolve the attached product's visible Product ID through Listing/GetListings in the selected channel; use the matching variation Id. If several variations match, resolve the requested variation rather than choosing one arbitrarily. Output: Returns History entries with Date, Value (channel selling price), Author and Why when recorded. A successful History: [] means no recorded price changes for that variation. success=false or a missing History is a failed lookup, not evidence of no history. Search terms: searchproduct pricechanges. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_searchproduct_pricechanges input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_searchproduct_pricechanges output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_searchproduct_pricechanges annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_searchproduct_stockchanges — Get Searchproduct Stockchanges

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/SearchProduct/StockChanges. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Reads the recorded stock quantity change history shown in HGRWeb for one listing variation. ownerAgent: listings. Domain: listings. Entity: listing_stock_history. Operation: read_history. Scope: exact_variation. Use when: Use it when the user asks for stock history, stock changes, quantity changes, inventory history or an availability timeline of an identified or attached store product. Current stock in the product details is not its history. Input: Required query id: positive internal ListingVariationId, not the parent ListingId, supplier ProductSourceId or marketplace Product ID. Resolve the attached product's visible Product ID through Listing/GetListings in the selected channel; use the matching variation Id. If several variations match, resolve the requested variation rather than choosing one arbitrarily. Output: Returns History entries with Date, Value (channel stock quantity), Author and Why when recorded. A successful History: [] means no recorded stock changes for that variation. success=false or a missing History is a failed lookup, not evidence of no history. Search terms: searchproduct stockchanges. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_searchproduct_stockchanges input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_searchproduct_stockchanges output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_searchproduct_stockchanges annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_sources_get — Get Sources Get

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Sources/Get. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Lists supplier/source marketplaces available to the user and the current channel. ownerAgent: catalog-sources. supportingAgents: listings. Domain: sources. Entity: supplier_source. Operation: list. Scope: current_store. Use when: Use it to build supplier selectors, map sourceId values to visible names, resolve suppliers for a catalog search, or verify whether a supplier supports publication and Auto Ordering for the selected store and country. Use actual returned supplier IDs when a catalog search specifies a supplier; do not invent IDs. Input: [FromQuery] isoCountry: int?. Header channel: current ChannelOAuthId. If isoCountry is not sent, use the selected channel country. Output: Returns sources/suppliers with Id, Name, BaseUrl, Site, publication permissions, HasAutoOrder, AutoOrderingFee and other visible metadata. Search terms: sources get. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_sources_get input schema

{
  "type": "object",
  "required": [
    "channelOAuthId"
  ],
  "properties": {
    "isoCountry": {
      "type": "integer",
      "description": "HGRApi query parameter isoCountry."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_get_sources_get output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_sources_get annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_sources_getpublic — Get Sources Getpublic

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Sources/GetPublic. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Lists visible supplier/source marketplaces and their capabilities for a requested country without requiring a selected channel. ownerAgent: catalog-sources. supportingAgents: account-metrics, orders-autoordering, support. Domain: sources. Entity: supplier_source. Operation: list. Scope: country_catalog. AllowedIntents: supplier_capabilities. Use when: Use it for general commercial or pre-sales questions about suppliers available in a country, publication methods, Auto Ordering support, or the configured Auto Ordering fee when no authenticated store context is required. SearchTerms: suppliers available by country, supplier capabilities by country, Amazon Italy Auto Ordering, Amazon.it Auto Ordering, supplier Auto Ordering fee, supported suppliers in Italy. NegativeUseCases: Do not use it to claim that a supplier account is configured for the current user; Do not use it to list private suppliers belonging to the authenticated user. Input: Required [FromQuery] isoCountry: string. Use the two-letter HGR country code inferred from the marketplace or country named by the user, such as IT for Italy. Output: Returns visible sources/suppliers for the country with Id, Name, BaseUrl, Site, publication permissions, HasAutoOrder and AutoOrderingFee. Search terms: sources getpublic.

hgr_get_sources_getpublic input schema

{
  "type": "object",
  "required": [
    "isoCountry"
  ],
  "properties": {
    "isoCountry": {
      "type": "string",
      "description": "HGRApi query parameter isoCountry."
    }
  },
  "additionalProperties": false
}

hgr_get_sources_getpublic output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_sources_getpublic annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_sources_goout — Get Sources Goout

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Sources/GoOut. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET go out operation in source/supplier reading. Use when: Use it when a client needs to run the go out operation for source/supplier reading. Input: [FromQuery] sourceUrl: string. [FromQuery] isoCountry: int?. [FromQuery] channelListingId: int?. Output: Returns the result or applies the effect of the go out operation. Search terms: sources goout. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_get_sources_goout input schema

{
  "type": "object",
  "required": [
    "sourceUrl",
    "channelOAuthId"
  ],
  "properties": {
    "sourceUrl": {
      "type": "string",
      "description": "HGRApi query parameter sourceUrl."
    },
    "isoCountry": {
      "type": "integer",
      "description": "HGRApi query parameter isoCountry."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "channelListingId": {
      "type": "integer",
      "description": "HGRApi query parameter channelListingId."
    }
  },
  "additionalProperties": false
}

hgr_get_sources_goout output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_sources_goout annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_user_gettokenbalance — Get User Gettokenbalance

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET Api/User/GetTokenBalance. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get token balance operation in visible user data. Use when: Use it when a client needs to run the get token balance operation for visible user data. Input: No explicit input parameters required. Output: Returns the result or applies the effect of the get token balance operation. Search terms: user gettokenbalance.

hgr_get_user_gettokenbalance input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_user_gettokenbalance output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_user_gettokenbalance annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_user_gettokenhistory — Get User Gettokenhistory

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET Api/User/GetTokenHistory. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Returns the authenticated user's token usage history. ownerAgent: account-metrics. Domain: account_tokens. Entity: token_history. Operation: list. Scope: authenticated_user. Use when: Use it when the authenticated user needs to review token charges, credits, awards, paid token entries or AI action usage history. Input: No body. Uses the authenticated user id from Authorization. No Header channel / ChannelOAuthId required. Not admin-only. Output: Returns history items with ReferenceType, Title, TokenAmount, UpdatedOn and ActionTypes. Search terms: user gettokenhistory.

hgr_get_user_gettokenhistory input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_user_gettokenhistory output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_user_gettokenhistory annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_winning_get_id — Get Winning Get ID

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Winning/Get/{id}. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET get operation in winning product generation reading. Use when: Use it when a client needs to run the get operation for winning product generation reading. Input: [FromRoute] id: int. Output: Returns the result or applies the effect of the get operation. Search terms: winning get id.

hgr_get_winning_get_id input schema

{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "HGRApi route parameter id."
    }
  },
  "additionalProperties": false
}

hgr_get_winning_get_id output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_winning_get_id annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_get_winning_list — Get Winning List

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for GET api/Winning/List. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the GET list operation in winning product generation reading. Use when: Use it when a client needs to run the list operation for winning product generation reading. Input: No explicit input parameters required. Output: Returns the result or applies the effect of the list operation. Search terms: winning list.

hgr_get_winning_list input schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

hgr_get_winning_list output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_get_winning_list annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_ai_createtask — Post Ai Createtask

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/AI/CreateTask. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST create task operation in AI optimization task management. Use when: Use it when a client needs to run the create task operation for AI optimization task management. Input: rq: Data.CreateTaskRequest. Main fields: Action: AIActionType, AutoPublish: bool, Listings: int[], Settings: CreateTaskRequestSetting[]. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the create task operation. Search terms: ai createtask. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_ai_createtask input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/AI/CreateTask request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_ai_createtask output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_ai_createtask annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_ai_getimageinfo — Post Ai Getimageinfo

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/AI/GetImageInfo. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST get image info operation in AI optimization task management. Use when: Use it when a client needs to run the get image info operation for AI optimization task management. Input: rq: GetImageInfoRequest. Main fields: Ids: int[]. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get image info operation. Search terms: ai getimageinfo. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_ai_getimageinfo input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/AI/GetImageInfo request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_ai_getimageinfo output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_ai_getimageinfo annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_ai_gettaskresult — Post Ai Gettaskresult

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/AI/GetTaskResult. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST get task result operation in AI optimization task management. Use when: Use it when a client needs to run the get task result operation for AI optimization task management. Input: rq: GetTaskResultRequest. Main fields: TaskId: int, ListingId: int. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get task result operation. Search terms: ai gettaskresult. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_ai_gettaskresult input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/AI/GetTaskResult request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_ai_gettaskresult output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_ai_gettaskresult annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_ai_publishnow — Post Ai Publishnow

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/AI/PublishNow. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST publish now operation in AI optimization task management. Use when: Use it when a client needs to run the publish now operation for AI optimization task management. Input: rq: PublishNowRequest. Main fields: TaskId: int, ListingId: int. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the publish now operation. Search terms: ai publishnow. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_ai_publishnow input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/AI/PublishNow request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_ai_publishnow output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_ai_publishnow annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_analytics_addwork — Post Analytics Addwork

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Analytics/AddWork. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST add work operation in current-channel watcher analytics. Use when: Use it when a client needs to run the add work operation for current-channel watcher analytics. Input: rq: AddWorkRequest. Main fields: Ids: int[]. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the add work operation. Search terms: analytics addwork. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_analytics_addwork input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Analytics/AddWork request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_analytics_addwork output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_analytics_addwork annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_catalog_getproducts — Post Catalog Getproducts

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/Catalog/GetProducts. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides supplier candidates for publication. ownerAgent: catalog-sources. Opening the catalog returns stored recommendations; explicit web, AI chat and MCP searches discover products through a deep internet search that may take several minutes. Use when: Use for catalog/source candidate discovery, not existing store inventory, importing store products, stock checks or ranking active listings. AI chat and MCP may search and apply the documented catalog filters, including themes, seasons and occasions such as Mother's Day gifts. Warn the user in their language before starting that a deep internet search may take several minutes; do not require confirmation for this read-only search. Input: CatalogProductsRequest. Header channel identifies the selected store and country. Search=false or omitted returns all type-0 country recommendations; SessionId preserves random order. For explicit searches from the web, AI chat or MCP set Search=true. Search accepts SourceIds, PriceFrom/PriceTo, ProfitFrom/ProfitTo, Prime options, Criteria as only the human-written free-text product search prompt (not a literal title substring) and optional Tags (selected theme/category integer IDs, using the same IDs as AI Publisher orders). When SourceIds is omitted or empty, searches use up to four distinct eligible supplier domains with the highest priority for the store's country and channel; source ID ascending breaks priority ties. Explicit supplier inclusions or exclusions retain their existing behavior. Theme, category, trending and store exclusion filters remain separate from Criteria. When Criteria is empty, categories and seasonal themes are expanded into related product families before searching; a human-written Criteria skips this expansion. Trending remains a search requirement. Price/profit requirements use effective channel/supplier settings and fees. For example, a Mother's Day product search uses {"search":true,"criteria":"Mother's Day gifts"}. Do not invent a quantity parameter; show the requested number from the returned candidates. Output: Returns Products with SourceId, Url, Title, ImageUrl, SourcePrice, ChannelPrice, Profit and SubOrigin. Initial candidates have CatalogSelection=1; search candidates have CatalogSearch=2. Publish by URL rather than ProductSourceId. Initial mode returns the complete stored country collection. Search returns at most 50 candidates total and can return fewer or none when no eligible products are found. TotalResults and PageSize are the returned count. Search terms: catalog getproducts. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_catalog_getproducts input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Catalog/GetProducts request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_catalog_getproducts output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_catalog_getproducts annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_catalog_submitcatalog — Post Catalog Submitcatalog

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Catalog/SubmitCatalog. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Queues selected catalog candidates for publication or review. ownerAgent: publication. Use when: Use after selecting real candidates from Catalog/GetProducts. Not for discovering products, importing existing store inventory, or publishing ad-hoc URLs; use Listing/SaveBulkPublish for general URL publication. Input: CatalogSubmitRequest. Header channel is required. Each ProductsToList item contains the exact Url, Title, SubOrigin (CatalogSelection=1 or CatalogSearch=2) and optional PublishOn for individual scheduling. Optimization/review options and Origin remain supported. Legacy Id and DelaysMap remain accepted for existing first-steps clients. UserDevice is optional web telemetry; AI chat and MCP omit it. Output: Creates URL-based bulk jobs, records SubOrigin while preserving Origin=Catalog, and returns BatchId. Token/quota validation applies. Search terms: catalog submitcatalog. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally. Internal-only request fields are removed automatically before the HGRApi request is sent.

hgr_post_catalog_submitcatalog input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Catalog/SubmitCatalog request body. Internal-only request fields are removed automatically."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_catalog_submitcatalog output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_catalog_submitcatalog annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_channellisting_clearonevariation — Post Channellisting Clearonevariation

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/ClearOneVariation. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST clear one variation operation in published product creation and optimization. Use when: Use it when a client needs to run the clear one variation operation for published product creation and optimization. Input: rq: ClearVariationsRequest. Main fields: ChannelListingId: int. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the clear one variation operation. Search terms: channellisting clearonevariation. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_clearonevariation input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/ClearOneVariation request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_clearonevariation output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_clearonevariation annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_channellisting_clearvariations — Post Channellisting Clearvariations

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/ClearVariations. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST clear variations operation in published product creation and optimization. Use when: Use it when a client needs to run the clear variations operation for published product creation and optimization. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the clear variations operation. Search terms: channellisting clearvariations. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_clearvariations input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/ClearVariations request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_clearvariations output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_clearvariations annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_channellisting_getcategoriesbytext — Post Channellisting Getcategoriesbytext

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/getCategoriesByText. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST get categories by text operation in published product creation and optimization. Use when: Use it when a client needs to run the get categories by text operation for published product creation and optimization. Input: [FromBody] rq: GetCategoriesByTextRequest. Main fields: Text: string. Header channel: current ChannelOAuthId. Output: Returns the categories whose name contains the text. When no category name contains it, returns suggested categories for the text: for eBay and TikTok stores the first one is the HGR suggestion for that text, followed by the marketplace suggestions. Search terms: channellisting getcategoriesbytext. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_getcategoriesbytext input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/getCategoriesByText request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_getcategoriesbytext output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_getcategoriesbytext annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_channellisting_getcategoryspecifics — Post Channellisting Getcategoryspecifics

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/GetCategorySpecifics. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Returns category field definitions and populated values for manual product preparation. ownerAgent: publication. Use when: Use when the manual product form needs fields for its selected category and supplier product data. Input: GetCategorySpecificsRequest: SourceId, Price, CategoryId, Title, Paragraphs, Features, TableValues. Header channel: current ChannelOAuthId. Admin: false. Output: response_data remains the category field collection. Admin or impersonated sessions additionally receive debug alongside response_data, with actual product inputs and returned definitions, restrictions and values. Missing initial values, internal filling decisions and browser-side changes are explicitly marked as unavailable, never inferred. A failed category-field request includes admin debug with its trace ID in the error response. Search terms: channellisting getcategoryspecifics. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_getcategoryspecifics input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/GetCategorySpecifics request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_getcategoryspecifics output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_getcategoryspecifics annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_channellisting_getsuggestedcategories — Post Channellisting Getsuggestedcategories

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/getSuggestedCategories. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST get suggested categories operation in published product creation and optimization. Use when: Use it when a client needs to run the get suggested categories operation for published product creation and optimization. Input: [FromBody] rq: Request.GetSuggestedCategoriesRequest. Main fields: Url: string, Text: string. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get suggested categories operation. Search terms: channellisting getsuggestedcategories. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_getsuggestedcategories input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/getSuggestedCategories request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_getsuggestedcategories output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_getsuggestedcategories annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_channellisting_getsuggestedtitles — Post Channellisting Getsuggestedtitles

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/GetSuggestedTitles. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST get suggested titles operation in published product creation and optimization. Use when: Use it when a client needs to run the get suggested titles operation for published product creation and optimization. Input: [FromBody] request: SuggestedTitles. Main fields: CategoryId: int, Product: SourceProduct. Output: Returns the result or applies the effect of the get suggested titles operation. Search terms: channellisting getsuggestedtitles. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_getsuggestedtitles input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/GetSuggestedTitles request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_getsuggestedtitles output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_getsuggestedtitles annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_channellisting_list — Post Channellisting List

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/List. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Resolves one supplier product URL into validated product data for listing creation. ownerAgent: publication. Use when: Use when a user has submitted one concrete supplier product URL and needs the product data required to prepare a listing. Input: ListRequest body with Url and optional extension ExtraData. Header channel: current ChannelOAuthId. Output: Returns ComListing with validated product data when details can be obtained. A successful product response may also include OtherUrls so compatible extension clients can offer an optional switch to bulk publish. For a recognized product URL whose details cannot be obtained, returns Success=false with ErrorType=UnknownProduct without OtherUrls. Non-product pages may return OtherUrls for bulk discovery. Search terms: channellisting list. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_list input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/List request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_list output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_list annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_channellisting_monitorexistinglisting — Post Channellisting Monitorexistinglisting

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/MonitorExistingListing. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Imports or monitors existing channel listings in HGR. Imported listings are always activated. ownerAgent: publication. Use when: Use when concrete existing store listing/product ids and source URLs are already selected and the user wants HGR to monitor/import those existing listings. Input: [FromBody] model: AddListingModel. Main fields: OAuthId: int, Listings: ListingToMonitor[]. Header channel: current ChannelOAuthId. ToRelist is currently ignored. UserDevice is optional HGRWeb client telemetry; AI chat and MCP must omit it and must not invent a device value. Output: Returns import/monitoring results with inserted, invalid, repeated and quota-related entries. Imported eBay API variations preserve VAT when the store supplies it; unknown VAT is not inferred from the publication default. Search terms: channellisting monitorexistinglisting. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally. Internal-only request fields are removed automatically before the HGRApi request is sent.

hgr_post_channellisting_monitorexistinglisting input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/MonitorExistingListing request body. Internal-only request fields are removed automatically."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_monitorexistinglisting output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_monitorexistinglisting annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_channellisting_monitorexistinglisting2 — Post Channellisting Monitorexistinglisting2

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/MonitorExistingListing2. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Imports existing store products into HGR with live progress over one HTTP stream. Imported products are activated; no new marketplace adverts are published. ownerAgent: publication. Use when: Use when exact existing store product ids and supplier URLs are selected and the caller can keep an SSE response open. Send the entire selection in one request. Do not use for catalog discovery or new marketplace publication. Input: Authenticated, not admin-only. Body: AddListingModel with Listings containing Id, SourceURL and optional VariationSku, VariationAttributes, SourceVariation, SourceWarehouse, Markup and Title. Requires Header channel: authorized ChannelOAuthId; the body OAuthId does not override it. ToRelist is ignored. UserDevice is optional web telemetry; AI and MCP must omit it. Output: SSE progress events contain phase, total, processed, imported, alreadyExisting, rejected, failed and optional itemId, error, pages, totalPages and cachedProducts. The terminal completed event contains inserted, wereInYourHGR, repeated, emptyUrl, notValidUrl, failed (id, variationSku, error), total, processed, ok and error. Inspect ok, failed and processed/total; a terminal event alone does not mean all products were imported. An unexpected stream failure emits error. Search terms: monitorexistinglisting 2, channellisting monitorexistinglisting 2. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_monitorexistinglisting2 input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/MonitorExistingListing2 request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_monitorexistinglisting2 output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_monitorexistinglisting2 annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_channellisting_optimizeimage — Post Channellisting Optimizeimage

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/OptimizeImage. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST optimize image operation in published product creation and optimization. Use when: Use it when a client needs to run the optimize image operation for published product creation and optimization. Input: rq: OptimizeImageRequest. Main fields: ImageUrl: string, Action: AIActionType, Settings: Setting[]. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the optimize image operation. Search terms: channellisting optimizeimage. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_optimizeimage input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/OptimizeImage request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_optimizeimage output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_optimizeimage annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_channellisting_optimizespecificfields — Post Channellisting Optimizespecificfields

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/ChannelListing/OptimizeSpecificFields. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST optimize specific fields operation in published product creation and optimization. Use when: Use it when a client needs to run the optimize specific fields operation for published product creation and optimization. Input: rq: OptimizeSpecificFieldsRequest. Main fields: ProductSourceId: int, Fields: ChannelSpecificField[]. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the optimize specific fields operation. Search terms: channellisting optimizespecificfields. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_channellisting_optimizespecificfields input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ChannelListing/OptimizeSpecificFields request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_channellisting_optimizespecificfields output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_channellisting_optimizespecificfields annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_dispatch_getshipmentdetails — Post Dispatch Getshipmentdetails

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/Dispatch/GetShipmentDetails. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST get shipment details operation in shipping and dispatch operations. Use when: Use it when a client needs to run the get shipment details operation for shipping and dispatch operations. Input: [FromBody] request: GetShipmentDetailsRequest. Main fields: TrackingCode: string. Output: Returns the result or applies the effect of the get shipment details operation. Search terms: dispatch getshipmentdetails. Send the exact request payload in body.

hgr_post_dispatch_getshipmentdetails input schema

{
  "type": "object",
  "required": [
    "body"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Dispatch/GetShipmentDetails request body."
    }
  },
  "additionalProperties": false
}

hgr_post_dispatch_getshipmentdetails output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_dispatch_getshipmentdetails annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_dispatch_updateshipmentdetails — Post Dispatch Updateshipmentdetails

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Dispatch/UpdateShipmentDetails. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST update shipment details operation in shipping and dispatch operations. Use when: Use it when a client needs to run the update shipment details operation for shipping and dispatch operations. Input: [FromBody] request: VelociPackerShipmentUpdateRequest. Main fields: TrackingCode: string, OrderReference: string, DeliveredOn: DateTime. Output: Returns the result or applies the effect of the update shipment details operation. Search terms: dispatch updateshipmentdetails. Send the exact request payload in body. Requires confirmed=true before execution.

hgr_post_dispatch_updateshipmentdetails input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Dispatch/UpdateShipmentDetails request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    }
  },
  "additionalProperties": false
}

hgr_post_dispatch_updateshipmentdetails output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_dispatch_updateshipmentdetails annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_helpcentre_contact — Post Helpcentre Contact

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/HelpCentre/Contact. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Creates a legacy authenticated help-centre contact ticket. Domain: support. Entity: support_ticket. Operation: create. Scope: authenticated_user. Use when: Use for legacy contact form submissions where a visible ticket id is not required. AIChat must prefer Contact2 when it needs to show the created ticket reference/link. Input: rq: ContactModel. Main fields: Message: string, Attachments: Attachment[]. Optional X-HGR-Client: ai_chat identifies the HGR AI chat gateway; normal web requests omit it. Output: Boolean success flag only. It does not return a visible ticket id. The creation event actor is human for web submissions or ai_chat for HGR AI chat; the first message remains an inbound customer message. Search terms: helpcentre contact. Send the exact request payload in body. Requires confirmed=true before execution.

hgr_post_helpcentre_contact input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/HelpCentre/Contact request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    }
  },
  "additionalProperties": false
}

hgr_post_helpcentre_contact output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_helpcentre_contact annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_listing_autolist — Post Listing Autolist

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Listing/AutoList. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST auto list operation in bulk publication and publication tracking. Use when: Use it when a client needs to run the auto list operation for bulk publication and publication tracking. Input: request: AutoListRequest. Main fields: WeListForYou: bool. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the auto list operation. Search terms: listing autolist. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_listing_autolist input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Listing/AutoList request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listing_autolist output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listing_autolist annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_listing_getbulkhistory — Post Listing Getbulkhistory

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/Listing/GetBulkHistory. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Returns recent bulk publication jobs and their recorded status/errors for the selected store. ownerAgent: publication. Use when: Use it to inspect bulk publication history and diagnose a job's recorded error. Input: Optional AutoListRequest. Header channel: current ChannelOAuthId. Output: Returns logs with job status, error code, listing status and origin. EnumValues maps the numeric codes. ChannelListingStatusFlags is a bitmask: decode every set bit, not the whole number as one ordinal. Search terms: listing getbulkhistory. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_listing_getbulkhistory input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Listing/GetBulkHistory request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listing_getbulkhistory output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listing_getbulkhistory annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_listing_getscrapingconfig — Post Listing Getscrapingconfig

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/Listing/GetScrapingConfig. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Returns supplier page extraction settings for the listing extension and bulk publication. Use when: Use it to identify product details and product links from a supported supplier page. Input: rq: GetScrapingConfigRequest. Main fields: Url: string, Site: eCountry?. Header channel: current ChannelOAuthId; Site defaults to the current store country. Output: Returns supplier-specific extraction settings. Keeps a configured product-link selector; uses all page links only when no link selector is configured. Search terms: listing getscrapingconfig. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_listing_getscrapingconfig input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Listing/GetScrapingConfig request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listing_getscrapingconfig output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listing_getscrapingconfig annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_listing_migratebulk — Post Listing Migratebulk

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Listing/MigrateBulk. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Queues selected listings for migration to a target channel in bulk. ownerAgent: publication. Use when: Use when concrete listing ids and a target channel are already selected and the user wants to migrate/copy them in bulk. Input: data: MigrateBulkRequest. Main fields: ListingIds: int[], TargetId: int, listFrequencyMinutes: int, dontListUntil: DateTime?, reviewBeforePublishing: bool, createdBy: int, ignoreVero: bool, ignoreOOS: bool, optimizeTitle: bool, optimizeDescription: bool, optimizeFields: bool. Header channel: current ChannelOAuthId. UserDevice is optional HGRWeb client telemetry; AI chat and MCP must omit it and must not invent a device value. Output: Creates migration bulk jobs for the selected listing ids. Search terms: listing migratebulk. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally. Internal-only request fields are removed automatically before the HGRApi request is sent.

hgr_post_listing_migratebulk input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Listing/MigrateBulk request body. Internal-only request fields are removed automatically."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_listing_migratebulk output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listing_migratebulk annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_listing_partner — Post Listing Partner

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Listing/Partner. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST partner operation in bulk publication and publication tracking. Use when: Use it when a client needs to run the partner operation for bulk publication and publication tracking. Input: request: AutoListRequest. Main fields: WeListForYou: bool. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the partner operation. Search terms: listing partner. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_listing_partner input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Listing/Partner request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listing_partner output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listing_partner annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_listing_relistedbulk2 — Post Listing Relistedbulk2

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Listing/RelistedBulk2. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Queues selected existing listings for relisting in bulk. ownerAgent: publication. Use when: Use when concrete listing ids are already selected and the user wants to relist them in bulk. Input: data: RelistedBulk2Request. Main fields: ListingIds: int[], listFrequencyMinutes: int, dontListUntil: DateTime?, reviewBeforePublishing: bool, createdBy: int, ignoreVero: bool, ignoreOOS: bool, optimizeTitle: bool, optimizeDescription: bool, optimizeFields: bool. Header channel: current ChannelOAuthId. UserDevice is optional HGRWeb client telemetry; AI chat and MCP must omit it and must not invent a device value. Output: Creates relist bulk jobs for the selected listing ids. Search terms: relistedbulk 2, listing relistedbulk 2. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally. Internal-only request fields are removed automatically before the HGRApi request is sent.

hgr_post_listing_relistedbulk2 input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Listing/RelistedBulk2 request body. Internal-only request fields are removed automatically."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listing_relistedbulk2 output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listing_relistedbulk2 annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_listing_saveautolist — Post Listing Saveautolist

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Listing/SaveAutolist. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Saves a bulk/autolist publication batch. ownerAgent: publication. Use when: Use when the user wants to queue multiple source URLs for publication or review through the autolist/bulk listing flow. Input: data: SaveAutolistRequest. Main fields: listings: string[][], listFrequencyMinutes: int, dontListUntil: DateTime?, reviewBeforePublishing: bool, createdBy: int, ignoreVero: bool, ignoreOOS: bool, optimizeTitle: bool, optimizeDescription: bool, optimizeFields: bool, publishVariations: bool, WeListForYou: bool, GeneratorId: int?. Each listings row is [sourceUrl] or [sourceUrl, optionalTitle]. sourceUrl is required; an omitted, null or empty title means no custom title is supplied. A supplied title is preserved. Header channel: current ChannelOAuthId. UserDevice is optional HGRWeb client telemetry; AI chat and MCP must omit it and must not invent a device value. Output: Creates bulk listing jobs and returns an AutolistSummaryViewModel with processed, duplicated, invalid and quota-related counts. Search terms: listing saveautolist. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally. Internal-only request fields are removed automatically before the HGRApi request is sent.

hgr_post_listing_saveautolist input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Listing/SaveAutolist request body. Internal-only request fields are removed automatically."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listing_saveautolist output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listing_saveautolist annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_listing_savebulkpublish — Post Listing Savebulkpublish

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Listing/SaveBulkPublish. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Saves a batch of URLs for bulk publication and returns one result per line. ownerAgent: publication. SearchTerms: save bulk publish, bulk publish, bulk publishing, mass publication, publicar en bulk. Use when: Use it when the client needs to know exactly which line was processed and which line was rejected without summarizing only by counts. Use it when selected products are source product URLs, Amazon URLs, ASIN URLs converted to source URLs, or source-page URLs. Do not use it to get existing listings or search candidates. Input: data: SaveAutolistRequest. Main fields: listings: string[][], listFrequencyMinutes: int, dontListUntil: DateTime?, reviewBeforePublishing: bool, createdBy: int, ignoreVero: bool, ignoreOOS: bool, optimizeTitle: bool, optimizeDescription: bool, optimizeFields: bool, publishVariations: bool, WeListForYou: bool. listings is string[][] where each row is [sourceUrl, optionalTitle]; sourceUrl is the supplier/source product URL to publish. Use reviewBeforePublishing for pending review, optimizeTitle/optimizeDescription/optimizeFields for optimization choices, and listFrequencyMinutes/dontListUntil for delayed publication. Do not send CatalogSubmitRequest.ProductsToList here. Header channel: current ChannelOAuthId. Internal client fields are managed by the tool and are not tool inputs. Output: Returns SaveBulkPublishLineStatus[] in the same order as listings. Values: Processed, ForbiddenWordsUrl, DuplicatedUrl, InvalidUrl, InvalidSourceUrl, ExistingListing, NoQuota, InvalidGenerator or DuplicatedProductSource. Search terms: listing savebulkpublish. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally. Internal-only request fields are removed automatically before the HGRApi request is sent.

hgr_post_listing_savebulkpublish input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Listing/SaveBulkPublish request body. Internal-only request fields are removed automatically."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_listing_savebulkpublish output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listing_savebulkpublish annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_listingcreate_editpending — Post Listingcreate Editpending

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/ListingCreate/EditPending. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST edit pending operation in manual product creation. Use when: Use it when a client needs to run the edit pending operation for manual product creation. Input: [FromBody] rq: EditPendingRequest. Main fields: ListingId: int. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the edit pending operation. Search terms: listingcreate editpending. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_listingcreate_editpending input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ListingCreate/EditPending request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listingcreate_editpending output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listingcreate_editpending annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_listingcreate_getdata — Post Listingcreate Getdata

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/ListingCreate/GetData. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Resolves one supplier URL into validated product and draft-listing data for the extension's manual product flow. ownerAgent: publication. Use when: Use when the extension submits one supplier URL and needs the product details required to prepare a manual product. Input: GetDataRequest body with Url and optional extension ExtraData. AliExpress URLs may include selected variation labels and a native skuId. Header channel: current ChannelOAuthId. Admin: false. Output: Returns ProductInformation and Listing when complete product details can be obtained. AliExpress manual imports refresh the selected SKU and full variation family from the supplier even when cached product details exist. ASOS UK, Matalan and Home Bargains imports refresh supplier data when the cached or browser-extracted product has no variations; the returned product uses its selected size identity to avoid an empty parent option and retain a stable size-specific URL. Explicit ASOS UK product URLs with a selected variant preserve that exact size and avoid adding a duplicate selected-size option when the same size is already present in the variation family. Explicit AliExpress SKU selections are preserved; invalid or conflicting selections return an error instead of substituting the first variation. Variation labels remain separate from other URL parameters. A successful product response may also include OtherUrls so the client can offer an optional switch to bulk publish. A recognized product whose details cannot be obtained returns ErrorType=UnknownProduct without OtherUrls; non-product pages may return OtherUrls for bulk discovery. Admin or impersonated sessions additionally receive Debug with extraction configuration excluding cookies, intermediate product snapshots, data-source decisions and final product/draft fields. Category filling is diagnosed separately through ChannelListing/GetCategorySpecifics; browser-side changes are not observed here. Search terms: listingcreate getdata. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_listingcreate_getdata input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ListingCreate/GetData request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listingcreate_getdata output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listingcreate_getdata annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_listingcreate_getdatabypsids — Post Listingcreate Getdatabypsids

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/ListingCreate/GetDataByPSIds. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Loads current supplier data for the exact product-source variations used during manual multi-variation product creation. ownerAgent: publication. Domain: publication. Entity: product_source_variation_data. Operation: read_and_refresh. Scope: selected_channel. Use when: Use it when the manual product form needs price, stock, EAN and source images for a known set of exact ProductSourceIds, especially before displaying or publishing all supplier variations. Do not use it to discover products or variations without exact ProductSourceIds, or for existing store-listing collection or ranking. Input: [FromBody] rq: GetDataByPSIdsRequest. Main fields: ProductSourceIds: int[]. Header channel: current ChannelOAuthId. Admin: false. Output: Returns ProductSources keyed by the requested ProductSourceId, with available images, price, stock and EAN. Cached stock is read from saved supplier stock options. Matalan and Home Bargains sizes are refreshed with live stock information, including zero stock for unavailable sizes. Sources configured for live refresh return non-empty freshly scraped images immediately; cached images are retained only when the refresh supplies no images. Requested AliExpress variation URLs using a readable selection, a numeric skuId/sku_id, or both together, without a saved supplier SKU are refreshed to resolve that exact variation and load its images. These AliExpress child refreshes obtain stock information and return refreshed data only after the supplier identity, price and available stock have been saved. If the supplier identity, price or available stock cannot be confirmed, or saving fails, the response retains cached data. Bare AliExpress product URLs are not refreshed by this recovery rule. The refresh can also update stored product-source data. Search terms: listingcreate getdatabypsids. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_listingcreate_getdatabypsids input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ListingCreate/GetDataByPSIds request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_listingcreate_getdatabypsids output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listingcreate_getdatabypsids annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_listingcreate_submit — Post Listingcreate Submit

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/ListingCreate/Submit. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Submits a manually prepared listing for creation. ownerAgent: publication. Use when: Use only after manual listing creation data has already been prepared and the user wants to create or queue that exact listing. Input: [FromBody] rq: SubmitCreateRequest, compatible with CreateRequest. Variation Markup settings are rounded to the nearest integer, with midpoint values rounded away from zero. Non-finite, malformed or out-of-range Markup values are ignored without deleting an existing override. For eBay API only, a missing VAT variation setting is initialized from the saved draft VAT or the store's PublishVAT default. Explicit product VAT, including zero, is preserved. VAT must be an integer from 0 to 100. UserDevice is optional HGRWeb client telemetry; AI chat and MCP must omit it and must not invent a device value. Output: Creates the listing through ListingService and returns success. Search terms: listingcreate submit. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally. Internal-only request fields are removed automatically before the HGRApi request is sent.

hgr_post_listingcreate_submit input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/ListingCreate/Submit request body. Internal-only request fields are removed automatically."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_listingcreate_submit output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_listingcreate_submit annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_notificationcenter_getall — Post Notificationcenter Getall

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/NotificationCenter/GetAll. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST get all operation in notification centre operations. Use when: Use it when a client needs to run the get all operation for notification centre operations. Input: rq: GetAllRequest. Main fields: Page: int. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get all operation. Search terms: notificationcenter getall. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_notificationcenter_getall input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/NotificationCenter/GetAll request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_notificationcenter_getall output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_notificationcenter_getall annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_notificationcenter_markallasread — Post Notificationcenter Markallasread

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/NotificationCenter/MarkAllAsRead. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST mark all as read operation in notification centre operations. Use when: Use it when a client needs to run the mark all as read operation for notification centre operations. Input: No explicit input parameters required. Output: Returns the result or applies the effect of the mark all as read operation. Search terms: notificationcenter markallasread. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_notificationcenter_markallasread input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/NotificationCenter/MarkAllAsRead request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_notificationcenter_markallasread output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_notificationcenter_markallasread annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_notificationcenter_markallchannelasread — Post Notificationcenter Markallchannelasread

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/NotificationCenter/MarkAllChannelAsRead. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST mark all channel as read operation in notification centre operations. Use when: Use it when a client needs to run the mark all channel as read operation for notification centre operations. Input: Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the mark all channel as read operation. Search terms: notificationcenter markallchannelasread. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_notificationcenter_markallchannelasread input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/NotificationCenter/MarkAllChannelAsRead request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_notificationcenter_markallchannelasread output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_notificationcenter_markallchannelasread annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_notificationcenter_markasread — Post Notificationcenter Markasread

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/NotificationCenter/MarkAsRead. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST mark as read operation in notification centre operations. Use when: Use it when a client needs to run the mark as read operation for notification centre operations. Input: rq: MarkAsReadRequest. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the mark as read operation. Search terms: notificationcenter markasread. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_notificationcenter_markasread input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/NotificationCenter/MarkAsRead request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_notificationcenter_markasread output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_notificationcenter_markasread annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_sales_fixedorderline — Post Sales Fixedorderline

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Sales/FixedOrderLine. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Completes an exact order line that is in CompletedAutoOrderPending. ownerAgent: orders-autoordering. Domain: orders. Entity: order_line. Operation: complete_pending_autoorder. Scope: current_store. Use when: Use only for an exact order line whose current state is CompletedAutoOrderPending and the user confirms the corresponding visible Mark as Purchased action. Input: [FromBody] rq: LoadAddressesFromOrderLineRequest. Main fields: OrderLineIds: int[]. Required Header channel: current ChannelOAuthId. Output: Moves eligible CompletedAutoOrderPending lines to CompletedAutoOrder and returns refreshed order data. Search terms: sales fixedorderline. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_fixedorderline input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/FixedOrderLine request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_fixedorderline output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_fixedorderline annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_sales_forceprocessorderline — Post Sales Forceprocessorderline

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Sales/ForceProcessOrderLine. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST force process order line operation in sales/order operations. Use when: Use it when a client needs to run the force process order line operation for sales/order operations. Input: [FromBody] rq: LoadAddressesFromOrderLineRequest. Main fields: OrderLineIds: int[]. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the force process order line operation. Search terms: sales forceprocessorderline. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_forceprocessorderline input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/ForceProcessOrderLine request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_forceprocessorderline output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_forceprocessorderline annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_sales_generatetrackingid — Post Sales Generatetrackingid

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Sales/GenerateTrackingId. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Generates an HGR/VelociPacker tracking number for exact existing order lines that have already been processed or marked as purchased. ownerAgent: orders-autoordering. Domain: orders. Entity: order_line. Operation: generate_tracking. Scope: current_store. Use when: Use it when the user explicitly asks HGR to generate tracking for an existing order. A manually purchased supplier order must first be marked as purchased in HGR; in HGRWeb the user then clicks Generate it in Orders. Input: [FromBody] rq: LoadAddressesFromOrderLineRequest. Main fields: OrderLineIds: int[]. Required Header channel: current ChannelOAuthId. Output: Queues HGR/VelociPacker tracking generation for each supplied order line and returns refreshed order data on success or the processing result when generation cannot start. Search terms: sales generatetrackingid. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_generatetrackingid input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/GenerateTrackingId request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_generatetrackingid output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_generatetrackingid annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_sales_loadaddressesfromorderline — Post Sales Loadaddressesfromorderline

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/Sales/LoadAddressesFromOrderLine. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST load addresses from order line operation in sales/order operations. Use when: Use it when a client needs to run the load addresses from order line operation for sales/order operations. Input: [FromBody] rq: LoadAddressFromOrderLineRequest. Main fields: OrderLineId: int. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the load addresses from order line operation. Search terms: sales loadaddressesfromorderline. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_loadaddressesfromorderline input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/LoadAddressesFromOrderLine request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_loadaddressesfromorderline output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_loadaddressesfromorderline annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_sales_loadprogress — Post Sales Loadprogress

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/Sales/LoadProgress. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Reads the auto-ordering progress of one exact order line. ownerAgent: orders-autoordering. Domain: orders. Entity: order_line. Operation: get_progress. Scope: current_store. Use when: Use it to see the auto-ordering states of an existing order line, for example to explain why an automatic purchase failed. Input: [FromBody] rq: LoadProgressRequest. Main fields: Id: int. Header channel: current ChannelOAuthId. Output: Returns states (id, date, status, error, errorMessage), lastStatus, lastStatusUpdate and lastAccountAlias. errorMessage is null for most errors. It is returned for CandBeMarkedAsDisparched errors and for OutOfStock errors whose text starts with No eligible new offer. That text means auto-ordering refused the order because the supplier has no offer in new condition, so nothing was bought; the text after Refused conditions: lists the conditions it found. Search terms: sales loadprogress. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_loadprogress input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/LoadProgress request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_loadprogress output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_loadprogress annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_sales_manuallydispatchorderline — Post Sales Manuallydispatchorderline

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Sales/ManuallyDispatchOrderLine. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Records exact existing order lines as manually purchased in HGR. This is the HGRWeb Mark as Purchased action for normal manual-purchase states. ownerAgent: orders-autoordering. Domain: orders. Entity: order_line. Operation: mark_purchased. Scope: current_store. Use when: Use only after the user confirms that they already placed the real supplier order manually and wants to record that purchase in HGR before generating HGR/VelociPacker tracking. Input: [FromBody] rq: LoadAddressesFromOrderLineRequest. Main fields: OrderLineIds: int[]. Required Header channel: current ChannelOAuthId. Output: Changes eligible order lines to the manually purchased state and returns refreshed order data. Search terms: sales manuallydispatchorderline. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_manuallydispatchorderline input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/ManuallyDispatchOrderLine request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_manuallydispatchorderline output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_manuallydispatchorderline annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_sales_markasdispatched — Post Sales Markasdispatched

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Sales/MarkAsDispatched. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Acknowledges in HGR that an order-dispatch warning was handled manually for one exact order line. ownerAgent: orders-autoordering. Domain: orders. Entity: order_line. Operation: acknowledge_manual_dispatch. Scope: current_store. Use when: Use only when the user explicitly wants to clear the HGR warning after manually handling dispatch in the marketplace. Input: [FromBody] rq: AddAutoOrderReferenceRequest. Main field: OrderLineId: int. Required Header channel: current ChannelOAuthId. Output: Marks the dispatch warning as acknowledged in HGR and returns whether the order line was updated. Search terms: sales markasdispatched. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_markasdispatched input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/MarkAsDispatched request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_markasdispatched output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_markasdispatched annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_sales_processorderline — Post Sales Processorderline

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Sales/ProcessOrderLine. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Starts automatic supplier purchase processing for exact existing order lines using the current saved auto-ordering settings. ownerAgent: orders-autoordering. Use when: Use it when the user explicitly wants to process or retry an existing order after correcting a payment card or another auto-ordering setting. Input: [FromBody] rq: LoadAddressesFromOrderLineRequest. Main fields: OrderLineIds: int[]. Required Header channel: current ChannelOAuthId. Output: Attempts normal processing for each supplied order line and returns refreshed order data on success or the processing error result. Search terms: sales processorderline. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_processorderline input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/ProcessOrderLine request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_processorderline output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_processorderline annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_sales_stoporderline — Post Sales Stoporderline

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/Sales/StopOrderLine. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST stop order line operation in sales/order operations. Use when: Use it when a client needs to run the stop order line operation for sales/order operations. Input: [FromBody] rq: LoadAddressesFromOrderLineRequest. Main fields: OrderLineIds: int[]. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the stop order line operation. Search terms: sales stoporderline. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_sales_stoporderline input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/Sales/StopOrderLine request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_sales_stoporderline output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_sales_stoporderline annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_searchproduct_defaultsettingsmultiple — Post Searchproduct Defaultsettingsmultiple

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/DefaultSettingsMultiple. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST default settings multiple operation in existing published product/listing management. Use when: Use it when a client needs to run the default settings multiple operation for existing published product/listing management. Input: [FromBody] rq: RemoveMultipleListingRequest. Main fields: Ids: int[]. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the default settings multiple operation. Search terms: searchproduct defaultsettingsmultiple. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_defaultsettingsmultiple input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/DefaultSettingsMultiple request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_defaultsettingsmultiple output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_defaultsettingsmultiple annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_searchproduct_getlistingsimages — Post Searchproduct Getlistingsimages

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/getListingsImages. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Returns the first image of active listings for concrete publication ids. ownerAgent: listings. Domain: listings. Entity: exact_listing. Operation: get_exact. Scope: current_store. Use when: Use it only when concrete listingIds are already known and thumbnails are needed for those exact listings. Input: Header channel: current ChannelOAuthId and body int[] with concrete listingIds. Does not accept free search or store scans. Output: Returns a map from published product id to image URLs. Search terms: searchproduct getlistingsimages. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_getlistingsimages input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/getListingsImages request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_getlistingsimages output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_getlistingsimages annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_searchproduct_getpendinglistingsimages2 — Post Searchproduct Getpendinglistingsimages2

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/getPendingListingsImages2. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST get pending listings images2 operation in existing published product/listing management. Use when: Use it when a client needs to run the get pending listings images2 operation for existing published product/listing management. Input: [FromBody] listings: GetPendingListingsImages2Request[]. Main fields: Id: int, SourceId: int. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the get pending listings images2 operation. Search terms: getpendinglistingsimages 2, searchproduct getpendinglistingsimages 2. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_getpendinglistingsimages2 input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/getPendingListingsImages2 request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_getpendinglistingsimages2 output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_getpendinglistingsimages2 annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_searchproduct_listnow — Post Searchproduct Listnow

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/ListNow. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Retries a failed pending publication or submits a pending product now. Domain: listings. Entity: pending_listing. Operation: retry_or_publish. Scope: current_store. State: pending. RequiredInputs: confirmed. ownerAgent: publication. SupportingAgents: listings, support. AllowedIntents: retry_pending_publication, publish_pending_listing. ReadOnly: false. RequiresConfirmation: true. RequiresChannel: true. Use when: The user asks to retry or resubmit an existing pending product after fixing a marketplace error, or explicitly asks to publish a pending product now. Use this action instead of telling the user to click Retry in HGRWeb. SearchTerms: retry pending listing, retry publishing, publish pending listing now, resubmit pending product, retry failed publication, retry ebay publication. NegativeUseCases: Do not retry automatically merely because the user asks what the error means; Do not use for relisting an active or terminated product. Input: [FromBody] rq: Request.ListNowRequest. Id is the first variation ID, not its parent ListingId. Resolve the attached product or GetPending listingId through Listing/GetListings with ListingIds and Projection=Identifiers in the selected channel, then use variations[0].id, as HGRWeb Retry does. Header channel: current ChannelOAuthId. Output: BaseResponse.Success reports whether the retry or scheduling request was accepted, not whether marketplace publication has completed. Search terms: searchproduct listnow. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_listnow input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/ListNow request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_listnow output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_listnow annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_searchproduct_optimize — Post Searchproduct Optimize

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/Optimize. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST optimize operation in existing published product/listing management. Use when: Use it when a client needs to run the optimize operation for existing published product/listing management. Input: [FromBody] data: OptimizeRequest. Main fields: ListingId: int?, ProductSourceId: int?, CurrentTitle: string, OptimizeTitle: bool, OptimizeDescription: bool, OptimizeFields: bool. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the optimize operation. Search terms: searchproduct optimize. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_optimize input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/Optimize request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_optimize output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_optimize annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_searchproduct_pausetoreview — Post Searchproduct Pausetoreview

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/PauseToReview. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Moves a scheduled pending product to manual review so it is not published at its scheduled time. ReadOnly: false. RequiresConfirmation: true. RequiresChannel: true. Use when: The user asks to pause, hold or stop a scheduled pending product so it is reviewed before publication. SearchTerms: pause pending listing, move pending listing to review, hold scheduled publication, stop scheduled listing. NegativeUseCases: Do not use for active or terminated listings. Input: [FromBody] rq: Request.ListNowRequest. Id is the first variation ID, not its parent ListingId. Resolve the attached product or GetPending listingId through Listing/GetListings with ListingIds and Projection=Identifiers in the selected channel, then use variations[0].id, as HGRWeb Pause does. Header channel: current ChannelOAuthId. Output: BaseResponse.Success is true when the product moved to review. It is false when the variation belongs to another channel, the product is not scheduled for its first listing, or its scheduled time is less than 3 minutes away. Search terms: searchproduct pausetoreview. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_pausetoreview input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/PauseToReview request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_pausetoreview output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_pausetoreview annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_searchproduct_relist — Post Searchproduct Relist

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/Relist. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST relist operation in existing published product/listing management. Use when: Use it when a client needs to run the relist operation for existing published product/listing management. Input: [FromBody] rq: RelistRequest. Main fields: Id: int. Header channel: current ChannelOAuthId. Output: Returns the result or applies the effect of the relist operation. Search terms: searchproduct relist. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_relist input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/Relist request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_relist output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_relist annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_searchproduct_removelisting — Post Searchproduct Removelisting

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/RemoveListing. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Removes one listing from HGR. HGRWeb uses it to delete pending listings in review or error so they are never published. ReadOnly: false. RequiresConfirmation: true. RequiresChannel: true. Use when: The user explicitly asks to remove or delete a pending listing so it is never published. SearchTerms: remove pending listing, delete pending listing, remove listing from HGR. Input: [FromBody] rq: Request.ListNowRequest. Id is a variation ID of the listing to remove, not its parent ListingId. Resolve the attached product or GetPending listingId through Listing/GetListings with ListingIds and Projection=Identifiers in the selected channel, then use variations[0].id, as HGRWeb Remove does. The whole listing that owns that variation is removed. Header channel: current ChannelOAuthId, used to resolve the variation; the endpoint itself does not check it. Output: BaseResponse.Success is true when the listing was marked removed and false when no listing in the authenticated user's stores owns that variation ID. Search terms: searchproduct removelisting. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_removelisting input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/RemoveListing request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_removelisting output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_removelisting annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_searchproduct_savemultipleproductchanges — Post Searchproduct Savemultipleproductchanges

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/SaveMultipleProductChanges. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST save multiple product changes operation in existing published product/listing management. Use when: Use it when a client needs to run the save multiple product changes operation for existing published product/listing management. Input: [FromBody] changes: SaveMultipleProductChangesRequest. Main fields: ListingIds: int[], DataByListing: Dictionary<int, SaveMultipleProductChangesRequestD>, Markup: SaveProductChangeNumber, IncreaseMarkup: SaveProductChangeNumber, Price: SaveProductChangeDecimal, Quantity: SaveProductChangeNumber, Profit: SaveProductChangeNumber, MonitorPrice: SaveProductChangeBoolean, MonitorStock: SaveProductChangeBoolean, MonitorPriceDecrease: SaveProductChangeBoolean, PriceDecreasePercentage: SaveProductChangeNumber, IgnoreRules: SaveProductChangeBoolean, MinQuantity: SaveProductChangeNumber, PrimeOnly: SaveProductChangeBoolean, ShippingPolicy: SaveProductChangeLong, ReturnPolicy: SaveProductChangeLong, PaymentPolicy: SaveProductChangeLong, DispatchTimeDays: SaveProductChangeNumber. Header channel: current ChannelOAuthId. VAT is optional and only supported for eBay API: omit to leave unchanged, use {value: integer} from 0 to 100 to set, or {value: null} to remove the override and send zero to eBay. VAT applies to every variation of the affected eBay listing. Output: Returns the result or applies the effect of the save multiple product changes operation. Side effect: when a new channel stock quantity is applied to a listing variation, its previous channel stock quantity is recorded in the stock history (author: user), so it appears in the stock changes history. VAT settings are saved only for provider-accepted changes. Search terms: searchproduct savemultipleproductchanges. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_savemultipleproductchanges input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/SaveMultipleProductChanges request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_savemultipleproductchanges output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_savemultipleproductchanges annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_searchproduct_terminatelisting2 — Post Searchproduct Terminatelisting2

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST api/SearchProduct/TerminateListing2. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Provides the POST terminate listing2 operation in existing published product/listing management. Use when: Use it when a client needs to run the terminate listing2 operation for existing published product/listing management. Input: [FromBody] item: TerminateItemRequest. Main fields: Id: int. Header channel: current ChannelOAuthId. Output: Ends the listing in the store. Marks it terminated in HGR and returns success=true only when the store confirms the end or reports that the item was already ended. When the store refuses the end, returns success=false and the listing stays active in HGR. Search terms: terminatelisting 2, searchproduct terminatelisting 2. Send the exact request payload in body. Requires confirmed=true and impactConfirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_searchproduct_terminatelisting2 input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "impactConfirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST /api/SearchProduct/TerminateListing2 request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    },
    "impactConfirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly confirmed the concrete high-impact consequences."
    }
  },
  "additionalProperties": false
}

hgr_post_searchproduct_terminatelisting2 output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_searchproduct_terminatelisting2 annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

hgr_post_smartlister_filters_checknew — Post Smartlister Filters Checknew

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Dedicated HGRApi tool for POST ai publisher filters checknew. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Checks whether a proposed AI Publisher order returns enough current product candidates. ownerAgent: ai-publisher. Use when: Use to check candidate availability without saving an order or publishing products. Input: NewFiltersRequest. Filter.Criteria is the optional free-text product search prompt, not a literal title substring. Supplier, price, profit, Prime and tag filters apply. Header channel: current ChannelOAuthId. Output: Returns GOOD, INSUFFICIENT or BAD based on up to 50 search results. Search terms: ai publisher filters checknew. Send the exact request payload in body. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_smartlister_filters_checknew input schema

{
  "type": "object",
  "required": [
    "body",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST ai publisher filters checknew request body."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_smartlister_filters_checknew output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_smartlister_filters_checknew annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

hgr_post_smartlister_filters_new — Post Smartlister Filters New

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dedicated HGRApi tool for POST ai publisher filters new. This is an explicit tool with a fixed endpoint; it is not a generic endpoint caller. HGRApi functional documentation: Purpose: Creates a scheduled AI Publisher publication order for the selected store, including search conditions copied from the catalog. ownerAgent: ai-publisher. Use when: Use to create an order with product conditions, quantity, schedule and optimization preferences. Input: NewFiltersRequest.Filter: supplier Sources, OnlyPrime, optional Criteria (the free-text search prompt, up to 4000 characters; not a literal title substring), PriceMin/PriceMax, ProfitMin/ProfitMax and optional Tags (array of separate integer IDs, not bit flags). Tag IDs: 1 Valentine's Day, 2 Mother's Day, 3 Father's Day, 4 Back to school, 5 Halloween, 6 Black Friday, 7 Cyber Monday, 8 Christmas, 9 New Year's Eve, 10 Prime Day, 11 Trending, 12 Home and garden, 13 Electronics, 14 Toys and games, 15 Health and beauty, 16 Sports, 17 Pet supplies. Header channel: current ChannelOAuthId; the selected store determines ChannelOauthId. Output: Returns the identifier of the created order. Search terms: ai publisher filters new. Send the exact request payload in body. Requires confirmed=true before execution. Requires HGRApi Header channel / ChannelOAuthId resolved internally.

hgr_post_smartlister_filters_new input schema

{
  "type": "object",
  "required": [
    "body",
    "confirmed",
    "channelOAuthId"
  ],
  "properties": {
    "body": {
      "description": "HGRApi POST ai publisher filters new request body."
    },
    "confirmed": {
      "type": "boolean",
      "description": "Must be true after the user explicitly requested or confirmed the exact action."
    },
    "channelOAuthId": {
      "type": "integer",
      "description": "ChannelOAuthId returned by hgr_list_channels for the selected visible store."
    }
  },
  "additionalProperties": false
}

hgr_post_smartlister_filters_new output schema

{
  "type": "object",
  "additionalProperties": true
}

hgr_post_smartlister_filters_new annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}

Prompts

Not advertised

No prompt definitions available.

Resources

1 advertised

hgr_mcp_server_info — HGR MCP server information

Advertised by the server during the last successful anonymous check.

Version and config metadata for the HGR MCP server.

hgr_mcp_server_info URI

hgr://mcp/server-info

MIME type: application/json

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks: 1 of 1 (100%)
Average latency: 1961 ms
95th percentile latency: 1961 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

Nov 1, 2026, 8:09 AM UTC · probe · passed · 1961 ms · metadata changed · 170 tool(s), 1 resource(s), 0 resource template(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.

Claude Code configuration

claude mcp add --transport http hustle-got-real-mcp https://mcp.hustlegotreal.com/

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).

Codex configuration

codex mcp add hustle-got-real-mcp --url https://mcp.hustlegotreal.com/

Cursor

Merge this server into .cursor/mcp.json in your project, then enable hustle-got-real-mcp in your MCP settings.

Cursor configuration

{
  "mcpServers": {
    "hustle-got-real-mcp": {
      "url": "https://mcp.hustlegotreal.com/"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).

Cline configuration

{
  "mcpServers": {
    "hustle-got-real-mcp": {
      "type": "streamableHttp",
      "url": "https://mcp.hustlegotreal.com/",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start hustle-got-real-mcp and inspect its tools.

VS Code configuration

{
  "servers": {
    "hustle-got-real-mcp": {
      "type": "http",
      "url": "https://mcp.hustlegotreal.com/"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.

Gemini CLI configuration

gemini mcp add --transport http hustle-got-real-mcp https://mcp.hustlegotreal.com/

Claude Desktop

Merge this into claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\), then restart Claude Desktop.

Claude Desktop configuration

{
  "mcpServers": {
    "hustle-got-real-mcp": {
      "url": "https://mcp.hustlegotreal.com/"
    }
  }
}

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.

Windsurf configuration

{
  "mcpServers": {
    "hustle-got-real-mcp": {
      "serverUrl": "https://mcp.hustlegotreal.com/"
    }
  }
}

Let your agent find its tools

Find servers like Hustle Got Real MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows

See all 1,057

Do you run Hustle Got Real MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing

Hustle Got Real MCP

Endpoint and access

What you can do with it

Source and maintenance

Protocol and capabilities

Server-provided instructions

Tools

Prompts

Resources

30-day availability

Maintenance history

Connect from your client

Claude Code

Codex

Cursor

Cline

VS Code

Gemini CLI

Claude Desktop

Windsurf

Let your agent find its tools

Other commerce servers

Do you run Hustle Got Real MCP?