205,128 tools. Last updated 2026-06-15 09:36
"Uber Eats" matching MCP tools:
- List email templates for the target company. Returns paginated results with template name, subject, and body. Recommended size <= 10: templates include the full HTML body; if the response exceeds the budget the tool returns isError:true with error_code=response_too_large and retry hints — reduce size or fetch a single template via hires_get_email_template.Connector
- Corrects the category of one or more transactions (PATCH /transactions/:id). Pass `items` as an array of { transaction_id, category_id } — `transaction_id` comes from openfinance_list_transactions, `category_id` from openfinance_list_categories. This overrides Pluggy's automatic categorization AND teaches Pluggy: recategorizing a transaction automatically creates a Category Rule for this client (case-insensitive exact match on the transaction's data), so FUTURE similar transactions are categorized the same way — use this to fix miscategorized transactions and improve categorization accuracy going forward. Batch shape: returns `{ updated, results: [{ transaction_id, category, categoryId }], errors: [{ id, status, message }] }` — per-item errors do not fail the whole batch.Connector
- Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call. Resolves the connection's accounts internally and fans out their transactions, so you do NOT need to call openfinance_list_accounts first nor carry account_id uuids between calls. Pass `item` (connector_id, connector_name or item_id) to target one bank, or OMIT it to analyze ALL linked banks at once. `from`/`to` are ISO dates (YYYY-MM-DD). Default `granularity:'monthly'` returns a COMPACT summary (no raw rows): total entradas, saídas, saldo_liquido, monthly evolution (`por_mes`), and `top_despesas`/`top_recebimentos` (largest N each), plus a per-account breakdown (`by_account`). Use this for 'análise anual/mensal', 'fluxo de caixa', 'entradas e saídas', 'maiores gastos/recebimentos'. Set `granularity:'raw'` to ALSO get every consolidated transaction (heavier — only when itemized rows are needed). `type` filters BANK or CREDIT accounts. On a connection with many transactions the scan caps at 5000/account and flags `truncated:true`.Connector
- Returns bill-level detail for one or more credit card bills by id (GET /bills/:id): financeCharges and payments[] (id, paymentDate, amount, valueType, paymentMode). Does NOT return individual transactions — to get itemized credit card transactions (purchases, subscriptions, etc.), use openfinance_list_transactions with the credit card account_id and a from/to date range matching the bill's billing cycle (approximately dueDate − 30d to dueDate); each transaction's creditCardMetadata.billId links it to the specific bill. Pass `bill_ids` as an array — use openfinance_list_credit_card_bills first to discover ids. `{ results, errors }` batch shape. NOTE: Pluggy does NOT return a paid/status field. In Brazilian Open Finance, `payments[]` reflects payments registered during THIS bill's billing cycle — typically the payment of the PREVIOUS bill (do NOT assume this bill was paid just because `payments[]` is non-empty). To check paid status, prefer `openfinance_list_credit_card_bills` which derives `payment_status` via cross-bill match.Connector
- List applications across all accessible jobs. Supports filtering by candidate, job, stage, status, AI score range, and date ranges. Use for pipeline analytics, sync jobs, and ATS dashboards. Avoid include=candidate or include=cv.text on large pages (each embeds heavy nested data); if the response exceeds the budget the tool returns isError:true with error_code=response_too_large and retry hints. Each application embeds its current `stage` (IdName) directly in the response — this is sufficient for rendering kanban/pipeline views; you DO NOT need to call hires_get_job to fetch workflow_stages separately when rendering a pipeline.Connector
- Returns transactions for a bank account (BANK or CREDIT type). For CREDIT (credit card) accounts, this is the ONLY way to get itemized transactions (purchases, subscriptions, etc.) — each credit card transaction carries `creditCardMetadata.billId` linking it to a specific bill from openfinance_list_credit_card_bills. CREDIT PENDING vs POSTED varies by connector: where the bank exposes future-dated `status:'PENDING'` installments, those represent the OPEN bill plus future bills (future months); where it does NOT, only the last closed bill's POSTED items appear until ~closing. Same query, different coverage per bank (upstream). To get a standardized open-bill total / total debt regardless, use openfinance_list_credit_card_bills (`open_bill` / `total_pending_debt`). Supports from/to date filters (ISO YYYY-MM-DD), pagination (max 500/page), and optional keyword filter via `search_queries` (case- and accent-insensitive substring match against description and merchant name, OR semantics across multiple terms). When `search_queries` is set the tool aggregates up to 5000 transactions within from/to before filtering — narrow from/to if `truncated:true` is returned. On upstream errors, returns { total:0, results:[], warning, error } instead of throwing. If total is 0 for a CREDIT account, check the connection health via openfinance_get_item_status — `statusDetail.creditCards.isUpdated: false` means the credit card sync failed and a force sync (openfinance_force_sync) or reconnection may be needed. Bulk support: accepts account_ids for batched execution.Connector
Matching MCP Servers
- Flicense-qualityDmaintenanceA proof-of-concept Model Context Protocol server that enables LLM applications to interact with Uber Eats, allowing AI agents to browse and order food through natural language.Last updated228
- Flicense-qualityDmaintenanceEnables interaction with Uber Eats for food ordering and delivery management through natural language, acting as a proof-of-concept MCP integration.Last updated
Matching MCP Connectors
Connect your Uber Conta by Digio account to AI via Brazil's Open Finance: balances, statements, card
Ask Factorial ATS the recruiting-ops questions dashboards miss by connecting applications, phases, candidates, sources, feedback, evaluation forms, job postings, messages, questions, answers, and rejection reasons. Find applications aging in phase, feedback debt by role and posting, source-quality gaps, rejected-candidate hygiene, incomplete application data, hiring-stage bottlenecks, and owner queues. No dashboard build. No SQL.
- Lists loan contracts per bank connection (GET /loans). Pass `items` as an array of connection selectors (item_id uuid, connector_id, or connector_name) — one entry per connection to fetch; multiple connections are queried sequentially with rate-limit spacing. OMIT `items` to list loans across ALL linked banks. Returns `{ results, errors }` per connection.Connector
- Returns accounts for a bank connection: BANK (checking/savings) and CREDIT (credit card) with balance, number, type, subtype, bankData, and creditData. Also returns `bank` (the brand/connector name like 'Nubank Empresas' — same shown in the dashboard UI) and `connector_id`. Note: each account's `name` is the legal entity that issues the account (e.g. 'Nu Pagamentos S.A. - Instituição de Pagamento'), which is not the same as the brand — when referring to the bank in user-facing text, use `bank`. OMIT `item` to list accounts across ALL linked banks at once — the response aggregates every connection's accounts into `results`, each row tagged with its own `bank`/`connector_id`/`item_id` (use this when the user asks for 'my accounts/cards' without naming a bank). Pass `item` to target a single bank (response carries `bank`/`connector_id`/`item_id` at the root). CREDIT (credit card) `balance`: its meaning is CONNECTOR-DEPENDENT — some banks report the current open-bill partial, others the full revolving/installment debt — so do NOT treat `balance` as 'this month's bill'. The open billing cycle is defined by `creditData.balanceCloseDate` (when it closes) / `balanceDueDate` (when it's due). For a standardized open-bill amount and total debt that mean the same across connectors, use openfinance_list_credit_card_bills (`open_bill` + `total_pending_debt`, derived from PENDING transactions); closed bills come from that same tool's `results`.Connector
- Download an attachment (resume, candidate file, application file, mail attachment, call recording). Pass the absolute URL returned by another endpoint (e.g. `message.attachments[].url`, `cv.url`, `resume.url`) — it MUST belong to the configured 100Hires API host; other hosts are rejected to avoid leaking the Bearer token. Returns `{file_name, mime_type, size, data}` where `data` is base64-encoded bytes. Files larger than 25 MB are rejected up-front (Content-Length check / streaming abort) without being loaded into memory.Connector
- Get the full chronological stage transition history for an application, including the initial assignment. Each entry has from_stage_id/name, to_stage_id/name, moved_at (Unix seconds), moved_by_type (system, user, automation), moved_by_user_id, and source (what caused the transition, e.g. 'apply:indeed', 'form_watcher', 'user'; null for historical records). Use this for funnel analysis, attribution reports, and time-in-stage reports instead of paginating through /candidates/{id}/activities when only stage data is needed.Connector
- Returns real-time balance payload per account id (GET /accounts/:id/balance). Pass `account_ids` as an array (1–50). CREDIT accounts may return Pluggy BALANCE_FETCH_ERROR — those rows include a structured `warning` instead of throwing. Response shape: `{ results: [...], errors: [{ id, status, message }] }`.Connector
- List interviews with optional filters by job, application, candidate, interviewer, date, or timestamps for incremental sync. Returns paginated results. **Always pass `include=candidate`** when surfacing results in the agenda widget — without it, the widget can only show candidate IDs and cannot link cards to candidate profiles. Avoid include=job on large pages (embeds full job description per interview); if the response exceeds the budget the tool returns isError:true with error_code=response_too_large and retry hints.Connector
- Get billing/pricing capability flags for the current company. Use before invoking paid-only API behaviors.Connector
- List timeline activities for a candidate (comments, stage moves, AI responses, etc.). Supports filtering by event type. Recommended size <= 10: copilot responses and call transcriptions can be large per event; if the response exceeds the budget the tool returns isError:true with error_code=response_too_large and retry hints.Connector
- Upload a file for a candidate using a base64 payload. Used for portfolio uploads and document attachment. WARNING: host function-call serializers (both OpenAI and Anthropic) truncate tool arguments above ~20KB, so binary files larger than that will arrive corrupted. For resumes specifically, prefer hires_create_candidate / hires_update_candidate with resume_text — the model parses the file from chat context and passes extracted text, avoiding the size limit entirely.Connector
- Checks the LIVE operational status of the Open Finance provider (its public status page) — this is the PROVIDER's health, separate from your own connection's `openfinance_get_item_status`. Use it whenever data looks incomplete or stale even though a connection shows UPDATED (accounts/transactions/balances missing, a bank not returning everything): it reveals an upstream outage or a known incident on a specific bank/connector, so you can tell a provider-side problem apart from a connection that just needs reconnecting. Returns the global indicator (none/minor/major/critical), degraded components, open incidents, and — when you have banks connected — flags the incidents that affect YOUR connected banks in `your_banks_affected`.Connector
- Forces the bank to re-sync one or more connections NOW and WAITS for it to finish (PATCH /items/:id, then polls until the item stops updating, up to ~60s). Use this when a balance or transaction list looks stale: a connection can read UPDATED yet be hours old, and this pulls fresh data WITHOUT disconnecting/reconnecting. Pass `items` as an array of selectors (item_id, connector_id, or connector_name); OMIT `items` to sync ALL linked banks. Returns `{ results, errors }`; each result has the final `status`, `executionStatus`, `lastUpdatedAt` (advances when data is refreshed), and `synced` (true = fresh data is ready). `needs_action` (e.g. LOGIN_ERROR / WAITING_USER_INPUT) means the user must reconnect; `timed_out: true` means the sync is still running — re-check with openfinance_get_item_status. Set `wait: false` for fire-and-forget (returns immediately while UPDATING).Connector
- List application forms (paginated). Returns forms with their questions for the target company. Recommended size <= 10: each form embeds its full question list; if the response exceeds the budget the tool returns isError:true with error_code=response_too_large and retry hints.Connector
- List available placeholders for email templates with pagination. Use `type` to filter by category, `q` to search by label. Discover placeholders here, then use hires_prepare_template_placeholders to get an HTML tag for insertion.Connector
- Returns CLOSED credit card bills for a CREDIT-type account: dueDate, totalAmount, minimumPaymentAmount, allowsInstallments, plus `payments[]` (id, paymentDate, amount, valueType, paymentMode), `payments_count`, `payments_total`, finance charges aggregates, and a derived `payment_status` per bill. IMPORTANT — Brazilian Open Finance semantics: Pluggy does NOT return a `paid`/`status` field. The payment goes into the `payments[]` of the bill whose CYCLE contains the paymentDate (closing ≈ dueDate − 7d): pre-payment before close stays on the bill being paid; payment between close and due, or after due, lands on the NEXT bill. So `payments[]` on a bill commonly carries the previous bill's payment, NOT the current one's — do NOT assume this bill was paid just because `payments[]` is non-empty. Use the derived `payment_status` (`PAID` | `OPEN` | `PAST_DUE_UNCONFIRMED` | `PAST_DUE_UNPAID`): a bill is `PAID` when its OWN `payments[]` (early pre-payment) or ANY newer bill in the payload contains a payment with amount ≈ this bill's `totalAmount` (±R$0.50). The MOST RECENT bill that's past-due, with no own pre-payment match, cannot be confirmed via cross-bill (the next cycle hasn't closed yet) — it returns `PAST_DUE_UNCONFIRMED`. NEVER call such a bill 'vencida' categorically; flag that the payment may have been made between close and due and not yet reflected upstream. The full `payment_status_legend` is returned alongside the results. OPEN BILL & TOTAL DEBT (standardized, derived — OPT-IN): pass `include_open_bill:true` to ALSO get `open_bill` (the current not-yet-closed bill, próxima a vencer) and `total_pending_debt` (saldo devedor total = all pending installments), BOTH derived from PENDING transactions so they mean the same thing across connectors — use these instead of the CREDIT account's `balance`, whose meaning VARIES by connector (some report the open-bill partial, others the full installment debt). `open_bill` = { available, method (`cycle_dates`|`calendar_month_fallback`), close_date, due_date, total_amount (net charges − credits), transaction_count }; plus a `future_bills[]` breakdown per month for installments dated beyond the close. CONNECTOR ASYMMETRY: where the bank does NOT expose the open bill before closing (it publishes only closed bills, no PENDING), `open_bill.available` is `false` with a `reason` and `total_pending_debt` is `null` — that bill simply isn't retrievable by any endpoint until it closes (upstream limit of the institution's Open Finance feed, not our filter). Default `false` (the projection runs an extra accounts+transactions scan, so it's opt-in). This tool's `results` are bill-level summaries — NOT individual transactions. To see itemized purchases/charges per bill, use openfinance_list_transactions with the CREDIT account_id (each transaction's creditCardMetadata.billId links to the bill). Returns a warning instead of failing if the CREDIT_CARDS product is not enabled. Bulk support: accepts account_ids for batched execution.Connector