Vaaya

active

Call paid services through Vaaya with one API key, or pay per call with no account. This specification covers the actions sold keyless: fixed-price actions over x402 (USDC on Base) and, where listed, MPP (Tempo charge, USDC.e), plus the MPP-only Hotel Lobby video job. Use GET /api/run for all actions, including free and variable-price services. Read the schema guide at…

AIBasex402 v2exactvaaya.ai ↗︎

Settled via Coinbase.

Transactions · 30d
1,005
Volume · 30d
$16.65
Unique buyers · 30d
27
Uptime · 30d
93.3%
Latency p50
151ms
Reported calls · 30d
887

Endpoints (305 live)

  • POST /api/run/brave/search — Brave — keyword web search over Brave's own independent index (not Google/Bing). Pass `q`; optional `count` (1-20), `offset` (pagination), `country` (2-letter), `search_lang`, `freshness` (pd|pw|pm|py or YYYY-MM-DDtoYYYY-MM-DD), `safesearch`, `result_filter` (comma list: web,news,videos,faq,discussions), `extra_snippets` (up to 5 alternative excerpts per hit). Returns ranked results with snippets — no page content; chain a scrape action for full text. The independent keyword-index alternative t… (0.01 USDC on Base)
  • POST /api/run/deepgram/transcribe — Transcribe audio (or the audio track of a video) to text with Deepgram Nova-3 — podcasts, calls, voicemails, interviews, screen recordings. Pass `url` (a publicly reachable audio/video file — stage local files via files/upload or fal/upload first) and `duration_minutes` (the approximate length, priced at 1¢/min, default 10). Options: `language` (ISO code, e.g. "en", "hi"), `detect_language: true`, `diarize: true` (speaker labels), `utterances: true` (timestamped segments), `model` ("nova-3" def… (0.02 USDC on Base)
  • POST /api/run/fal/generate — Generate or edit images, video, music, and speech via fal.ai. Pass `model` (one of the registered keys) plus the model-specific params (prompt, image_url, aspect_ratio, duration, text, etc.). (0.4 USDC on Base)
  • POST /api/run/fal/upload — Stage a media file on the fal CDN before a fal generation. Returns { upload_url, file_url }: PUT the raw file bytes to upload_url (with the matching Content-Type header), then pass file_url as the image_url/video_url/audio_url param of the generation. Upload originals UNCOMPRESSED — never downscale or re-encode; high-res inputs cost nothing extra and compression degrades outputs. (0.01 USDC on Base)
  • POST /api/run/brave/news — Brave — news-only search over the Brave index: recent articles with source, age, and breaking flags. Pass `q`; optional `count` (1-50), `country`, `search_lang`, `freshness` (pd|pw|pm|py), `safesearch`, `offset`. Use for current-events queries where web search returns stale evergreen pages. (0.01 USDC on Base)
  • POST /api/run/courtlistener/cases — Search 10M+ US court opinions (CourtListener v4). Pass `q` + optional `court` (e.g. cand, ca9, scotus), `judge`, `filed_after`/`filed_before`, `order_by` ("dateFiled desc"), `cursor` (pagination). Returns case names, courts, dates, cites, and absolute_url links to full opinions. (0.01 USDC on Base)
  • POST /api/run/openwebninja/website-contacts — Emails, phone numbers and social profile links (LinkedIn, X, Facebook, Instagram, TikTok, YouTube, GitHub, Pinterest) scraped live from a website root domain `query` ("acme.com"). Optional `match_email_domain` (only emails on that domain), `external_matching`. One call per domain, no name needed — different from tomba/icypeas person-level finders. (0.01 USDC on Base)
  • POST /api/run/openwebninja/social-links — Social profile URLs for a person or brand `query` ("Sam Altman", "Notion HQ") across facebook, tiktok, instagram, snapchat, twitter, youtube, linkedin, github, pinterest. Optional `social_networks` comma list to narrow. (0.01 USDC on Base)
  • POST /api/run/signalbase/investors — Signalbase — INVESTORS database: VC firms, angels, PE, corporate investors, government funds, accelerators, family offices, hedge funds, crowdfunding platforms. Filters: `type` (vc/angel/pe/corporate/government/accelerator/family_office/hedge_fund/crowdfunding), `search`, `headquarters`, `countries`, `ticket_size_min`/`max` (USD). `limit` ≤100 — flat price per call. Qualify funds and build investor target lists; pair with signalbase:funding (`investor_name`) to see a fund’s recent deals. (0.25 USDC on Base)
  • POST /api/run/fundable/industry-search — Fundable — Resolve an industry or super-category NAME to the exact permalink that fundable/deals expects ("fintech" → "fintech-e067", "AI" → "artificial-intelligence-e551"). Fuzzy match on `name`; optional `type`: INDUSTRY (specific) or SUPER_CATEGORY (broad, auto-includes its child industries). FREE upstream. Run this BEFORE any industry-filtered call — a hand-written permalink is silently ignored and you pay for unfiltered rows. (0.01 USDC on Base)
  • POST /api/run/perplexity/search — Perplexity — web search over Perplexity's own retrieval index, the one behind its answer engine, returning ranked results with snippets plus `date` and `last_updated` per hit. Pass `query`; optional `max_results` (1-10), `search_recency_filter` (hour|day|week|month|year), `country` (ISO-2), `max_tokens_per_page` (trim the excerpt), `search_domain_filter` (array of domains to include, or `-domain.com` to exclude). The freshness signal is the differentiator — results carry when the page was last … (0.01 USDC on Base)
  • POST /api/run/fundable/person-search — Fundable — Resolve a PERSON to Fundable's own person `id`, across both investors and non-investor people. Pass exactly ONE of `name`, `id`, `linkedin`, `crunchbase`, `twitter`. The id it returns is what fundable/person-deals takes, so this is the first call when you want every round an angel or a named partner has backed and you only have their name or profile URL. (0.01 USDC on Base)
  • POST /api/run/fundable/investor-search — Fundable — Resolve a FUND or firm NAME to Fundable's own investor `id`, with fuzzy matching and a `relevance_score`. Pass any ONE of `name`, `domain`, `linkedin`, `crunchbase`. Returns id, `guru_permalink`, description, domain and socials. This is how you go from "Benchmark" to the id fundable/investor-deals needs, so it is the first call in any fund → portfolio walk that starts from a name. (0.01 USDC on Base)
  • POST /api/run/fundable/company-search — Fundable — Resolve a company NAME to Fundable's own company `id`, with fuzzy matching and a `relevance_score`. Pass any ONE of `name`, `domain`, `linkedin`, `crunchbase`. The entry point to the graph when all you have is a name: the `id` it returns is what fundable/company and fundable/company-deals take. If you already have a domain, call those directly instead and save the hop. (0.01 USDC on Base)
  • POST /api/run/fundable/location-search — Fundable — Resolve a place NAME to the exact permalink that fundable/deals expects ("san francisco" → "san-francisco-california"). Fuzzy match on `name`; optional `type`: CITY, STATE, REGION or COUNTRY. FREE upstream. Run this BEFORE any location-filtered call — a hand-written permalink is silently ignored and you pay for unfiltered rows. (0.01 USDC on Base)
  • POST /api/run/openwebninja/jsearch — OpenWeb Ninja JSearch — Google for Jobs aggregate: title, employer, city/state/country, remote flag, salary when published, apply link, description, posted-at timestamp. Pass `query` (put the country in the text: "Product Manager in India"); optional `page` (1-based), `num_pages` (1-10, ~10 postings each), `date_posted` (all|today|3days|week|month — week is denser than month), `country` (2-letter), `remote_jobs_only`, `employment_types` (FULLTIME,PARTTIME,CONTRACTOR,INTERN). Cheapest job feed o… (0.01 USDC on Base)
  • POST /api/run/firecrawl/extract — Firecrawl — Extract structured data from URLs using a schema. (0.01 USDC on Base)
  • POST /api/run/scrapingant/markdown — ScrapingAnt — Scrape a URL and return LLM-ready markdown (rendered in headless Chrome, then converted). Pass `url`; optional browser/wait_for_selector/proxy_country/timeout knobs. Returns `{ url, markdown }`. Alternative to crw/scrape or firecrawl/scrape when you want ScrapingAnt's proxy pool behind the fetch. (0.01 USDC on Base)
  • POST /api/run/edgar/fulltext — SEC EDGAR full-text search over all filings (2001+). Pass `q` (quote for exact phrase) + optional `forms` (comma-separated: D = private fundraises, C/C-AR = Reg CF financials, 1-K/1-SA = Reg A financials, 4 = insider trades, UPLOAD/CORRESP = SEC comment letters), `startdt`/`enddt` (YYYY-MM-DD), `from` (pagination offset). Hits include the filer, date, and {accession}:{filename} ids for edgar/document. (0.01 USDC on Base)
  • POST /api/run/files/upload_from_url — Fetch a file from a public URL into your persistent Vaaya file library (server-side — no local download needed). Returns file_id and get_url. Max 100MB per file. (0.01 USDC on Base)

+285 more endpoints.

MCP tools (14)

Vaaya https://vaaya.ai/mcp

  • buy — Find and buy products, tickets, bookings and subscriptions for the user at supported stores. Start with `search` { query } to find the item and merchant page using Vaaya OneSearch (5¢ per search); the user can describe what they need without supplying a link. Before checkout, use `setup` to check payment and shipping readiness; resolve missing setup once. Persistent merchant accounts are managed at /store-connections. Use store_connection_id to select an account. Passwords and verification codes belong only on the merchant page, never in chat. PRODUCT DISCOVERY: if the user describes what to buy but provides no URL, use `search` { query: <product, variant, budget and preferred merchant if specified> } to locate it under the existing tool spending permissions; do not ask them to paste a link or say search for it first. Search is not purchase authorization. Respect search fees and spending limits; if search is unavailable, explain the actual error and then ask for a link. Verify the merc
  • close — Close an E2B sandbox session and stop its billing. Pass the `session_id`. Captures the final metered uptime cost and releases the hold. ALWAYS call this when finished with a session — an open session keeps billing per second of uptime. Safe to call repeatedly (idempotent).
  • consult — Plan an external task and get the exact call to run. Describe the job in plain words, not a vendor name: '4 product shots of this mug on marble', 'keyword volume for trail shoes in the US', 'work email for the CTO of acme.com'. Free: it runs and bills nothing. Returns mode='call': an ordered list of `use` calls, each with service, action, params, price_cents and max_cost_cents, and a short message on why this option and what the alternatives are (multi-step plans may hold placeholders like '<from step 1: sandbox_id>'; run earlier steps first and substitute). mode='converse': a question or options for the user; ask them and pass the answer back as the next intent (it remembers prior turns). mode='unsupported': not in the catalog. Replies carry 2-3 `suggestions`; offer the ones that fit. Optional: after running a plan, a one-line note on the outcome (what was produced, any failures) returns next steps that take the result into account. Check with consult before telling the user Vaaya can
  • docs — Vaaya's deep reference, FREE and instant. Pass `topic` to get the full playbook for a capability area — exact services, actions, params, prices, model lists, and gotchas — the same reference files the vaaya skill ships. Topics: 'setup' (connecting an agent, a chat app, or an unattended process), 'tools' (exact params of every Vaaya tool, GTM suite included), 'media' (image/video/audio models + product-demo videos), 'gtm' (leads, enrichment, outreach, signals, email), 'research' (OneSearch lanes, deep research, company/market research playbooks), 'data' (scraping, people, social platforms, public records, onchain, compliance), 'compute' (sandboxes, browser automation, files, memory, workers, phone calls, llm). Reading the matching topic before non-trivial work in that area is cheaper than a wrong call. Never bills; safe to call any time.
  • jobs — Jobs: a marketplace where humans hire humans, and each side's agent handles the steps. Call with { action, ...params }. Actions: list, get, mine, draft, update_draft, cancel, accept, submit_proof, record_verdict, request_release, dispute. A poster's agent drafts a job (budget_usd, definition_of_done, required_evidence) and gives its human the review_url; the HUMAN publishes, which holds the budget from their wallet. A doer's agent accepts an open job for its human and later submits that human's proof (summary + links). The poster's agent evaluates the proof against the definition of done with record_verdict. Only the poster, in their own browser on the job page, can release payment; no action here moves money to anyone. Never claim the agent did the work.
  • llm — Ask a DIFFERENT LLM a question and get its answer, billed per token from the Vaaya wallet (the model provider's cost with zero markup, usually a fraction of a cent). Use it to get a second opinion from a rival model, cross-check an answer, summarize a huge blob cheaply, or query a specific model the user names (Kimi, GPT, Gemini, Claude, DeepSeek, and 300+ more). `model` accepts 'auto' (default: short prompts go cheap, long go mid), 'cheap' | 'mid' | 'best' tiers, or any exact OpenRouter slug like 'moonshotai/kimi-k3'. Typical costs: cheap tier well under 0.1 cents, best tier 1-3 cents per call. Not for the conversation you are already having — it is a one-shot ask to another model.
  • result — Fetch the status + output of an async job started by `use` (e.g. a video render). Pass the `job_id` that `use` returned with `{ async: true }`. Returns `{ status, result?, progress?, charged_cents }`: `running` (still working — when the job reports it, `progress` carries `{ phase, percent, rendered_frames, total_frames, eta_sec }` and `hint` is a one-line summary like "rendering 42% (380/900 frames, ~120s left)", so you can tell real progress from a hang; wait a bit and call again), `succeeded` (`result` holds the output, e.g. the video URL; the call is charged now), or `failed`/`cancelled` (no charge; on `failed`, read `error` and `hint` — `hint` carries the service's usage notes, which usually explain how to fix the call). Safe to call repeatedly: it never starts new work or double-charges. Use this to retrieve an async result; re-running `use` starts a new paid job.
  • session — Run a command or code in an open E2B sandbox session (started by `use` with action `create_session`, which returns a `session_id`). Pass `session_id` plus either `command` (a shell command) or `code` (+ optional `language`: python/javascript/bash). Returns stdout/stderr/exit_code (or the code result). The sandbox stays alive — and billed per second of uptime — until you `close` it; re-running reuses the SAME box, so filesystem + process state persist between calls. ALWAYS `close` when done.
  • stocks — Buy tokenized stocks on Base using only the user’s prepaid Vaaya balance, never the welcome credit or the GitHub credit line. Commands: list (supported token tickers), portfolio (owned stocks and buying power), quote {symbol, amount_cents}, buy {symbol, amount_cents, idempotency_key}, order {order_id}. When the user asks to buy a specified stock and dollar amount, resolve its supported token ticker (Apple = AAPLc) and call buy directly; no activation or additional approval step. amount_cents is the maximum total prepaid spend including provider fees. Use a unique idempotency_key for each intended purchase and reuse it on retries. Query order until confirmed/failed; queued/submitted is not success. Do not increase the user’s spend or retry a failed purchase as a new order without instruction. Ask only for missing or ambiguous purchase details. If prepaid_required or buyingPowerCents is insufficient, offer a $14/$40/$60 prepaid pack: POST /api/v1/topup with pack_cents 1400/4000/6000 and
  • use — Run one external call: image, video and audio generation, web search, scraping, data and enrichment, email, document parsing, code sandboxes, browser automation, embeddings and more. Billed only on success and never above `max_cost_cents`. The server validates params against the endpoint schema and holds the credentials, so you never pass URLs or API keys. Call it directly when you know the exact (service, action, params, max_cost_cents) from a `consult` plan, the vaaya skill's catalog or a call you have already run; when unsure, consult instead of guessing. Long jobs return { async: true, job_id }; poll them with `result`.
  • vaaya_account — Show which Vaaya account this connection is linked to and its money state. Returns { email, name, user_id, connected_client, scopes, balance_cents, credit_line, available_cents, credits_url, switch_account }. Call it whenever the user asks "which account is connected", "what's my balance", "how much credit is left", or "how do I switch accounts" — and relay the answer. `credit_line` is the credit the account can spend past its prepaid balance (the welcome credit plus any GitHub-score line); `available_cents` = balance + active line, the number calls are gated on.
  • vaaya_logout — Disconnect this client from the current Vaaya account: revokes this connection's authorization server-side, so every later call fails with 401 until the user reconnects. Call it when the user asks to log out, sign out, disconnect, or switch Vaaya accounts — then relay the returned switch steps VERBATIM (the browser sign-out step is what actually enables switching accounts).
  • vaaya_onboard — Public onboarding hint for an agent whose user isn't linked to Vaaya yet. Returns where the human should go to connect (and sign up if new). Call this when vaaya_test_connection reports needs_auth, or any tool returns unauthorized, then relay the instructions to the user. If the user IS already linked it returns `first_call` instead — show `first_call.show_to_user` as written so they know what to try.
  • vaaya_test_connection — Round-trip ping that confirms the agent → Vaaya connection and whether the user is linked. Returns { ok:true, userId, scope, version, server_time, first_call } when linked — SHOW `first_call.show_to_user` to the user as written, it is the same set of starter examples the website and installer give them. Returns { ok:false, needs_auth:true, verification_uri, signup_uri, instructions } when not linked yet — relay that to the user so they can connect (and sign up if new).

First seen · last seen · last active