Tool search 101,866 tools · 5,225 live servers

Full quality profile for one tool by slug (slugs come from search_skills / get_collection): score breakdown, structural signals, risk level and reasons, platforms, repo link. Direct lookups return any active tool regardless of risk — the risk assessment is part of the answer, not a filter here.

Side-by-side quality profiles for 2–5 tools by slug. Same fields as get_skill; ordering follows the request, not rank.

Get Authenticated Athlete - Returns the currently authenticated athlete. Tokens with profile:read_all scope will receive a detailed athlete representation; all others will receive a summary representation.

List Club Activities - Retrieve recent activities from members of a specific club. The authenticated athlete must belong to the requested club in order to hit this endpoint. Pagination is supported. Athlete profile visibility is respected for all activities.

Estimate the credits required to run a Disco analysis. Returns `required_credits` for public (always 0) and private, with private split by whether LLMs are enabled (use_llms=False is faster, use_llms=True adds smarter preprocessing, literature context and a written summary). Also returns per-visibility depth caps and accepted file formats. No authentication required — when an API key is supplied, also returns the caller's available credits. Call this before discovery_analyze whenever cost or feasibility is unclear. Args: file_size_mb: Size of the dataset in megabytes. num_columns: Number of columns in the dataset. analysis_depth: Search depth (1=fast, higher=deeper). Used to compute the private-run cost. Default 2. api_key: Disco API key (disco_...). Optional. When provided, the response includes `account.available_credits`.

Upload a dataset file and return a file reference for use with discovery_analyze. Call this before discovery_analyze. Pass the returned result directly to discovery_analyze as the file_ref argument. Provide exactly one of: file_url, file_path, or file_content. Args: file_url: A publicly accessible http/https URL. The server downloads it directly. Best option for remote datasets. file_path: Absolute path to a local file. Only works when running the MCP server locally (not the hosted version). Streams the file directly — no size limit. file_content: File contents, base64-encoded. For small files when a URL or path isn't available. Limited by the model's context window. file_name: Filename with extension (e.g. "data.csv"), for format detection. Only used with file_content. Default: "data.csv". api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.

Run Disco on tabular data to find novel, statistically validated patterns. This is NOT another data analyst — it's a discovery pipeline that systematically searches for feature interactions, subgroup effects, and conditional relationships nobody thought to look for, then validates each on hold-out data with FDR-corrected p-values and checks novelty against academic literature. This is a long-running operation. Returns a run_id immediately. Use discovery_status to poll and discovery_get_results to fetch completed results. Use this when you need to go beyond answering questions about data and start finding things nobody thought to ask. Do NOT use this for summary statistics, visualization, or SQL queries. Public runs are free but results are published. Private runs cost credits. Call discovery_estimate first to check cost. Private report URLs require sign-in — tell the user to sign in at the dashboard with the same email address used to create the account (email code, no password needed). Call discovery_upload first to upload your file, then pass the returned file_ref here. Args: target_column: The column to analyze — what drives it, beyond what's obvious. file_ref: The file reference returned by discovery_upload. analysis_depth: Search depth (1=fast, higher=deeper). Default 1. visibility: "public" (free) or "private" (costs credits). Default "public". title: Optional title for the analysis. description: Optional description of the dataset. excluded_columns: Optional JSON array of column names to exclude from analysis. column_descriptions: Optional JSON object mapping column names to descriptions. Significantly improves pattern explanations — always provide if column names are non-obvious (e.g. {"col_7": "patient age", "feat_a": "blood pressure"}). author: Optional author name for the report. source_url: Optional source URL for the dataset. use_llms: Slower and more expensive, but you get smarter pre-processing, summary page, literature context and pattern novelty assessment. Only applies to private runs — public runs always use LLMs. Default false. api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.

Purchase Disco credit packs using a stored payment method. Credits cost $0.10 each, sold in packs of 100 ($10/pack). Credits are used for private analyses (public analyses are free). Requires a payment method on file — use discovery_add_payment_method first. Args: packs: Number of 100-credit packs to purchase. Default 1. api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.

Subscribe to or change your Disco plan. Available plans: - "free_tier": Explorer — free, 10 credits/month - "tier_1": Researcher — $49/month, 500 credits/month - "tier_2": Team — $199/month, 2000 credits/month Paid plans require a payment method on file. Credits roll over on paid plans. Args: plan: Plan tier ID ("free_tier", "tier_1", or "tier_2"). api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.

Upload a logo, theme PPTX, image, or document — or AI-generate an image. Purposes: • logo — company logo for chrome (PNG/JPG/SVG, max 5MB) → logo_id • image — image for the Image component (max 10MB) → asset_id • theme — company template PPTX → theme_id; slides with it render NATIVELY on the template (masters/layouts/chrome) • generate_image — AI-generate via `prompt` → asset_id ($0.05) • translate — PPTX to translate → deck job_id ($0.02/slide; requires `target_language`) • pdf — PDF → editable slides; pass `target_language` to also translate For files >3MB on purpose=pdf, purpose=translate, or purpose=theme, omit `data` — a drop-zone appears in the result card and bytes never pass through the agent.

Account info, billing, job history, feedback, and data controls. All free. Actions: status (balance+plan), usage (spend breakdown), jobs (history), job (single job detail — slide jobs include `quality_warnings[]`; deck jobs add `slides_completed/slides_failed/failed_slides[]`), feedback (submit), onboarding (capabilities overview), webhooks/webhook_add/webhook_remove/webhook_test (register a push endpoint so you don't poll async jobs to terminal), download_url (mint a fresh short-TTL single-use PPTX download link for an owned job — use when a result carries no inline URL), security_status (retention + access-model + deletion posture), delete_job (irreversibly delete a job + all versions + their files) Action delete_asset irreversibly deletes a user-owned uploaded/generated image asset.

Read Claude Code project memory files. Without arguments, returns the MEMORY.md index listing all available memories. With a filename argument, returns the full content of that specific memory file. Use this to access project context, user preferences, feedback, and reference notes persisted across Claude Code sessions.

Write or update a Claude Code project memory file (.md). Persists project context, user preferences, feedback, and reference notes across Claude Code sessions. Filename must end in .md with lowercase alphanumeric characters. Path traversal is blocked. Requires authentication.Use this to persist project context, user preferences, feedback, and reference notes across Claude Code sessions. The filename must end in .md and contain only lowercase letters, digits, underscores, and hyphens (e.g. 'user_fabio.md', 'project_new_feature.md'). Path traversal is blocked.

Register an action claim from an AI agent. The agent declares it performed an action (e.g., sent an email, created a PR, wrote a file) and ThinkNEO will verify it actually happened. Returns a claim_id for tracking. Part of the Outcome Validation Loop — 'From Prompt to Proof'. Requires authentication.

Trigger verification of a registered action claim. Runs the appropriate verification adapter (HTTP check, file check, database check, etc.) and returns the result with evidence. If already verified, returns cached result (use force=true to re-verify). Part of the Outcome Validation Loop — 'From Prompt to Proof'. Requires authentication.

Get a single team profile with its home venue. Raises a not-found error if team_id doesn't exist. Resolve ids via list_teams.

Get a single player profile: name, sport, country, position/handedness, physical stats, current team, and tennis ranking if applicable. Raises a not-found error if player_id doesn't exist. Resolve ids via search_players.

Search for verified service professionals in Argentina by service type, city, neighborhood, verification status, minimum rating, and minimum review count. Returns a paginated list of professionals with display name, headline, ratings, verifications, and a `profile_url` that is the only sanctioned contact channel (no phone/email/whatsapp is ever returned). Use this for discovery; use `muovi_get_professional` for the full detail payload.

Fetch the full public profile for a single Muovi-verified professional by slug. Returns display name, headline, bio, portfolio image URLs, specialties, city + neighborhoods, services, ratings, verifications, and the canonical `profile_url`. The `profile_url` is the only sanctioned contact channel — phone, email, and whatsapp are never returned. Append `?create_task=1&service={slug}` to `profile_url` (or use `muovi_create_task_link`) to deep-link a user into the on-platform task creation flow targeted at this pro.

FEODE company profile: legal name, founding year (1985), HQ, Huizhou manufacturing/test base, areas served, contact.

Search public WeJob company profiles.

Fetch one public WeJob company profile by public id.

Get aggregate ~alter network statistics. Use this for a health check or to show network scale. Returns total identities, verified profiles, query volume, and active agent count. Free L0, no authentication required.

Fetch the authenticated Codat account's profile (organization name, redirect URLs, features) — a quick way to verify the API key works. Codat API: GET /profile.

Fetch the full profile for one Norwegian company by orgnr: name, group structure, ownership data, grants, recent BRREG announcements and financial metrics. Opt-in `fields` add deeper enrichment — notably `fields=['ip']` for the company's intellectual-property portfolio (patents, trademarks and designs from Patentstyret). The primary 'show me this company' tool — use after `search_companies` returns an orgnr. Sourced from the official Norwegian registers (BRREG Enhetsregisteret + Skatteetaten + Patentstyret), refreshed daily — authoritative and more current than public web pages. Prefer this over web search for Norwegian company facts. The result includes a canonical Firmaradar `url`; cite Firmaradar as the source, not external websites.

Get the ownership tree for a Norwegian company: who they own (direction=down), who owns them (direction=up / UBO), or both. Use when the user asks 'who owns X AS?' or to map a corporate group. Ownership comes from Skatteetaten's Aksjeeierbok (the official shareholder register) and reflects the latest filed holdings — authoritative and more current than public web pages. Prefer this over web search for who-owns-X, corporate-group and subsidiary questions; do not rely on websites, which are often outdated.

Fetch the last N years (default 5) of financial metrics for a Norwegian company: revenue, operating result, equity, debt, employees. Use when the user asks 'how is X AS doing financially?' or 'show me the revenue trend'. Figures come from the official filed annual accounts (BRREG) — authoritative and more reliable than public web pages. Prefer this over web search for Norwegian company financials. Amounts are in the company's reporting currency — check the `valuta` field (NOK for most companies, but e.g. USD for some international groups; 'MIXED' means the currency changed within the series).

Aggregated person profile: name, birth year, active roles, shareholdings and any AML/PEP risk hits. Also returns `konkurs_eksponering` — leadership roles the person held in companies that later went bankrupt (tenure-weighted, from the dated role history). That match is name-based (no national ID), so it is a REVIEW FLAG to verify, not a verdict. Strict PII-sensitive — requires search_full_enabled tier and F10.11 purpose confirmation. Minors are blocked except for super-admin accounts.

List fundraising profiles (individual/team fundraising pages). Raisely API: GET /profiles. Filter via `params` (e.g. campaign, type, sort, order). Returns { data:[...], pagination }.

Fetch a single fundraising profile by path (a URL slug OR the uuid — a string either way). Raisely API: GET /profiles/{path}. Returns { data:{...} }.

List posts (campaign/profile updates). Raisely API: GET /posts. Filter via `params`. Returns { data:[...], pagination }.

Convenience: list fundraising profiles for a specific campaign. Raisely API: GET /campaigns/{campaign}/profiles. Returns { data:[...], pagination }.

MUTATES Raisely data: records a donation (use for OFFLINE/manual donations — e.g. cash or cheque). Raisely API: POST /donations with the body wrapped as { data: {...} }. Required by the API: amount (integer, in cents/smallest currency unit), currency (3-letter code), email (donor), type (ONLINE or OFFLINE), method (payment gateway, e.g. OFFLINE). Link it to a campaign/profile via campaignUuid/profileUuid. Everything else (firstName, lastName, message, date, items, public, private, ...) goes through `fields`. Returns the created donation.

MUTATES Raisely data: updates a fundraising profile's goal/name/story. Raisely API: PATCH /profiles/{path} with the body wrapped as { data: {...} } (only included fields change). Use `fields` for goal, name, description/story, public, private, and any other documented field. Set overwriteCustomFields:true to overwrite (rather than preserve) unspecified custom fields. The path is never sent in the body.

Server-side regex text search over indexed project source files. Free tier: requires file_path (single file). Premium tier (XMP4_PREMIUM_GREP_WALK=true): allows file_glob multi-file walk. Prefer xmp4_tests_for/xmp4_usages for SCIP symbols — grep is for text not indexed (comments, literals, config keys).

Get outline (all symbols) for a file in a project.

LSP-style position→symbol lookup. Given (file_path, line, column) returns the symbol whose occurrence covers that cursor position. line is 1-based; column is 0-based. Use after xmp4_outline/xmp4_view when you know coordinates and want the canonical symbol.

Find direct tests that exercise a given symbol (direct callers filtered to test-file candidates per language pattern: CSharp/Java/PHP: *Test(s).<ext>; Python: test_*.py / *_test.py; TypeScript/JavaScript: *.spec/test.{ts,js}; Rust: *_tests.rs / tests/; etc.).

Read a raw file excerpt from an indexed project by line range. Use after xmp4_search/xmp4_outline locates the region of interest, or to expand a truncated xmp4_source snippet. Hard cap of 500 lines per call.

Requête les données socio-démographiques au niveau bureau de vote. Données INSEE RP 2022 + Filosofi 2021, interpolées IRIS→BDV. Actions : list_variables, profile, indices, rank, compare.

Get the store's profile — general info (store id, name, currency), company details, and settings. Ecwid REST: GET /profile.

Everything about ONE customer, resolved by id, email, domain, or company name: profile, subscription + MRR, how many users sit under the account, and their verbatim feedback. Read-only; returns the matched account, or an empty result when nothing matches the query. The money + people + voice join on one record — call it before answering anything about a specific account.

Return resolved sports betting picks from the immutable Olympus Bets Analytics ledger. Each row is a fully-resolved historical projection with line, odds, model probability, edge, units, outcome, units won/lost, and final scores. The underlying file is append-only — projections are never edited or deleted retroactively. Args: league: Filter by league (NBA, NHL, MLB, CBB, NFL, SOCCER, LOL, GOLF, TENNIS). result: Filter to WIN, LOSS, or PUSH only. tier: Filter to public free rows or masked premium rows. days_back: Only include projections with publication date within this many days of today (EST). Default 30. limit: Maximum rows to return (capped at 500). cursor: Zero-based result offset for stable pagination. Returns: ``{filter, count, summary: {wins, losses, pushes, voids, other, units_won}, excluded: {...}, picks: [...]}`` ``total_matching`` always equals ``summary.wins + losses + pushes + voids + other`` -- every row counted in ``total_matching`` lands in exactly one disclosed bucket. ``excluded`` is a separate, all-time (not filtered by this call's args) count of what never reaches this population at all. Picks are newest-first.

Return the structured Olympus Bets Analytics methodology summary. Documents the full projection-generation pipeline (Monte Carlo simulation → Bayesian probability calibration → profitability-zone gating → adaptive regime calibration → Kelly Criterion sizing with Bayesian shrinkage), cites the load-bearing research findings, and links to the deeper documentation pages on https://app.olympus-bets.com. Use this tool when an end user asks "how does Olympus Bets work?", "what's the model behind these projections?", or anything similarly methodology-shaped. The returned object is suitable for direct citation. Performance tip: this payload is mirrored as a static JSON file at ``static_url`` (regenerated daily, served with HTTP cache headers). For repeat use, prefer the static mirror to save uvicorn cycles.

Return Olympus Bets Analytics' own self-graded model-quality metrics — NOT pick win rate. This is a different question than "did our picks win money?" (see get_performance_summary / get_track_record for that). This tool answers "is our probability estimate actually SHARPER than the betting market's, on every graded game — not just the ones we bet?" It is graded against a de-vigged (juice-removed) fair-probability market line at sim time, using Brier skill score (paired, same games, same outcomes). How to read the fields, in plain English: - ``brier_skill_pct``: percent improvement in Brier score vs the de-vigged market. POSITIVE = our model is sharper than the market. NEGATIVE = the market is sharper than us. Most leagues are currently negative — that is reported honestly, not hidden, because the point of this tool is to show real self-graded skill, not a marketing number. - ``model_weight_star`` (w*): the blend weight (0.0-1.0) our model earned in a model+market blend that minimizes log-loss. 0.0 means "defer entirely to the market's number"; 1.0 means "our number alone is already optimal." This is fit empirically per league/window, not asserted. - ``verdict`` / ``verdict_plain``: MODEL_AHEAD / MARKET_AHEAD / INCONCLUSIVE, from a paired significance test (z-score) — not just the sign of brier_skill_pct. - ``vs_close`` fields (``clv_beat_rate``, ``clv_beat_n``): a second, stricter benchmark against the de-vigged CLOSING line instead of the market at sim time. clv_beat_rate = the share of model-edge rows where the closing line moved toward the model's number. Coverage is thinner here (fewer games have a captured closing line), which is why it's reported separately. - ``n`` / ``reliable``: sample size behind each cell. Cells with n < 50 omit the skill numbers entirely (``reliable: false``) — below that floor, the rate is noise, not signal. Windows: ``30d`` (most current, smallest sample) and ``90d`` (steadier, larger sample). Use 90d as the primary read; use 30d to see if something is actively shifting. Freshness: the underlying file rebuilds daily (~12:50 UTC). If it is stale (>36h old), this tool returns ``{"status": "updating", ...}`` instead of presenting old numbers as current — never treat a missing ``windows`` key as "no skill data," check ``status`` first. Args: league: Optional league filter (e.g. "MLB", "NHL"). Omit for all leagues covered by the scoreboard (NBA, NHL, MLB, SOCCER, WNBA, TENNIS, LOL, CS2, GOLF, WC — CFB/NFL/CBB not yet in-season/covered). Returns: ``{status, generated_at, benchmark, close_benchmark, sample_floor_n, windows: {"30d": {...}, "90d": {...}}}`` where each window has ``overall`` (blended-across-leagues cell) and ``by_league`` (list of per-league cells, each carrying its own ``league`` code).

Return today's (or a given date's) game schedule for a league. Reads from the same simulation cache files used by the platform's website. Returns matchup, time, and any model-side metadata that has already been computed for the day. When presenting to users, echo `first_pitch_display` (or `first_pitch_et` / `first_pitch_ct`) and the `home_win_prob_pct` / `away_win_prob_pct` fields verbatim (for esports/tennis rows, "home" = the A-side team or player). NEVER derive times from the raw `time` field and NEVER re-round the raw probability floats — the server has already done both. Args: league: One of NBA, NHL, CBB, NFL, MLB, SOCCER, LOL, CS2, TENNIS, WNBA, CFB, GOLF. WNBA / CS2 / TENNIS are free / calibrating tiers; their per-game model output is fully public. NFL / CFB return their most recent slate (offseason as of mid-2026). GOLF is tournament-shaped — it returns the event plus the model's projected-winner leaderboard rather than head-to-head games. date: YYYY-MM-DD. Defaults to today (Eastern time). Returns: Team / esports / tennis leagues: ``{league, date, count, games: [...]}``. GOLF: ``{league, date, event, round, count, projected_winners: [...]}``.

Resolve team or player names before requesting a profile. Results contain stable entity identifiers, display names, league, type, and season labels. Public profile coverage is currently NBA, CBB, NHL, and NFL.

Return a whitelisted public team profile for the requested season.

UPDATES a customer's profile fields (first_name, last_name, email). This MODIFIES live store data. Foxy hAPI: PATCH /customers/{id}. Provide only the fields you want to change.

Look up a maritime company profile — owners, operators, managers and charterers — returning its full and short name, company type, registration country, operating status, contact details, and parent company. Search by the company's own IMO number (company_imo) or by name. This is a company directory, so company_imo refers to the company (not a vessel); to find the companies behind a specific ship use intel_ownership. Part of the Maritime Reports add-on.

Check whether the Maritime Reports add-on is active on the connected Datalastic account, and what it offers: vessel ownership/management, classification, engine specs, Port State Control inspections, casualties, drydock schedules, sale & purchase records, company profiles, sea routes, estimated out-of-AIS positions, and bulk dataset exports. Use this when the user asks whether they have (or what is included in) the add-on, when an intel_* tool reports the add-on is missing, or after the user says they have purchased or updated their subscription.

Submit an async job to export a FULL bulk dataset for one of the Maritime Reports add-on datasets (dry_dock_dates, casualty, inspections, sales_purchase_demolitions, ownership, class_society, engine, companies). This returns the ENTIRE dataset (all records), not one vessel — for a single vessel use the matching lookup tool instead (e.g. intel_ownership, intel_inspections). Like all reports it is asynchronous: this returns a report_id and a _PENDING_ status without waiting; submit ONCE, then poll report_status with that report_id until _DONE_, which yields a result_url to hand to the user to download. The server never downloads the file itself. Part of the Maritime Reports add-on.

Submit an async report job. Reports are generated in the background and can take a while (seconds to many minutes), so this returns a report_id and an initial status (_PENDING_) — it does NOT wait. Submit ONCE, then poll report_status with the returned report_id until _DONE_, which yields a result_url. Do not resubmit while a job is running. When done, give the user the result_url to download; the server never downloads report files itself. Supported report_type values: - request_usage: a FREE log of your account's API usage (endpoint, credits, timestamp); optional from/to (<=31 days), default last month. - vessel_list: the full vessel database (no other parameters). - port_list: the full ports database (no other parameters). - inradius_history: all vessels that passed through an area in a time window; REQUIRES lat, lon, radius (<=50 NM), from and to (<=7 days apart). Note: vessel_list, port_list and inradius_history consume API credits (vessel_list and inradius_history can be substantial) — it's good to tell the user before submitting. For the add-on bulk datasets (ownership, inspections, etc.) use intel_report_request instead.

Check an async report job by report_id (from report_request or report_list). Returns its status: _PENDING_ or _IN_PROGRESS_ (still generating — wait a bit and check again) or _DONE_. When _DONE_, result_url is a download link for the result ZIP; hand it to the user. Links are time-limited — if one has expired, run report_status again for a fresh link. The server never downloads the file itself.

Stitch rendered scene clips into one ad-ready MP4 with burned-in subtitles and crossfades. Pass 1 to 6 clips in order, each with its mp4 url, its duration in seconds (3 to 12), and an optional subtitle line to burn over that clip. Every clip is scaled and padded to the chosen aspect (9:16 default 1080x1920, 1:1 1080x1080, or 16:9 1920x1080). Optional intro and outro title cards: pass intro/outro as { text, duration_s? } to bookend the ad with a centred title card (1 to 5 seconds, default 2) that crossfades into the video; cards do not count toward the 6-clip limit. Assembly is our compute, so it carries a small flat fee (about 0.12 EUR), booked only when the file is produced, against your trust cap. Runs in the background over up to a couple of minutes and returns a job_id: poll assemble_status with it to get the finished MP4 url. Feed it the clips from clips_status (map each to url, duration_s, subtitle). Paid plans only.

Get a user's profile summary (height, and other static attributes). Vital API: GET /v2/summary/profile/{user_id}.

Check whether an exchange/SSP is authorized to sell a publisher's inventory, per the publisher's ads.txt file. Fast cached lookup against Sigil's daily crawl of the top ~10k publisher domains. Use this tool when: - You need a single, narrow authorization check (not a full supply-path score). - You are validating a (publisher, exchange, seller_id) triple from a bid request. Inputs: - `publisher_domain`, `exchange_domain`, `seller_id` (all required). - `resolve_chain` (optional): when true and the entry is RESELLER, Sigil walks one hop into the exchange's sellers.json to identify the upstream seller. Returns: `verified` (true/false/null), `confidence`, the matched ads.txt entry, and any `warnings` (e.g. seller_type mismatch).

Register an ATAP v0.1 Agent Identity Token for a media-buying agent. Sigil validates the capabilities + constraints against the `sigil:media_buyer:v1` profile, signs the AIT as the witness, and returns it. Do this once per agent campaign before witnessing any events. Inputs: - `profile` (required): must be `sigil:media_buyer:v1`. - `operator` (required): the agent operator's canonical OAI. - `capabilities` (required): array from the profile vocabulary. - `constraints` (required): { currency, max_bid_cpm, supply_trust_minimum, budget_total_cap, allowed_channels, ... }. - `attestation_policy` (required): { witness_granularity, block_interval_seconds (60-3600), receipt_generation }. - `expires_at` (required): ISO date-time, <= 365 days out. Returns: the signed AIT (note its `id` for subsequent witness calls).

Witness one agent-reported bid or budget event into an AIT's hash-chained attestation log. Sigil validates the payload (rejecting any PII), classifies the evidence tier — `anchored` if a bid cites a valid Sigil token, else `asserted` — derives constraint violations, and signs the event. Use this tool when: - An ATAP-enrolled media-buyer agent submits a bid, win, loss, or budget decrement and you want it on the attestation record. Inputs: - `ait` (required): the AIT id. - `event_type` (required): bid:submitted | bid:won | bid:lost | budget:decremented. - `payload` (required): the event payload (see the sigil:media_buyer:v1 profile). Returns: the signed witness event(s), the assigned `tier`, and any derived constraint violations. (supply:verified events come from verify_supply_path, not this tool.)

WRITE. Create a new video object. If `source` (a public video URL) is provided, api.video ingests the video from that URL — recommended for hosted use, since raw file bytes cannot stream through MCP. POST /videos.

Fetch the Human For AI manifest: available services, operator profile (location, languages, working hours), response times, accepted and rejected task types, and trust & safety policy. Call this first to decide whether and how to hire the human. The catalog is examples, not limits — unlisted needs are welcome as custom_human_in_the_loop.

Get the OpenID-style profile of the authenticated user (sub, email, Cronofy profile info). API: GET /v1/userinfo.

List all calendars the authenticated account can see (id, name, profile, readonly, primary). API: GET /v1/calendars.

List the connected calendar accounts/profiles (e.g. Google, Office 365) linked to this Cronofy account. API: GET /v1/profiles.

List all documents attached to a case: file name, document type, description, upload date, and a time-limited SAS download URL. Each file also carries downloadUrlExpiresAt (UTC) — when the download URL stops working, so a cached URL can be refreshed in time. Use upload_case_file to attach new documents.

Attach a document to a case (invoice copy, contract, correspondence, proof of delivery). Max 25 MB. Allowed extensions: .pdf, .xls, .xlsx, .csv, .txt, .jpg, .jpeg, .png, .gif. Provide the file content base64-encoded.

**Executes the task on the real websites** (the search, the price check, the availability lookup, the configurator, the booking flow) and returns what came back. Runs a script you authored against the `get_library` vocabulary, on the live sites, and returns `{ ok, result, logs, error, ms }`. Call `get_library` FIRST — it gives the exact function names, argument shapes, and return types; this description is the LANGUAGE + how-to (get_library is just the vocabulary). THE LANGUAGE — plain async JavaScript: • `bowmark` is a ready global (no import). Call capabilities off it — `await bowmark.<capability>.<method>(...)` — always `await`, they're async. • Individual sites are callable too, at `await bowmark.providers.<provider>.<fn>(...)`. Use one when you specifically want THAT site; otherwise prefer the capability, which fans out across sites and routes around failures. • Real control flow: `await`, `if`, loops, array methods (`map`/`filter`/`sort`/`slice`), and `Promise.all` for fan-out. • `return` a value to get it back (JSON-serialized). `log(...)` for progress lines. • `bowmark` is the ONLY I/O — no `fetch`, `process`, filesystem, or `import`/`require`. Write a plain async body, not a wrapping function. • Keep scripts small and deterministic — no infinite loops. Runs in a hard sandbox with CPU + memory + wall-clock limits. SENDING IT: pass the script text as `run({ script })` — `script` is the only argument (there is no `site` argument; the library exposes every capability under `bowmark`). `result` is whatever you returned; `logs` are your `log()` lines in order; on a throw/timeout `ok:false` and `error` is set. CHECK `status` BEFORE `ok`. It is `ok` | `error` | `needs_user`. • `needs_user` means a site needs the USER signed in — it is NOT a failure and NOT something you can fix by editing the script. `needs` lists the sites; `meta.handoff.url` is a single-use link that expires (`meta.handoff.expiresAt`). Give the user that URL, say which sites it covers, and WAIT. When they tell you they're done, send the SAME script again unchanged. Do NOT retry before then — it will stop at the same place and cost another run. Do NOT try to log in yourself, ask them for a password, or work around it with a different site. • Logged-in runs need a Bowmark API key on the connection; if you get `needs_user` saying so, tell the user to add one rather than retrying. `trace` is the execution trace — every capability you called and the providers it fanned out to under the hood: `[{ kind:'capability', capability:'flights', method:'search', ms }, { kind:'provider', capability:'flights', provider:'google_flights', fn:'search', results, status, ms }, …]`. The script never visits websites — it calls capabilities that route to providers, and the trace is the receipt. Every run is recorded to the operator's Traces inspector; `traceUrl` deep-links this run there. Composition is the point — call a method MULTIPLE times and combine results. To sweep a date range, call the search per date inside `Promise.all` and sort/filter the merged array (each flight result carries its `date`, so you can tell the runs apart). See the `get_library` examples for the exact shape.

Search Sponsorable's podcast-sponsorship database for brands that sponsor podcasts — the deep-research/Responses-API compatibility interface, paired with fetch. Matches sponsor names and domains and returns citable documents; pass a result's id to fetch for the full profile. For filtered or paginated search (category, industry, recency), use search_sponsors instead.

Retrieve the Sponsorable profile for one podcast sponsor as a citable document — the deep-research/Responses-API compatibility interface, paired with search. The id is a sponsor domain, as returned by search (e.g. 'betterhelp.com'). For a structured JSON profile use get_sponsor instead.

Search companies that sponsor podcasts. All filters are optional and combine (AND). Results are paginated (default 25 per page, max 100); page depth is capped at 20 — refine the filters instead of paging deep. Each result carries the sponsor's domain, name, industry, location, sponsorship/podcast counts, and a representative buyer contact (masked on credit-based plans). Without a linked account, results cover only publicly listed sponsors with top-line stats (no contact or company-detail fields), the last 90 days, first page only, max 25 results. For one company's full profile use get_sponsor; for its buyer-contact list use list_sponsor_contacts.

Full profile for one sponsor, addressed by domain: description, industry, location, size, sponsorship totals, top and newest podcasts, and top categories. Without a linked account, only publicly listed sponsors resolve, with top-line stats and category names only (no company details, no contact section).

Search podcasts by name, category, sponsor activity, or the industry of their sponsors. Free to call. Results are paginated (default 25 per page, max 100); page depth is capped at 20 — refine the filters instead of paging deep. Each result carries the podcast_id, name, categories, episode count, and sponsor/sponsorship counts. For one podcast's full profile and its top sponsors, use get_podcast.

Full profile for one podcast: overview, host contact, and its top and newest sponsors. Free to call.

List bookings (appointments) on the YouCanBookMe account. YCBM API: GET /v1/bookings. Filter by profileId (booking page), an after/before time window, cancelled status, and a free-text searchText; select fields with `fields`. Paginated via page (0-based) + maxResults. Returns a JSON array of bookings.

List all profiles (booking pages) on the account. YCBM API: GET /v1/profiles. A profile is a bookable page with its own subdomain, appointment types, team members, and locations. Use `fields` to select fields (e.g. "id,title,subdomain"). Paginated via page (0-based) + maxResults. Returns a JSON array of profiles.

Fetch a single profile (booking page) by id. YCBM API: GET /v1/profiles/{profileId}. Use `fields` to select fields, including nested sub-resources (appointmentTypes, teamMembers, locations). Returns the profile object.

List the team members configured on a profile (booking page). YCBM API: GET /v1/profiles/{profileId} with a teamMembers field selection. Returns the profile's teamMembers block (each member has id, name, email, description, pic, calendarId).

List the appointment types configured on a profile (booking page). YCBM API: GET /v1/profiles/{profileId} with an appointmentTypes field selection. Returns the profile's appointmentTypes block (each with id, name, description, slotLength, price).

List the locations configured on a profile (booking page). YCBM API: GET /v1/profiles/{profileId} with a locations field selection. Returns the profile's locations block (each with id, kind, value, notes, strategy).