Skip to content

Partle MCP server

xyz.rubenayla.partle/marketplacepartle.rubenayla.xyzstreamable-httpv1.2.0Scanned

Search products in nearby stores. Agents can also list items for sale on a user's behalf.

30 tools: 5 can delete or cancel things, 14 change things and 11 only read.

Tools: 5 delete, 0 irreversible, 14 write, 11 read.
  • Reads private data · 2
  • Reads text others write · 9
  • Can send data out · 2
  • 9 findings

Tools listed without sign-in. Remote posture

With Anlyon

5 tools here can delete or cancel things. Govern them.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the Partle MCP server can do

The Partle MCP server is published by partle.rubenayla.xyz, a domain the MCP Registry verified. It has 30 tools. It can delete or cancel things (5 tools: delete_product, delete_product_image, delete_inventory_item, revoke_account_api_key and 1 more) and create or change data (14 tools: create_buy_request, submit_feedback, create_product, update_product and 10 more). 11 tools only read.

2 tools read private data (get_account_settings and list_account_api_keys); 9 tools bring in text other people can write (search_wanted, create_buy_request, create_product and 6 more); 2 tools can send data out of your system (create_product and update_product). On its own it has all three parts of a prompt-injection exfiltration path: private data, text others write, and a way out.

The fixed checks matched 9 findings (long-description, credentials-mention and annotation-conflict). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in.

Last scanned Nov 18, 2026, version 1.2.0.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

30 tools

Deletes or cancels 5Claude Code: deny
  • delete_inventory_itemPermanently delete an inventory row.No findings

    Why it is in this group

    • The name "delete_inventory_item" says "delete": a word for removing or ending something.
    • The description says "Permanently delete".
    • The server marks it destructive (destructiveHint: true).
    Description, as the server wrote it
    Permanently delete an inventory row. Authenticated. Required OAuth scope: `inventory:write`. Caller must own the item (404 otherwise). Hard delete — no soft-delete. Args: item_id: ID of the row to delete. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Returns: ``{"deleted": true, "id": item_id}`` on success, or ``{"error": ...}`` on auth / not-found.

    Annotations the server declares

    • title: Delete inventory item
    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: false
  • delete_productPermanently delete a product listing and all its images.Reads text others writeNo findings

    Why it is in this group

    • The name "delete_product" says "delete": a word for removing or ending something.
    • The description says "Permanently delete".
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Permanently delete a product listing and all its images. Destructive. Authenticated. OAuth (scope `products:write`) preferred; `api_key` fallback. Use only when the user explicitly asks to remove a listing they own. Cannot be undone — there is no soft-delete or trash bin. Idempotent: deleting a product that no longer exists returns an error, not duplicate side effects. Caller must own the product. Args: product_id: ID of the product to delete. Get from `get_my_products`. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: ``{"deleted": True, "product_id": int}`` on success, or ``{"error": ...}`` on auth/ownership failure.

    Annotations the server declares

    • title: Delete product
    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: true
  • delete_product_imageRemove a specific image from a product.Reads text others writeNo findings

    Why it is in this group

    • The name "delete_product_image" says "delete": a word for removing or ending something.
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Remove a specific image from a product. Destructive, idempotent. Authenticated. OAuth (scope `products:write`) preferred; `api_key` fallback. Use when an image was uploaded by mistake or the merchant updated their listing. The product itself is preserved — only the image record and its file are removed. To remove the product entirely use `delete_product`. Args: product_id: ID of the product the image belongs to. image_id: ID of the image to delete. Visible in the `images` array of `get_product` responses. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: ``{"deleted": True, "product_id": int, "image_id": int}`` on success, or ``{"error": ...}`` on auth/ownership failure.

    Annotations the server declares

    • title: Delete product image
    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: true
  • revoke_account_api_keyImmediately revoke one of your API keys.No findings

    Why it is in this group

    • The name "revoke_account_api_key" says "revoke": a word for removing or ending something.
    • The server marks it destructive (destructiveHint: true).
    Description, as the server wrote it
    Immediately revoke one of your API keys. Requires OAuth security:write. Consumers using the key will lose access. For rotation, first install and test the replacement returned by rotate_account_api_key.

    Annotations the server declares

    • title: Revoke account API key
    • readOnlyHint: false
    • destructiveHint: true
    • openWorldHint: false
  • revoke_connected_appRevoke an app's access AND refresh tokens for your account.No findings

    Why it is in this group

    • The name "revoke_connected_app" says "revoke": a word for removing or ending something.
    • The server marks it destructive (destructiveHint: true).
    Description, as the server wrote it
    Revoke an app's access AND refresh tokens for your account. Requires OAuth security:write. This disconnects the app immediately. Revoking your own calling app also works, but subsequent requests will fail until you reconnect with consent.

    Annotations the server declares

    • title: Disconnect account app
    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: false
Changes things 14Claude Code: ask
  • add_inventory_itemAdd an item to the caller's personal inventory.1 finding

    Why it is in this group

    • The name "add_inventory_item" says "add": a word for a change.

    Findings

    • Info

      The description is 2,624 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...oduct` if linked), or ``{"error": ...}`` on auth/validation failure."

      What this check looks for
    Description, as the server wrote it
    Add an item to the caller's personal inventory. Authenticated. Required OAuth scope: `inventory:write`. One creation tool covers all lifecycle states — set ``status`` based on the user's intent: "I bought" → ``owned``, "I want" → ``wanted``, "I'm selling" → ``for_sale``. Either ``product_id`` (linked to an existing Partle product) or ``name`` (freeform) must be set. **Not idempotent** — each call creates a new row. Args: name: Freeform name for items not yet linked to a Partle product. Either ``name`` or ``product_id`` must be set. product_id: Link to a canonical Partle product. status: Lifecycle. One of: ``owned``, ``wanted``, ``for_sale``, ``sold``, ``discarded``. Default ``owned``. quantity: How many. Fractional allowed. Default 1. notes: Freeform multi-line text — the dumping ground for anything not modeled as a column: extra URLs, comments, where stored, condition narrative, purpose, source, history, log entries. Markdown is fine. **Put extra URLs here, not in another field.** acquisition_price: What the user paid. acquisition_currency: Currency of acquisition_price. purchased_at: ISO date (YYYY-MM-DD) when it was acquired. asking_price: When status=for_sale, asking price. asking_currency: Currency of asking_price. condition: Free string — typical: ``new``, ``like_new``, ``good``, ``fair``, ``poor``. external_link: **Primary** click-through URL only (source listing, vendor page, manufacturer page). Exactly one. Additional URLs go in ``notes`` as markdown links. external_id: Stable identifier from the source system, used as a **dedup key**. Per-user unique when set — same external_id can't appear twice for one user. Format is up to you (e.g. ``aliexpress:1005004714348221``, ``amazon:order/3024.../line/1``, content hash). Leave null for handwritten items. project: Tag for grouping (e.g. "kitchen-renovation"). api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Returns: The newly-created inventory row (with embedded `product` if linked), or ``{"error": ...}`` on auth/validation failure.

    Annotations the server declares

    • title: Add inventory item
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • create_account_api_keyCreate a full-access catalog/inventory API key.1 finding

    Why it is in this group

    • The name "create_account_api_key" says "create": a word for a change.

    Findings

    • Info

      The description mentions "credentials".

      Matched text

      description: "...n. It cannot manage account settings or credentials through MCP. Each call creates a ne..."

      What this check looks for
    Description, as the server wrote it
    Create a full-access catalog/inventory API key. Requires OAuth security:write. The secret is returned ONCE. Store it securely; never include it in a public message or logs. This grants broader catalog/inventory access than a limited OAuth token. It cannot manage account settings or credentials through MCP. Each call creates a new key; do not retry blindly after a lost response.

    Annotations the server declares

    • title: Create account API key
    • readOnlyHint: false
    • destructiveHint: false
    • openWorldHint: false
  • create_buy_requestPost a public buy request — an ad asking suppliers to reach out.Reads text others writeNo findings

    Why it is in this group

    • The name "create_buy_request" says "create": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Post a public buy request — an ad asking suppliers to reach out. Use when the user wants others to know they're looking to buy something. **Independent of personal inventory** — inventory is the user's private workshop tracking; a buy request is a sales-facing ad on the public demand feed at /wanted. Authenticated. Required OAuth scope: ``inventory:write``. **Not idempotent** — each call creates a new public post. Args: name: Short scannable headline ("Looking for X"). Required. description: Plain text long-form — specs, constraints, delivery preference. The supplier reads this to decide whether they can fulfil. quantity: How many units the poster wants. Default 1. max_price: Optional ceiling per unit. currency: Currency for max_price (default €). contact: Free-form contact (email/phone/Telegram/etc.) shown publicly. Optional. Without it, suppliers can only respond via whatever channels you separately make available. reference_url: Link to a sample/datasheet/manufacturer page. product_id: Link to a canonical Partle product if asking for a specific known SKU. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Returns: The newly-created buy request, or ``{"error": ...}``.

    Annotations the server declares

    • title: Create buy request
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • create_productCreate a new product listing on Partle.Reads text others writeCan send data out2 findings

    Why it is in this group

    • The name "create_product" says "create": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.

    Findings

    • Info

      The description mentions "credential".

      Matched text

      description: "...ders needed, the URL itself carries the credential: requests.put(result["upload_url..."

      What this check looks for
    • Info

      The description is 4,152 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...ailure (dedup also returns ``{"existing": {"id", "name", "url"}}``)."

      What this check looks for
    Description, as the server wrote it
    Create a new product listing on Partle. Authenticated. Prefer **OAuth**: connect once via the consent flow on claude.ai (or any MCP client that supports OAuth) and the bearer token is attached automatically — no `api_key` parameter needed. **Fallback**: pass an `api_key` (prefix `pk_`, generate at /account) for programmatic or non-OAuth clients. Required OAuth scope: `products:write`. Use when the user wants to add an item for sale. For edits to an existing product, use `update_product` instead. **Images.** This tool creates text fields only — no image arg. Do **not** try to pass image bytes through a tool argument; phone-sized payloads blow past conversation context limits. The response includes a one-shot ``upload_url`` (signed, ~15 min TTL, bound to this product and your authenticated user). To attach an image from your code-execution sandbox, do **one** PUT request — no auth headers needed, the URL itself carries the credential: requests.put(result["upload_url"], data=open("/path/to/photo.jpg", "rb").read(), headers={"Content-Type": "image/jpeg"}) The bytes flow Python → HTTP body → Partle, never through the conversation. The URL works once and expires fast. Alternative if you don't have local bytes but have a public image URL: call ``upload_product_image(product_id, image_url=...)`` instead. **Duplicate prevention.** Same user, same product name (case- and whitespace-insensitive) returns 409 with `existing.id`, `existing.url`, **and a fresh `upload_url`** for that existing product — so if the user is just retrying with a photo, you can attach it directly to the existing listing without having to create or pick anything new. You can also call `update_product` to change fields. Don't retry blindly. **Idempotency.** Pass `idempotency_key` (any unique string per logical create — UUID or hash of the source listing) and a retry after a network failure returns the original response instead of creating a duplicate. Reusing a key with a different payload is a 422. Args: name: Product name. Required, 1–200 chars. description: Long-form product description. Optional. price: Price in whole currency units, **not** cents (e.g. ``15.99`` means €15.99). Max 100000. Omit for "ask the seller". currency: Currency symbol. Defaults to `€`. Use `$`, `£`, etc. url: Link to the merchant's product page. Optional but recommended. store_id: ID of the store this product belongs to. Omit for a personal listing not tied to any store. listing_type: ``in_stock`` (default) when the seller has the item and it can be bought now. ``tentative`` when they do not stock it and want to measure interest first — such a listing is kept out of normal search results and instead collects "I need this" presses. Only use ``tentative`` if the user explicitly said they are gauging demand; an item that is merely out of stock today is still ``in_stock``. If the user is looking to *buy* something nobody sells, use `create_buy_request` instead — that is the demand side and it is a different tool. idempotency_key: Optional retry-safety token. Unique per logical create. Send the same key on retries to get the same response. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: The created product record including its new `id` and canonical `partle_url`. Share `partle_url` with the user. Returns ``{"error": ...}`` on auth, dedup, or validation failure (dedup also returns ``{"existing": {"id", "name", "url"}}``).

    Annotations the server declares

    • title: Create product
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • get_upload_urlMint a one-shot signed upload URL for a product you own.Reads text others write2 findings

    Why it is in this group

    • The name "get_upload_url" says "get": a word for reading.
    • The server marks it as not read-only (readOnlyHint: false).

    What it can reach

    • untrusted-inputThe name "get_upload_url" says "get" and "url": it reads web pages, which anyone can write.
    • untrusted-inputThe description's first sentence says "url": it reads web pages, which anyone can write.

    Findings

    • Info

      The description mentions "credential".

      Matched text

      description: "...uth header on that PUT — the URL is the credential. If you have a public URL (not loc..."

      What this check looks for
    • Warn

      The server marks "get_upload_url" as not read-only (readOnlyHint: false), and its words say it reads.

      Matched text

      annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "get_upload_url" says "get": a word for reading.

      What this check looks for
    Description, as the server wrote it
    Mint a one-shot signed upload URL for a product you own. Authenticated. OAuth (scope `products:write`) preferred; `api_key` fallback. Use this when you have **local image bytes** (a file the user attached, bytes you generated/downloaded in your sandbox) and you want to attach them to a product that already exists. Common cases: - `create_product` returned 409 (duplicate name) — the listing already exists; this tool gives you an upload URL for it without creating anything new. - You're adding a 2nd, 3rd, … photo to a product. The returned URL is valid for ~15 min, single product, signed with your authenticated identity. From your sandbox, do **one PUT**: requests.put(result["upload_url"], data=open("/path/to/photo.jpg", "rb").read(), headers={"Content-Type": "image/jpeg"}) No auth header on that PUT — the URL is the credential. If you have a public URL (not local bytes), use `upload_product_image(product_id, image_url=...)` instead. Args: product_id: Product to attach the future image to. You must own it. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: ``{"upload_url": str, "upload_expires_in": int}``, or ``{"error": ...}`` on auth/ownership failure.

    Annotations the server declares

    • title: Get image upload URL
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • mark_for_saleMove an inventory item to status=for_sale and set listing fields.No findings

    Why it is in this group

    • The name "mark_for_sale" says "mark": a word for a change.
    Description, as the server wrote it
    Move an inventory item to status=for_sale and set listing fields. Convenience wrapper over `update_inventory_item` that matches a natural user request ("list my drill for sale at 30€"). Sets all three columns (`status`, `asking_price`, `asking_currency`, and optionally `condition`) atomically. Authenticated. Required OAuth scope: `inventory:write`. Caller must own the item. Args: item_id: ID of the inventory row. asking_price: How much you're asking for it. Whole units, not cents. Required. asking_currency: Currency. Default `€`. condition: Free string describing the item's condition (e.g. ``like_new``, ``good``). Optional. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Returns: The updated inventory row, or ``{"error": ...}``.

    Annotations the server declares

    • title: Mark inventory item for sale
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • mark_soldMark an inventory item as sold (status=sold).No findings

    Why it is in this group

    • The name "mark_sold" says "mark": a word for a change.
    Description, as the server wrote it
    Mark an inventory item as sold (status=sold). Convenience wrapper over `update_inventory_item` for the natural "I sold the drill" request. Authenticated. Required OAuth scope: `inventory:write`. Caller must own the item. Args: item_id: ID of the inventory row. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Returns: The updated inventory row, or ``{"error": ...}``.

    Annotations the server declares

    • title: Mark inventory item sold
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • rotate_account_api_keyCreate a replacement for your key, keeping the old key ACTIVE.No findings

    Why it is in this group

    • The description's first verb is "create": a word for a change.
    Description, as the server wrote it
    Create a replacement for your key, keeping the old key ACTIVE. Requires OAuth security:write. Returns the replacement secret ONCE with its new ID. Install it in the consumer, test it, then call revoke_account_api_key with previous_key_id. Do not revoke until the replacement is working. Each call creates a key; do not retry blindly after a lost response. Never publish the secret.

    Annotations the server declares

    • title: Prepare account API key rotation
    • readOnlyHint: false
    • destructiveHint: false
    • openWorldHint: false
  • set_account_usernameSet your username once, only if unset.No findings

    Why it is in this group

    • The name "set_account_username" says "set": a word for a change.
    Description, as the server wrote it
    Set your username once, only if unset. Requires OAuth account:write. Use 3–20 letters, digits, underscores or dashes. Existing usernames cannot be changed. Ask the user which public username they want before setting it.

    Annotations the server declares

    • title: Set account username
    • readOnlyHint: false
    • destructiveHint: false
    • openWorldHint: false
  • submit_feedbackReport a problem with **the Partle marketplace API/MCP itself**.1 finding

    Why it is in this group

    • The name "submit_feedback" says "submit": a word for a change.

    Findings

    • Info

      The description is 2,194 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...s, or ``{"error": ...}`` on auth, rate-limit, or validation failure."

      What this check looks for
    Description, as the server wrote it
    Report a problem with **the Partle marketplace API/MCP itself**. Authenticated. Prefer **OAuth**: connect once via the consent flow and the bearer token is attached automatically. **Fallback**: pass an `api_key` (prefix `pk_`, generate at /account). Required OAuth scope: `feedback:write`. Feedback is attributed to your account so reports are trustworthy and the channel can't be flooded anonymously. Scope — what this is for: - A Partle tool description is unclear or its parameters are surprising. - A Partle response is broken, malformed, or missing fields. - The Partle catalog is missing a category of products you'd expect. - Search relevance is off for a specific class of queries on Partle. Scope — what this is **NOT** for: - General complaints about tasks Partle isn't designed to do (Partle is a local-marketplace search/listing API — not a news API, an HTML hosting service, a portfolio-rebalancing app, a stock brokerage, or a generic dashboard SaaS). - Venting that an invented API key was rejected (Partle keys must be `pk_<hex>`; generate one at /account — don't fabricate them). - Asking the maintainers to do work the user requested but you can't do. If you can't fulfil a user request, tell the user — don't submit feedback about it here. Don't loop — each call adds a row and pages the maintainer. Resubmitting the same text within 24h is de-duplicated (returns the existing id). Args: feedback: Freeform text up to 5000 characters. Be specific — name the tool, the input that was confusing, and what you expected. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: ``{"id": int, "message": "Thanks for the feedback!"}`` on success, or ``{"error": ...}`` on auth, rate-limit, or validation failure.

    Annotations the server declares

    • title: Submit feedback
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • update_account_settingsSet your account theme to light, dark, or system.No findings

    Why it is in this group

    • The name "update_account_settings" says "update": a word for a change.
    Description, as the server wrote it
    Set your account theme to light, dark, or system. Requires OAuth account:write. The website applies it on login, reload or return to its tab. This only changes the theme; passwords, roles and sign-in providers cannot be changed.

    Annotations the server declares

    • title: Change account theme
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • update_inventory_itemPatch an existing inventory item.No findings

    Why it is in this group

    • The name "update_inventory_item" says "update": a word for a change.
    Description, as the server wrote it
    Patch an existing inventory item. Only provided fields change. Authenticated. Required OAuth scope: `inventory:write`. Caller must own the item (404 otherwise — we don't leak existence). Idempotent: calling twice with the same input yields the same final state. For lifecycle convenience, see `mark_for_sale` and `mark_sold` which set the right combination of fields atomically. Args: item_id: ID of the inventory row to update. Get from `get_my_inventory` or `add_inventory_item`'s return value. (every other param matches `add_inventory_item`; omit any field you don't want changed.) api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Returns: The updated inventory row, or ``{"error": ...}`` on auth / not-found / validation failure.

    Annotations the server declares

    • title: Update inventory item
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • update_productUpdate an existing product listing.Reads text others writeCan send data outNo findings

    Why it is in this group

    • The name "update_product" says "update": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
    Description, as the server wrote it
    Update an existing product listing. Only provided fields are changed. Authenticated. OAuth (scope `products:write`) preferred; `api_key` accepted as fallback. Only fields you pass are changed; omitted fields are preserved. Idempotent — calling twice with the same input yields the same final state. For creating a new listing, use `create_product` instead. Caller must own the product. Trying to update someone else's product returns an error. Args: product_id: ID of the product to update. Get from `create_product`'s return value, `get_my_products`, or `search_products`. name: New product name. Omit to leave unchanged. description: New description. Omit to leave unchanged. price: New price in whole currency units (e.g. 15.99 = €15.99). Max 100000. Omit to leave unchanged. currency: New currency symbol. Omit to leave unchanged. url: New merchant URL. Omit to leave unchanged. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: The updated product record (full, not just the changed fields), or ``{"error": ...}`` on auth/ownership/validation failure.

    Annotations the server declares

    • title: Update product
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • upload_product_imageAttach an image to an existing product by giving Partle a public URL to download the image from.Reads text others write1 finding

    Why it is in this group

    • The name "upload_product_image" says "upload": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Info

      The description is 2,047 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...and storage path, or ``{"error": ...}`` on validation/auth failure."

      What this check looks for
    Description, as the server wrote it
    Attach an image to an existing product by giving Partle a public URL to download the image from. Authenticated. OAuth (scope `products:write`) preferred; `api_key` fallback. **When to use this tool**: the image is already hosted at a public URL (a scraped product page, an Imgur link, a CDN URL the user provided). Partle's server fetches it and stores it. **When NOT to use this tool**: you have local image bytes (a file the user attached, or bytes you generated/downloaded in your sandbox). Sending those bytes through a tool argument blows past conversation context limits — phone-photo-sized payloads can be 6+ MB of base64. Instead, in your code-execution sandbox, POST the file directly to the HTTP endpoint with multipart encoding: requests.post( "https://partle.rubenayla.xyz/v1/external/products/{product_id}/images", files={"file": open("/path/to/photo.jpg", "rb")}, headers={"X-API-Key": "pk_..."}, ) Or, to create the listing and attach an image in one HTTP request: requests.post( "https://partle.rubenayla.xyz/v1/external/products", data={"metadata": json.dumps({"name": ..., "price": ...})}, files={"image": open("/path/to/photo.jpg", "rb")}, headers={"X-API-Key": "pk_..."}, ) Args: product_id: ID of the product to attach the image to. image_url: Publicly fetchable URL of the image. Server fetches it and stores it. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: The created `ProductImage` record with its `id` (use for deletion) and storage path, or ``{"error": ...}`` on validation/auth failure.

    Annotations the server declares

    • title: Upload product image
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
Only reads 11Show 11 read-only tools
  • get_account_settingsRead your account ID, email, username and theme.Reads private dataReads text others writeNo findings

    Why it is in this group

    • The name "get_account_settings" says "get": a word for reading.

    What it can reach

    • private-dataThe description's first sentence says "read" and "email": it reads mail.
    • untrusted-inputThe description's first sentence says "read" and "email": it reads inbound email, which other people can write.
    Description, as the server wrote it
    Read your account ID, email, username and theme. Requires OAuth account:read. Passwords and key secrets are never returned. No other account can be selected. A null theme means no account preference has been set; the browser keeps its local choice.

    Annotations the server declares

    • title: Read account settings
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • get_my_inventoryList the caller's personal inventory items.No findings

    Why it is in this group

    • The name "get_my_inventory" says "get": a word for reading.
    Description, as the server wrote it
    List the caller's personal inventory items. Authenticated. Required OAuth scope: `inventory:read` (or pass an `api_key` for legacy/programmatic clients). Use this when the user asks "what do I own?", "what's on my wishlist?", "what am I selling?", etc. The returned rows include every status by default; pass `status` to filter. Args: status: Filter by lifecycle. One of: ``owned``, ``wanted``, ``for_sale``, ``sold``, ``discarded``. Omit for all. product_id: Filter to rows linked to a specific Partle product. project: Exact-match filter on the project tag. q: Substring search on `name` and `notes` (case-insensitive). limit: Page size, 1–200. Default 50. offset: Pagination offset. Default 0. api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: ``{"items": [...], "count": int}`` where each item carries status, quantity, name (or linked product), notes, prices, etc. On auth failure: ``{"error": ...}``.

    Annotations the server declares

    • title: Get my inventory
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • get_my_productsList products created by the authenticated user.No findings

    Why it is in this group

    • The name "get_my_products" says "get": a word for reading.
    Description, as the server wrote it
    List products created by the authenticated user. Authenticated. OAuth (scope `products:read`) preferred; `api_key` fallback. Use when the user asks "what have I listed?" or before bulk operations like updating prices across multiple of their products. Distinct from `search_products`, which searches the public catalog without owner scoping. Read-only. Args: limit: Max results (1–200, default 50). api_key: Optional API key (`pk_*`, generate at /account). Used when there is no OAuth token, and also when the OAuth token lacks the required scope — an explicitly passed key overrides an ambient token that is scoped too narrowly. An invalid or revoked token still fails regardless. Omit when using OAuth. Returns: A list of products in the same shape as `search_products`. Returns ``[{"error": ...}]`` on auth failure.

    Annotations the server declares

    • title: List my products
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • get_productGet the full record for a single product by its numeric ID.No findings

    Why it is in this group

    • The name "get_product" says "get": a word for reading.
    Description, as the server wrote it
    Get the full record for a single product by its numeric ID. Use after `search_products` returns a candidate the user is interested in, when you need fields not in the search summary (full description, all images, sold status, expiration). Don't loop `get_product` over many search results — re-search with tighter filters instead. Read-only. No authentication. Args: product_id: Integer `id` from a `search_products` result, or visible in a Partle product page URL (`/p/<id>-<slug>`). Returns: A single product object with all fields, including the canonical `partle_url` to share with the user. Returns ``{"error": ...}`` if the ID does not exist.

    Annotations the server declares

    • title: Get product details
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • get_statsGet top-level Partle platform statistics.No findings

    Why it is in this group

    • The name "get_stats" says "get": a word for reading.
    Description, as the server wrote it
    Get top-level Partle platform statistics. Use for size questions ("how big is Partle?", "how many stores does Partle cover?"). Aggregate counts only — no per-product or per-store data; use `search_products` / `search_stores` for that. Read-only. No authentication. Cheap, but rarely changes — long-running agents should cache the result. Returns: ``{"total_products": int, "total_stores": int, "description": str}``.

    Annotations the server declares

    • title: Get platform stats
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • get_storeGet the full record for a single store by its numeric ID.No findings

    Why it is in this group

    • The name "get_store" says "get": a word for reading.
    Description, as the server wrote it
    Get the full record for a single store by its numeric ID. Use after `search_stores` to retrieve fields not in the search summary (full address, owner profile, contact details). For a list of *products* in that store, call `search_products(store_id=…)` instead — this tool returns store metadata only. Read-only. No authentication. Args: store_id: Integer `id` from a `search_stores` result. Returns: A single store object with all fields. Returns ``{"error": ...}`` if the ID does not exist.

    Annotations the server declares

    • title: Get store details
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • list_account_api_keysList your key IDs, labels, prefixes and dates, never secrets.Reads private dataNo findings

    Why it is in this group

    • The name "list_account_api_keys" says "list": a word for reading.

    What it can reach

    • private-dataThe description's first sentence says "list" and "secret": it reads secrets.
    Description, as the server wrote it
    List your key IDs, labels, prefixes and dates, never secrets. Requires OAuth security:read.

    Annotations the server declares

    • title: List account API keys
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • list_connected_appsList apps with active access to your account and their permissions.No findings

    Why it is in this group

    • The name "list_connected_apps" says "list": a word for reading.
    Description, as the server wrote it
    List apps with active access to your account and their permissions. Requires OAuth security:read.

    Annotations the server declares

    • title: List connected apps
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • search_productsSearch Partle's product catalog by name or description.1 finding

    Why it is in this group

    • The name "search_products" says "search": a word for reading.

    Findings

    • Info

      The description is 6,336 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...items. Don't infer "this is a great match" from a 0.75 score alone."

      What this check looks for
    Description, as the server wrote it
    Search Partle's product catalog by name or description. CRITICAL SEARCH INSTRUCTION: Reason from the job to the product class first, then search with a descriptive product phrase (e.g. including substrate, material, or size class). DO NOT blindly search using the user's raw conversational words. Transform questions like 'what do I need to attach a mirror to a brick wall?' into a product phrase like 'heavy duty masonry wall anchor'. Two distinct modes: - **Default (no flags)** — fast keyword search. ~100ms. Acts like a normal "dumb" search box: matches the literal words you typed against product names and descriptions, with stemming. Good for queries where the user knows the product's likely name ("BC547", "Arduino Uno", "Bosch drill"). Returns noisy/wrong results on cross-language or attribute queries ("compost bin" matches Spanish "composta", not real composters). - **`super_search=True`** — slow, high-quality. ~1–2s. Run when the user describes what they want rather than naming it: cross-language ("Schraubenzieher Set" → real screwdriver sets even without German catalog entries), attribute-style ("small metal part with a flat head"), or any case where the default returns junk. Embeds the query with voyage-3-large, takes the cosine top-50 over the corpus (with an exact-name precision boost for part numbers), then a cross-encoder reranks them. The two modes are mutually exclusive in practice — pick one based on whether the user knows the product's name or is describing it. Use this when the user asks to find a specific product or browse products matching a query. Prefer over `search_stores` when the intent is product-led ("find a drill") rather than store-led. Use `get_product` afterwards if the user wants full details for one specific result. Read-only. No authentication. Rate-limited to 100 requests/hour per IP. Args: query: Free-text search term. In default mode, treated as keywords (each word matched against product text). In `super_search=True`, treated as a natural-language description. min_price: Lower bound on price in EUR. Omit for no lower bound. Null-priced rows are NOT excluded by this filter — pass `has_price=True` if you need only priced listings. max_price: Upper bound on price in EUR. Omit for no upper bound. Tip — narrow by budget: `min_price=10, max_price=50, sort_by="price_asc", has_price=True`. Products without a listed price (a large fraction of the scraped catalog) sort last under either price ordering and are kept in results unless `has_price` filters them out. tags: Comma-separated tag filter (e.g. "electronics,bluetooth"). Tags are AND-ed together. store_id: Restrict results to a single store. Use the integer `id` from `search_stores` results. sort_by: One of `price_asc`, `price_desc`, `name_asc`, `newest`, `oldest`. Omit to use the default search-relevance ranking. has_price: When True, exclude products without a listed price (~most of the scraped catalog). Use this for competitive pricing or budget-bounded shopping. When False, return only null-priced listings (rarely useful). Omit to include both. semantic: Legacy flag. Pure vector ordering, ~250ms. Mostly superseded by `super_search=True` (which uses the same vector retrieval plus a cross-encoder rerank for materially better ordering at the cost of another ~700ms). Keep using it only if you specifically want vector retrieval *without* the rerank. super_search: **Enable for natural-language / "describe what I want" queries.** ~1–2s. Embeds the query with voyage-3-large, takes the cosine top-50 (with a precision boost for exact-name matches like part numbers / SKUs), then a cross-encoder reranks them. Use whenever the user is describing rather than naming — cross-language ("Schraubenzieher Set"), attribute-style ("small black metal bracket"), or any case where the default keyword path returns junk. Don't combine with cheap browse-style queries where the user typed an exact product name — keyword default is faster there. On `relevance_score` here: better than the bi-encoder cosine, but still not a "did I find what the user wanted" gauge. Behavior to expect: gibberish or fully-off-topic queries cap around 0.35; loosely-related catalogue clusters can score 0.7+ even when no item truly matches (a "ceramic vase" query in a catalog with no vases but many ceramic flowerpots will still score high). **Read the product names** before claiming a match. The score is most useful as a relative signal within one result set — a sharp drop between rank N and N+1 marks where the catalog stops being useful for this query. limit: Max results (1–100, default 20). Larger limits are slower and consume rate budget faster. offset: Skip this many results before returning. Use for pagination (offset += limit on each follow-up call). Returns: A list of products. Each includes `id`, `name`, `price`, `currency`, `url`, `description`, `store` (id/name/address), `tags`, `images`, a canonical `partle_url`, and `relevance_score` (cosine similarity 0–1 between the query and the product's embedding when a query was provided; `None` otherwise). **Always share `partle_url` with the user so they can view the listing.** Caveat on `relevance_score`: it is monotonic *within a single search… [336 more characters not shown]

    Annotations the server declares

    • title: Search products
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • search_storesSearch or list stores in the Partle marketplace.No findings

    Why it is in this group

    • The name "search_stores" says "search": a word for reading.
    Description, as the server wrote it
    Search or list stores in the Partle marketplace. Use for store-led questions ("what hardware shops are in Madrid?") rather than product-led ones (use `search_products` for that). Pass no query to browse the whole catalog. Read-only. No authentication. Rate-limited to 100 requests/hour per IP. Args: query: Free-text search over store name and address. Omit to list all stores in default order. limit: Max results (1–50, default 20). Returns: A list of stores with `id`, `name`, `address`, `lat`/`lon` (when geocoded), `homepage`, `type`, and `product_count` (active listings in the store — useful for competitive-landscape sizing without a separate `search_products` round-trip). Pass `id` to `search_products(store_id=…)` to filter the product catalog by that store.

    Annotations the server declares

    • title: Search stores
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • search_wantedBrowse public buy requests — what users are looking to buy but haven't found through normal supply.Reads text others writeNo findings

    Why it is in this group

    • The name "search_wanted" says "search": a word for reading.

    What it can reach

    • untrusted-inputThe description's first sentence says "browse": it reads web pages, which anyone can write.
    Description, as the server wrote it
    Browse public buy requests — what users are looking to buy but haven't found through normal supply. The demand side of Partle. Use this when an agent wants to **offer matches** (cross-reference open requests against `search_products` and surface hits) or just survey unmet demand. Every result is a public posting — users put these up specifically so suppliers can reach them. Buy requests are independent of personal inventory (which is private): these are sales-facing ads, not workshop tracking notes. Read-only. No authentication. Rate-limited 100 req/hour per IP. Args: query: Free-text filter over name + description (case-insensitive substring). Omit to list everything, newest first. limit: Max results (1–100, default 20). offset: Pagination offset. Returns: A list of open buy requests. Each includes ``id``, ``name`` (plus a deprecated ``title`` mirror of it), ``description`` (markdown — read the full text for specs and constraints), ``quantity``, ``max_price`` + ``currency`` (if the poster set a ceiling), ``contact`` (if they left an email/phone/handle), ``reference_url`` (sample or datasheet link if any), ``posted_by`` (display name), and ``created_at``. If the poster left a ``contact`` value, that's how a supplier should respond — Partle doesn't broker the conversation.

    Annotations the server declares

    • title: Search buy requests (public demand feed)
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

36 paths in this server alone from private data, through text someone else wrote, to a way out. Denying 2 outbound tools breaks every one.

Reads private data2
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write9
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out2
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
deny to break every path
{
  "permissions": {
    "deny": [
      "mcp__marketplace__create_product",
      "mcp__marketplace__update_product"
    ]
  }
}

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

Tools listed without sign-in

Looked at Nov 20, 2026, 19:21 UTC, unchanged since Oct 22, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
19
Protocol version
2025-06-18
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
https://partle.rubenayla.xyz/.well-known/oauth-protected-resource
Authorization servers
https://partle.rubenayla.xyz
Legacy HTTP+SSE transport
no
Dynamic client registration
yes
Client ID metadata documents
no
  • HighThe whole server

    The endpoint served tools/list without credentials, and the list has 19 tools that change things (5 destructive, 14 write). Whether a call also works without credentials was not tested: tools are never called.

    Matched text

    https://partle.rubenayla.xyz/mcp/: tools/list returned 30 tools to an anonymous client, including delete_product (destructive), delete_product_image (destructive), delete_inventory_item (destructive), revoke_account_api_key (destructive), revoke_connected_app (destructive) and 14 more

    What this check looks for

Findings

Matches of fixed checks, with the text they matched.

1 warn8 info
  • The server marks "get_upload_url" as not read-only (readOnlyHint: false), and its words say it reads.

    Matched text

    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "get_upload_url" says "get": a word for reading.

    What this check looks for
  • The description is 6,336 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...items. Don't infer "this is a great match" from a 0.75 score alone."

    What this check looks for
  • The description is 2,194 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...s, or ``{"error": ...}`` on auth, rate-limit, or validation failure."

    What this check looks for
  • The description mentions "credential".

    Matched text

    description: "...ders needed, the URL itself carries the credential: requests.put(result["upload_url..."

    What this check looks for
  • The description is 4,152 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...ailure (dedup also returns ``{"existing": {"id", "name", "url"}}``)."

    What this check looks for
  • The description mentions "credential".

    Matched text

    description: "...uth header on that PUT — the URL is the credential. If you have a public URL (not loc..."

    What this check looks for
Show 3 more findings

History

Changes to its tool definitions and to its remote endpoint, newest first.

No change seen yet. Its tools are rescanned every day, and a remote endpoint is looked at once a week.

Install

Pinned to version 1.2.0. Values in angle brackets are yours to fill in.

claude mcp add --transport http marketplace https://partle.rubenayla.xyz/mcp/
claude mcp add --transport http marketplace https://partle.rubenayla.xyz/mcp/

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__marketplace__search_products",
      "mcp__marketplace__get_product",
      "mcp__marketplace__search_stores",
      "mcp__marketplace__get_store",
      "mcp__marketplace__get_stats",
      "mcp__marketplace__search_wanted",
      "mcp__marketplace__get_my_products",
      "mcp__marketplace__get_my_inventory",
      "mcp__marketplace__get_account_settings",
      "mcp__marketplace__list_account_api_keys",
      "mcp__marketplace__list_connected_apps"
    ],
    "ask": [
      "mcp__marketplace__create_buy_request",
      "mcp__marketplace__submit_feedback",
      "mcp__marketplace__create_product",
      "mcp__marketplace__update_product",
      "mcp__marketplace__get_upload_url",
      "mcp__marketplace__upload_product_image",
      "mcp__marketplace__add_inventory_item",
      "mcp__marketplace__update_inventory_item",
      "mcp__marketplace__mark_for_sale",
      "mcp__marketplace__mark_sold",
      "mcp__marketplace__update_account_settings",
      "mcp__marketplace__set_account_username",
      "mcp__marketplace__create_account_api_key",
      "mcp__marketplace__rotate_account_api_key"
    ],
    "deny": [
      "mcp__marketplace__delete_product",
      "mcp__marketplace__delete_product_image",
      "mcp__marketplace__delete_inventory_item",
      "mcp__marketplace__revoke_account_api_key",
      "mcp__marketplace__revoke_connected_app"
    ]
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as marketplace. Review it before you use it.

Capability tags behind 10 rules
  • mcp__marketplace__search_wanted untrusted-input
  • mcp__marketplace__create_buy_request untrusted-input
  • mcp__marketplace__create_product untrusted-input, outbound
  • mcp__marketplace__update_product untrusted-input, outbound
  • mcp__marketplace__delete_product untrusted-input
  • mcp__marketplace__delete_product_image untrusted-input
  • mcp__marketplace__get_upload_url untrusted-input
  • mcp__marketplace__upload_product_image untrusted-input
  • mcp__marketplace__get_account_settings private-data, untrusted-input
  • mcp__marketplace__list_account_api_keys private-data

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/xyz.rubenayla.partle/marketplace/verify?hash=8640da3c1692f7fffbedc87df8c7db9a903f0482c4c6f4d74a5818ff52b3fe0e" | jq -e '.changed == false'

Pinned hash 8640da3c1692, from Nov 18, 2026, 11:18 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/xyz.rubenayla.partle/marketplace/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for xyz.rubenayla.partle/marketplace
[![Anlyon Radar](https://radar.anlyon.com/badge/xyz.rubenayla.partle/marketplace.svg)](https://radar.anlyon.com/servers/xyz.rubenayla.partle/marketplace)

Source: MCP Registry · repository. Synced Oct 21, 2026, 18:55 UTC.

Partle MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the Partle MCP server safe?

No scan can promise that. What its definitions show: 30 tools, 19 of which can change, send or delete something, and 9 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.

Can the Partle MCP server delete data?

Yes. 5 tools can delete, cancel or revoke something: delete_product, delete_product_image, delete_inventory_item, revoke_account_api_key and revoke_connected_app.

Can the Partle MCP server do things that cannot be undone?

No tool is classed as irreversible: none of them sends, pays, publishes or merges, going by their definitions.

What tools does the Partle MCP server have?

30 tools: 5 destructive, 14 write, 11 read. delete_product, delete_product_image, delete_inventory_item, revoke_account_api_key, revoke_connected_app, create_buy_request, submit_feedback, create_product and 22 more.

Does the Partle MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the Partle MCP server send data to outside services?

2 tools can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): create_product and update_product.

Has the Partle MCP server changed its tools?

Not since Anlyon Radar started tracking it. Last scanned Nov 18, 2026.