Skip to main content
Glama
781,388 tools. Updated 2026-11-14 07:38

"Automating HTTP API Wrapping into MCPT Tool" matching MCP tools:

  • Check a pending API key authorization using its request_id. Use request_id exactly as returned by request_api_key, never an email. Poll every 10 seconds. awaiting_user means the user must open the URL; pending means email verification is still required. ready returns the API key once only. Store it and include it in all subsequent HTTP calls. Stop on expired; ask the user before starting another authorization.
    ConnectorNo auth
  • 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.
    ConnectorNo auth
  • 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.
    ConnectorNo auth
  • Submit an uploaded PDF for faxing. Step 1 (before this tool): upload the PDF over plain HTTP multipart, using any HTTP client you have — shell, JavaScript fetch with FormData, Python, etc.: curl -F "file=@document.pdf" https://www.sendthisfax.com/api/upload fetch("https://www.sendthisfax.com/api/upload", {method: "POST", body: formDataWithFile}) The response contains fax_public_id and page_count. PDFs must be unencrypted, at most 50 MB and 1000 pages. Step 2: call this tool with the fax_public_id and the recipient fax number. Two modes: - With an API key (Authorization: Bearer stf_live_... on this MCP connection): the fax price is debited from the prepaid credit balance and sending starts immediately — no checkout, no browser. sender_email and billing_country are optional (they default to the key's records). Buy credits at https://www.sendthisfax.com/en/credits. - Without an API key: sender_email and billing_country are REQUIRED and the tool returns a checkout_url the USER must pay in a browser; the fax is sent automatically once paid. In both modes, poll get_fax_status until status reaches "delivered" or "failed" (failures after payment are auto-refunded). For integration testing, +19898989898 is the designated test recipient number.
    ConnectorNo auth
  • **Executes the task on live websites** and returns the result. Call `get_library` FIRST, then `run({ script })`. The same script can run from your app: POST `https://api.bowmark.ai/v1/run` with your API key; see `bowmark.ai/docs/http-api`. THE SCRIPT is a plain async JavaScript body, not a wrapping function. `bowmark` is a ready global: `await bowmark.<capability>.<fn>(...)`, or one site via `await bowmark.providers.<provider>.<fn>(...)`. `return` what you want back; `log(...)` for progress. Built-ins plus `URL`/`URLSearchParams` exist; `fetch`, `import`, `setTimeout` and a filesystem do not — `bowmark` is the only I/O. MIND THE CLOCK. Your client times out around 55 seconds; calls may take 30-55 seconds; default to ONE per script. Several? Use `Promise.allSettled` together (a dropped leg still returns `partial`), never one after another or inside a `for` loop. Keep under ~25,000 chars. CHECK `status` BEFORE `ok` — `ok` | `error` | `partial` | `needs_user` | `running`: • `running`: it is still going. Call `run({ runId })` to wait for the SAME run; never resend the script. • `partial`: `result` is real but narrower than asked, usually the site's doing; `incomplete` names what did not answer. Tell your user — never call it complete. `incomplete.failures[].fixable: true` means your argument was wrong: fix it and rerun. • `needs_user`: a site needs your user signed in; not a failure. Give them `meta.handoff.url`, name the sites, then call `wait_for_sign_in` with `meta.handoff.ref`. On `done`, send the SAME script unchanged. • `error`: there is no result; `error` says why. Saving files, one exit IP, saved secrets, `warnings`, `emptyHanded`, and the billed `browser_agent`/`delegate` fallbacks: `get_library({ query: "run guide" })`.
    Connector
    Destructive
    No auth
  • Turn an instance you are ALREADY running into a persistent volume. Use this when you launched something, set it up, and then decided you want to keep it. Nothing reboots and no data moves — the machine you have becomes the volume, and you can detach it afterwards to stop paying for compute while keeping the machine. Beats creating a volume and rebuilding. Only instances launched with an ssh_public_key qualify. One launched with your own user_data carries only your key, and a key cannot be added to a machine we cannot already log into — check "managed_ssh" on the instance. Requires: API key with write scope, and an active subscription. Args: instance_id: A running lsw.* instance you own name: Label for the volume (defaults to the instance name) Returns: Volume dict with state "attached", wrapping that same instance. No snapshot exists yet — the first one is taken on detach or snapshot. Errors: CONFLICT: Not running, already a volume, BorealHost Metal, or launched without BorealHost management access
    ConnectorNo auth

Matching MCP Servers

  • A
    license
    Not graded
    quality
    B
    maintenance
    This server enables aspiring Google Summer of Code contributors to discover and evaluate mentoring organizations and repositories, find available beginner issues, check claimability, get personalized recommendations, prepare proposals, and track progress using grounded GSoC and GitHub data. It also surfaces official program guidance, anti-spam rules, and GitHub API rate-limit status.
    354 PyPI
    1
    MIT

Matching MCP Connectors

  • Web page tools for AI agents: page metadata, outlinks, change detection, readable text and 10-URL batch metadata. Pay per call in USDC on Base via x402 ($0.02 to $0.15), no API key or signup.

  • Paid MCP server for EAN, UPC, and GTIN validation, normalization, correction, and batch analysis.

  • Convert a file you already hold — .docx, .xlsx or .csv — into a PDF, preserving its existing content. Pass the bytes base64-encoded together with the original filename, which is what the API uses to detect the input type. This is the inbound direction: it consumes an existing document, whereas render_docx / render_xlsx / render_pptx GENERATE new documents from structured data, and render_pdf builds one from a template. Returns a stored render { id, url, bytes, durationMs, name } whose id can be fed straight into merge_pdfs, split_pdf, edit_pdf, create_signature_request or create_envelope. Counts one render against the monthly quota. Files over 10 MB are refused by this tool because the bytes travel through the tool call. Requires a Kamy API key with the `render` scope; without a key, returns dashboard setup instructions.
    ConnectorNo auth
  • Convert a file you already hold — .docx, .xlsx or .csv — into a PDF, preserving its existing content. Pass the bytes base64-encoded together with the original filename, which is what the API uses to detect the input type. This is the inbound direction: it consumes an existing document, whereas render_docx / render_xlsx / render_pptx GENERATE new documents from structured data, and render_pdf builds one from a template. Returns a stored render { id, url, bytes, durationMs, name } whose id can be fed straight into merge_pdfs, split_pdf, edit_pdf, create_signature_request or create_envelope. Counts one render against the monthly quota. Files over 10 MB are refused by this tool because the bytes travel through the tool call. Requires a Kamy API key with the `render` scope; without a key, returns dashboard setup instructions.
    ConnectorNo auth
  • Discovery meta-tool. Lists ALL available Nordic Data API data endpoints (HTTP method, path, short description) by reading the backend's live OpenAPI spec at runtime — far beyond the curated high-level tools. Use this to discover capabilities the dedicated tools do not cover, then call get_endpoint_schema for parameter details and call_endpoint to execute one. Only read-only operations are listed (GET/HEAD plus the POST screening queries); admin and state-changing endpoints are never returned. Supports an optional `search` keyword filter. The catalog has 230+ endpoints.
    ConnectorNo auth
  • Get a FactReason API key for yourself, instantly, with no human, no signup and no card. Returns a key carrying one-off trial credit that you can spend immediately on any tool. CALL THIS FIRST if you have no key, or as soon as any FactReason tool returns HTTP 402 Payment Required — then retry the original call with the key, passed as that tool's apiKey argument (or as an Authorization: Bearer header if your client can set one). The tool is free and is never metered. Supplying an email is optional and only affects whether trial credit is granted; a key is always issued either way.
    ConnectorNo auth
  • Get a FactReason API key for yourself, instantly, with no human, no signup and no card. Returns a key carrying one-off trial credit that you can spend immediately on any tool. CALL THIS FIRST if you have no key, or as soon as any FactReason tool returns HTTP 402 Payment Required — then retry the original call with the key, passed as that tool's apiKey argument (or as an Authorization: Bearer header if your client can set one). The tool is free and is never metered. Supplying an email is optional and only affects whether trial credit is granted; a key is always issued either way.
    ConnectorNo auth
  • List all toolsets (tool groups) with slug, tool count and whether they are visible in this session. Core toolsets are always visible; enable others with enable_toolset. Full-access API keys see every tool; scoped keys and OAuth sessions automatically see every tool their scopes or role allow. Hidden tools stay callable — enabling only affects what tools/list advertises.
    ConnectorAPI key
  • $2.00 once. Use when your client cannot sign x402 on every call: a prepaid key lt_... holding $2.00 of credit, sent as the X-API-Key header on POST /mcp or any paid HTTP route; each call's price is deducted. A bearer secret; credit does not expire. Try first: buy_trial_key. No arguments.
    ConnectorNo auth
  • [PAID $0.01 USDC per call — optional third-party receipt] Bind an executed tool-call input/output pair into a verifiable cryptographic execution receipt through HumanMirror Execution Receipt (humanmirror.fr, x402-verified seller). Returns receipt_id, receipt_hash, input_hash, output_hash and the hm_trace_v1 proof token. Only hashes and receipt metadata are stored on their side; the payloads themselves are not. Use after an important or risky tool call to give third parties verifiable provenance that the call executed and what it produced. Invalid shapes are refused with HTTP 422 and no charge. This is an OPTIONAL external service; AgentWorld's own settlement receipts remain primary and free.
    ConnectorNo auth
  • Set or update the authentication on an HTTP-API integration, generically. Identify it by `integration_id` or `base_url`. Pass `auth` = {type: bearer|api_key|basic|query|custom_headers|browser_identity|none, ...}: bearer/basic → {token}; api_key → {token, header_name?} (key rides in a HEADER); query → {token, param_name} (key rides in the QUERY STRING, e.g. param_name='api_key' → `?api_key=…`); custom_headers → {headers:{name:value,...}}; browser_identity → {identity_id|identity_name, extract}; an extract block that echoes a percent-encoded cookie (Laravel's XSRF-TOKEN; a 419 means this) takes value_format:'urlencoded'. Token values are encrypted; nothing is stored in cleartext. To only refresh a browser_identity session, OMIT `auth` and pass `cookies` (and/or `local_storage`) — they are merged into the bound identity without touching its config. (oauth2 / service_account use the REST settings flow.)
    ConnectorAPI key
  • Set or update the authentication on an HTTP-API integration, generically. Identify it by `integration_id` or `base_url`. Pass `auth` = {type: bearer|api_key|basic|query|custom_headers|browser_identity|none, ...}: bearer/basic → {token}; api_key → {token, header_name?} (key rides in a HEADER); query → {token, param_name} (key rides in the QUERY STRING, e.g. param_name='api_key' → `?api_key=…`); custom_headers → {headers:{name:value,...}}; browser_identity → {identity_id|identity_name, extract}; an extract block that echoes a percent-encoded cookie (Laravel's XSRF-TOKEN; a 419 means this) takes value_format:'urlencoded'. Token values are encrypted; nothing is stored in cleartext. To only refresh a browser_identity session, OMIT `auth` and pass `cookies` (and/or `local_storage`) — they are merged into the bound identity without touching its config. (oauth2 / service_account use the REST settings flow.)
    ConnectorAPI key
  • Set or update the authentication on an HTTP-API integration, generically. Identify it by `integration_id` or `base_url`. Pass `auth` = {type: bearer|api_key|basic|query|custom_headers|browser_identity|none, ...}: bearer/basic → {token}; api_key → {token, header_name?} (key rides in a HEADER); query → {token, param_name} (key rides in the QUERY STRING, e.g. param_name='api_key' → `?api_key=…`); custom_headers → {headers:{name:value,...}}; browser_identity → {identity_id|identity_name, extract}; an extract block that echoes a percent-encoded cookie (Laravel's XSRF-TOKEN; a 419 means this) takes value_format:'urlencoded'. Token values are encrypted; nothing is stored in cleartext. To only refresh a browser_identity session, OMIT `auth` and pass `cookies` (and/or `local_storage`) — they are merged into the bound identity without touching its config. (oauth2 / service_account use the REST settings flow.)
    ConnectorAPI key
  • Mint a short-lived signed URL for uploading speaker-separation audio. Three steps: (1) call this tool with filename, mimeType, and optional size; (2) HTTP PUT the raw file bytes to signedUploadUrl with Content-Type set to the same mimeType before expiresInSeconds elapses; (3) call speaker_separation with the returned path as audioFileUrl. Do not POST the bytes to this tool. Returns signedUploadUrl, path, bucket, expiresInSeconds, maxBytes, and allowedMimeTypes.
    ConnectorOAuth
  • Mint a short-lived signed URL for uploading an invoice PDF or image. Three steps: (1) call this tool with filename, mimeType, and optional size; (2) HTTP PUT the raw file bytes to signedUploadUrl with Content-Type set to the same mimeType before expiresInSeconds elapses; (3) call invoice_processor with the returned path, bucket, and mimeType. Do not POST the bytes to this tool. Returns signedUploadUrl, path, bucket, expiresInSeconds, maxBytes, and allowedMimeTypes.
    ConnectorOAuth
  • [PAID $0.01 USDC per call — optional third-party receipt] Bind an executed tool-call input/output pair into a verifiable cryptographic execution receipt through HumanMirror Execution Receipt (humanmirror.fr, x402-verified seller). Returns receipt_id, receipt_hash, input_hash, output_hash and the hm_trace_v1 proof token. Only hashes and receipt metadata are stored on their side; the payloads themselves are not. Use after an important or risky tool call to give third parties verifiable provenance that the call executed and what it produced. Invalid shapes are refused with HTTP 422 and no charge. This is an OPTIONAL external service; AgentWorld's own settlement receipts remain primary and free.
    ConnectorNo auth
  • WHEN: You have one-shot work a foreign agent can finish. DO: Offer a race-safe work contract to foreign agents. POST /api/v1/tasks. No API key. Peers claim it; HTTP 409 means another agent already took it. DON'T: Claim your own offer. Keep title and description in English. NEXT: GET /api/v1/tasks and wait for complete_task from the assignee.
    ConnectorNo auth