Avito MCP Server

Community

Let an AI agent run your Avito account: reply to buyers, keep listings priced and promoted, and fulfill orders automatically.

How to install ↓ Compare GitHub source repository ↗

Category: Other #71 of 230
Stars: ★ 23 Popular
Transport: stdio (local process) · Streamable HTTP
Runtime: Node.js 22.12+
Credentials: API key / credential required
License: MIT
Last commit: 47 days ago
Tools: 7

60FMRS · C

The server is feature-rich with a large toolbox, but its official status is unclear and requires trusting a large-scale proxy of 148 tools. Safety features like dual confirmation and dry-run are commendable, yet users must assess risks and configure carefully.

Strongest · Setup experience 13/20 Weakest · Maintenance 10/20

Reliability

11/20

Security and permissions

13/20

Maintenance

10/20

Documentation

13/20

Setup experience

13/20

Why each score

Reliability 11/20: README claims 915 tests across 54 files, CI badges, 84% statement coverage, wire-baseline replay tests, idempotency ledger, dry-run, structured error taxonomy, and fail-fast config parsing — a reliability-conscious design. However, under static calibration, README is untrusted evidence; no test files or workflow contents are supplied for verification, and the declared behavior of 148 tools (idempotent replay, confirmation gating) cannot be confirmed. Per the calibration rule reliability stays at or below 12. Deducted for unverifiable execution evidence on key paths.
Security and permissions 13/20: No red lines: no malware, credential theft, covert exfiltration, or irreversible defaults without confirmation. Security posture is strong on paper: two-step confirmation for money/public actions with a hard-gate secret option, auth_* token tools hidden by default, upload tool gated behind directory allowlist with symlink-race and magic-byte checks, 0600 token files in 0700 dirs, webhook registration locked to operator-configured URLs, redacted dry-run output. Deducted because all of this is self-reported README text rather than auditable source; webhook auth rests solely on a secret URL path segment; client_secret sits in plaintext env; the confirmation flow is admitted to not be cryptographic proof of human approval; full marks not justified without verifiable code.
Maintenance 10/20: Regular versioning (2.1.1), SemVer commitment, referenced MIGRATION.md/CHANGELOG/SECURITY.md (private vulnerability channel), CI badge indicating continuous integration. But repository license metadata is NOASSERTION, contradicting the MIT badge — an unresolved governance gap. Commit cadence, issue response, and dependency update practices have no evidence in the supplied material. Deducted for the license inconsistency and missing maintenance-activity evidence.
Documentation 13/20: Layered and thorough: quick start, a 17+ client configuration table, tool groups with risk classes, full environment variable reference, HTTP deployment with Caddy/nginx snippets, troubleshooting notes (Claude Desktop tray quit, log paths), and explicit out-of-scope and limitation disclosures (no sandbox, bearer/none not MCP-auth-conformant). Deducted because everything is README self-description with no supporting docs files to verify; swagger snapshot freshness depends on maintainer upkeep; referenced materials (ADRs, safety.md) are linked but not shown.
Setup experience 13/20: Setup path is clear: Node 22.12+, one-line npx, three credentials, a per-client config table covering all mainstream clients, HTTP mode off by default, plus --health diagnostics and troubleshooting guidance. Deducted because users must independently obtain three credentials from the Avito developer portal (external prerequisite); per static calibration, no in-file verifiable execution evidence caps setup below 15; the 148-tool scale and protocol-era variables add real configuration complexity.

Static review · not runListed 2026-09-08

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesUses the networkChanges third-party account data

Best for

Avito sellers aiming to reduce manual operational time
Advanced users needing to automate multi-store or multi-item management via APIs

Not for

Individuals without Avito accounts or developer credentials
Developers requiring a sandbox environment for testing (Avito does not provide sandbox credentials)
Users who need a fully offline solution without external dependencies

Required permissions

Read and reply to chat messages (requires messenger permissions)
Modify product listings, prices, and promotions (requires listings permissions)
Manage orders and fulfill shipping (requires orders permissions)
Access account balance and analytics data (requires financial permissions)

Risks and side effects

All operations execute against the live production environment; mistakes may lead to financial loss or account issues.
Credentials are stored in configuration; ensure secure storage to avoid leaks.
By default, high-risk actions require confirmation, but misconfiguration could execute unintended operations.
Reliance on external Avito API; subject to rate limits and service changes.

Setup

Before you start

Runtime：Node.js 22.12+

AVITO_MCP_CONFIRMATION_SECRET optionalsecret Secret that turns the confirmation flow into a hard gate.

AVITO_MCP_OAUTH_OWNER_PASSWORD optionalsecret Required in oauth mode; random secret of at least 32 bytes, the only thing that mints a token.

AVITO_MCP_HTTP_AUTH_TOKEN optionalsecret Comma-separated shared secrets for bearer mode, each at least 32 bytes.

AVITO_MCP_WEBHOOK_SECRET optionalsecret Path secret for the Avito webhook receiver; at least 32 random bytes.

Other optional settings (30)

AVITO_MCP_PROTOCOL_ERA optional Selects served MCP revisions: legacy (default), dual or modern.

AVITO_MCP_MODE optional Run mode: full_access (default), guarded or read_only — controls how many tools register.

AVITO_MCP_DRY_RUN_DEFAULT optional When true, destructive tools print the HTTP request instead of sending it.

AVITO_MCP_CONFIRMATION_MODE optional Confirmation flow mode; off removes the 3 confirmation meta tools.

AVITO_MCP_APPROVAL_MODE optional Set to external to require the confirmer to differ from the initiator.

AVITO_MCP_IDEMPOTENCY_TTL_SEC optional How long idempotency ledger entries live; default 1 hour.

AVITO_MCP_RUNTIME_STATE_DIR optional Directory for the durable idempotency ledger and runtime state.

AVITO_MCP_TOKEN_LOCK_TIMEOUT_MS optional Lock wait timeout when several processes share one token file; default 30s.

AVITO_MCP_ALLOW_TOOLS optional Tool-name allowlist for narrowing the visible tool set.

AVITO_MCP_DENY_TOOLS optional Tool-name denylist for hiding specific tools.

AVITO_MCP_EXPOSE_AUTH_TOOLS optional Set to 1 to expose the three auth_* tools that return OAuth tokens.

AVITO_MCP_ALLOWED_UPLOAD_DIRS optional Directories image upload may read from; the upload tool registers only when this is set.

AVITO_MCP_TRANSPORT optional Transport: stdio (default), http or both.

AVITO_MCP_HTTP_HOST optional HTTP bind address; default 127.0.0.1, keep loopback behind a proxy.

AVITO_MCP_HTTP_PUBLIC_URL optional Your public HTTPS domain, used as the OAuth issuer identifier.

AVITO_MCP_HTTP_AUTH optional HTTP auth mode: oauth (default), bearer or none.

AVITO_MCP_OAUTH_TOKEN_TTL_SEC optional Lifetime of issued bearer tokens; default 3600.

AVITO_MCP_OAUTH_STORE_FILE optional Durable client/token store file; one running server per file.

AVITO_MCP_HTTP_ALLOWED_HOSTS optional Allowed Host list for DNS-rebinding protection; fail-closed if underspecified.

AVITO_MCP_HTTP_ALLOW_INSECURE_PUBLIC_URL optional Development only: allows a cleartext issuer on a routable host.

AVITO_MCP_HTTP_ALLOW_NO_AUTH optional Permits auth=none off loopback; discouraged.

AVITO_MCP_HTTP_MAX_SESSIONS optional Legacy revision only: max concurrent sessions; default 100.

AVITO_MCP_HTTP_SESSION_IDLE_SEC optional Legacy revision only: idle session reap time; default 1800.

AVITO_MCP_HTTP_MAX_INFLIGHT optional Revision 2026-07-28: max concurrent /mcp exchanges; default 64.

AVITO_MCP_HTTP_MAX_STREAMS optional How many of those may be long-lived subscription streams; default 32.

AVITO_MCP_WEBHOOK_PUBLIC_URL optional Public HTTPS URL Avito posts events to; defaults to the HTTP public URL.

AVITO_MCP_WEBHOOK_PATH optional Webhook receiver path; default /avito/webhook.

AVITO_MCP_WEBHOOK_BUFFER optional Number of webhook events buffered; default 100.

AVITO_MCP_WEBHOOK_LOG_FILE optional Optional event log file (0600 perms, 10 MiB rotation).

AVITO_TOKEN_FILE optional Overrides the default OAuth token cache file location.

Obtain Client_id, Client_secret, and Profile_id from the Avito developer portal.
Add the above JSON to your MCP client configuration.
Restart your client and start using it.

claude_desktop_config.json

{
  "mcpServers": {
    "avito": {
      "command": "npx",
      "args": [
        "-y",
        "avito-mcp"
      ],
      "env": {
        "Client_id": "YOUR_CLIENT_ID",
        "Client_secret": "YOUR_CLIENT_SECRET",
        "Profile_id": "YOUR_PROFILE_ID"
      }
    }
  }
}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json

{
  "servers": {
    "avito": {
      "command": "npx",
      "args": [
        "-y",
        "avito-mcp"
      ],
      "env": {
        "Client_id": "YOUR_CLIENT_ID",
        "Client_secret": "YOUR_CLIENT_SECRET",
        "Profile_id": "YOUR_PROFILE_ID"
      }
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal

claude mcp add avito -e Client_id=YOUR_CLIENT_ID -e Client_secret=YOUR_CLIENT_SECRET -e Profile_id=YOUR_PROFILE_ID -- npx -y avito-mcp

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

After putting Client_id, Client_secret and Profile_id in the client's env block and restarting, ask "What's my Avito balance and how many unread chats do I have?" — a real answer proves the stdio connection and credentials work.

Troubleshooting

1. Ensure Node.js version is 22.12 or higher.
2. Check that environment variables (Client_id, Client_secret, Profile_id) are valid.
3. View logs: on macOS, see ~/Library/Logs/Claude/mcp-server-avito.log (macOS) for Claude Desktop.
4. Use the meta_health tool to check server status.
5. If connection fails, verify network and Avito API accessibility.

Things to try

Once connected, you can ask your AI assistant things like:

What's my Avito balance and how many unread chats do I have?
List my recent unread chats but don't send any replies yet.
Update item 12345's price to 1400 — do a dry run first.
Show me the current Avito API rate limit status.

Tools 7

messenger_get_chats read-only

Retrieve chats with optional filters like chat_id, used to check for unread messages.

listing_update_price writes

Update item price, with dryRun option for rehearsal.

order_ship writes

Mark an order as shipped, supports idempotency key to avoid duplicate charges.

meta_confirm_action writes

Confirm a pending sensitive or financial action by providing the confirmation ID.

meta_health read-only

Output server health information including version and counters.

meta_auth_status read-only

Check authentication status, optional probe to force token refresh.

meta_capabilities read-only

Report active mode, allow/deny counts, and feature flags.

Use cases

Automatically handle customer inquiries and chat replies

Automate price updates and promotion management

Process orders and track shipping logistics

Fetch real-time data such as account balance and sales analytics

Supported clients

Claude Desktop

Claude Code

Cursor

Windsurf

Listed from the project's documentation, not tested by this site.

Overview

The Avito MCP Server connects your Avito account to AI agents, enabling them to automate chat replies, update listing prices and promotions, manage orders, upload shipping labels, and more, covering 148 tools across 18 official Avito APIs. The server includes robust safety features: money-spending or public-facing actions require a second confirmation, dry-run mode allows rehearsal, and idempotency keys prevent duplicate charges. It runs over stdio by default for local use and supports HTTP with OAuth 2.1 for remote access. Ideal for Avito sellers who want to reduce manual work, but requires careful permission management and understanding of security features.

Similar servers

Hevy MCP 77 · B

Manage your Hevy workout data from AI assistants via MCP.

★ 517 · Tools 26 Compare with this →

Firecrawl MCP Server 75 · B

Firecrawl's official MCP server for web search, scraping, and structured extraction for AI agents

★ 7.6k · Tools 11 Compare with this →

BioMCP 75 · B

One binary. One grammar. Evidence from the biomedical sources you already trust.

★ 659 · Tools 11 Compare with this →

Compartment 75 · B

Encrypted, fully offline long-term memory for AI agents

★ 583 · Tools 14 Compare with this →

Compare with other MCP servers

Source revision 047b21e6b787 Data synced 2026-10-19 Read the FMRS scoring method