Prototyp · Vorschau: alle Server aus der offiziellen Registry, alle 30 Minuten synchronisiert. Bewertungen und Benutzerkonten folgen in einem späteren Schritt.
PopNx MCPMCP-Server für alle, die KI nutzen · in einfachen Worten erklärt
Einsteigermodus An
FarbenSystemHellDunkel
SpracheไทยEnglish中文日本語한국어EspañolDeutsch
☰ MenüEinstellungen
Einsteigermodus An
FarbenSystemHellDunkel
SpracheไทยEnglish中文日本語한국어EspañolDeutsch

J-Quants MCP

von shigechikaVersion 1.5.2i★ –iLäuft auf deinem Computer
Name in der Registryio.github.shigechika/jquants-mcp

Installieren

Überblick

Beschreibung vom Entwickler (englisches Original)

MCP server for retrieving Japanese stock market data via J-Quants API v2

Die drei Säulen von PopNx MCP

Diese drei werden nie zu einer Punktzahl zusammengefasst: Meinungen, Messungen und Beliebtheit sind verschiedene Dinge.

Was du damit machen kannst

Für diesen Server haben wir noch keine Zusammenfassung in einfacher Sprache geschrieben. Unten stehen die Fakten, die wir aus der Registry gelesen haben.

  • Verbindung: Läuft auf deinem Computer
  • Transport: stdio
  • Kategorie: Buchhaltung, Finanzen & Steuern

Installation

Wähle die KI-App, die du nutzt, und kopiere die Einstellungen.

Bevor du installierst

  • Basischecks: 1 von 1 bestanden
  • Läuft auf deinem Computer mit den Rechten deines Benutzerkontos (Dateien, Netzwerk, Apps).
  • Die Registry nennt keinen Schlüssel zum Eintragen.

Du brauchst

  • PyPIuv für Python installiert (für den Befehl uvx)

Welche App nutzt du?

Wähle oben deine App. Wir merken sie uns, damit der Button beim nächsten Mal „In … installieren“ anzeigt.

Öffne Claude Desktop → Settings → Developer → Edit Config und füge dies in claude_desktop_config.json ein

{
  "mcpServers": {
    "jquants": {
      "command": "uvx",
      "args": [
        "jquants-mcp"
      ]
    }
  }
}

Führe das in deinem Terminal aus

claude mcp add jquants -- uvx jquants-mcp

In Cursor öffnen

Oder kopier die Einstellungen selbst

In .cursor/mcp.json in deinem Projekt oder in ~/.cursor/mcp.json einfügen

{
  "mcpServers": {
    "jquants": {
      "command": "uvx",
      "args": [
        "jquants-mcp"
      ]
    }
  }
}

Dein Browser fragt, ob er die App öffnen darf, dann zeigt die App die Einstellungen und bittet dich um Bestätigung. Schlüsselwerte bleiben leer, damit du sie selbst einträgst.

In VS Code öffnen

Oder kopier die Einstellungen selbst

In .vscode/mcp.json in deinem Projekt einfügen

{
  "servers": {
    "jquants": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "jquants-mcp"
      ]
    }
  }
}

Dein Browser fragt, ob er die App öffnen darf, dann zeigt die App die Einstellungen und bittet dich um Bestätigung. Schlüsselwerte bleiben leer, damit du sie selbst einträgst.

Dieser Server läuft auf deinem Computer, und ChatGPT kann sich nur mit Servern im Internet verbinden. Wähle eine andere App.

Deine Auswahl bleibt in einem Cookie auf diesem Gerät; kein Konto nötig.

Diese Einstellungen werden aus dem Registry-Eintrag des Entwicklers erzeugt. Wenn in der README etwas anderes steht, folge der README.

Was er kann

Läuft auf deinem Computer; die Tool-Liste erscheint nach der Installation in deiner KI-App.

Basischecksi

Wir prüfen Informationen, die jeder sehen kann; den Code haben wir nicht gelesen. Checks, die nicht zutreffen, werden nicht mitgezählt. · Geprüft am 8. Nov. 2026

  • ✓ Bestanden

    Entwickler passt zum Repo

    Der Registry-Name wurde mit dem GitHub-Konto shigechika bestätigt, dem das Repo gehört

  • … Noch nicht geprüft

    Wird noch gepflegt

    Dieses Repo haben wir noch nicht von GitHub gelesen

  • … Noch nicht geprüft

    Hat eine Lizenz

    Dieses Repo haben wir noch nicht von GitHub gelesen

  • – Nicht zutreffend

    Endpunkt antwortet

    Dieser Server läuft auf deinem Computer; es gibt keinen Endpunkt im Internet

  • – Nicht zutreffend

    Anmeldung mit OAuth

    Läuft auf deinem Computer und nutzt stattdessen lokale Einstellungen

  • … Noch nicht geprüft

    Keine versteckten Anweisungen in Tool-Beschreibungen

    Läuft auf deinem Computer; Tool-Listen können wir nur von Endpunkten im Internet lesen

Im Vergleich mit anderen in Buchhaltung, Finanzen & Steuerni

  • Mehr Sterne als 0 % der anderen 2920 Server in dieser Kategorie
  • Neuer in der Registry veröffentlicht als 70 % der anderen 2920 Server in dieser Kategorie
  • Basischecks gleich gut wie oder besser als bei 100 % der anderen 2920 Server in dieser Kategorie

Verglichen mit allen aktiven Servern dieser Kategorie in der Registry. Sterne zählen nur, wenn dem Herausgeber das Repo gehört.

Häufige Fragen

Ist J-Quants MCP sicher?

Er hat 1 von 1 zutreffenden Basischecks bestanden. Den Code haben wir nicht gelesen. Bevor du einen Schlüssel oder Token hinzufügst, sieh nach, welche Zugriffe der Server verlangt, und nutze einen Schlüssel, der nur die Berechtigungen hat, die du brauchst.

Welche Schlüssel oder Codes braucht er?

Die Registry nennt keinen erforderlichen Schlüssel, manche Server bitten dich aber bei der ersten Nutzung, dich anzumelden.

Läuft er auf meinem Computer oder in der Cloud?

Er läuft auf deinem Computer. Deine KI-App startet ihn bei Bedarf, und die Daten laufen nicht über die Server des Entwicklers (außer der Server ruft selbst einen Onlinedienst auf).

Wird er noch gepflegt?

Das GitHub-Repo wurde zuletzt – geändert, und die neueste Version (1.5.2) kam vor 13 Tagen in die Registry.

Welche Apps können ihn nutzen?

Apps, die MCP unterstützen, etwa Claude Desktop, Claude Code, Cursor und VS Code. Außerdem brauchst du Python (uv) auf deinem Computer.

Was kann ich stattdessen nutzen?

In derselben Kategorie: Finance Toolkit, SolidInvoice, Korea Tax Calculator

Alternativen

Server derselben Kategorie von anderen Entwicklern, sortiert nach Sternen.

So liest du eine Karte:↓ Downloads pro Wochei★ GitHub-SterneiDrei Säulen: Bewertungen · Checks · NutzungiAktualisiert = neueste Version in der Registry veröffentlichti

Finance Toolkit

500+ transparent financial methods calculated from raw statements, not third-party endpoints.

von JerBoumaWeit verbreitet↓ 15.541/Wo.★ 5496Aktualisiert gestern

Computer oder Cloud
Installieren

SolidInvoice

Create and send invoices and quotes, manage clients, and track payments in SolidInvoice.

von SolidInvoiceWachsend★ 981Aktualisiert vor 9 Tagen

Läuft in der Cloud✓ solidinvoice.co
Installieren

Korea Tax Calculator

Korean tax calculation and tax-audit judgment MCP: 96 tools with statutory citations.

von UpstageAIWachsend↓ 3172/Wo.★ 97Aktualisiert vorgestern

Läuft auf deinem Computer
Installieren

README vom Entwickler

README öffnen

Unverändert aus dem Repo des Entwicklers übernommen. PopNx MCP hat den Inhalt weder geprüft noch empfiehlt es ihn. HTML, Bilder und Skripte wurden entfernt. Links führen von dieser Website weg.

jquants-mcp

English | 日本語

An MCP (Model Context Protocol) server that retrieves Japanese stock market data via J-Quants API v2.

User-facing documentation site: https://shigechika.github.io/jquants-mcp/ (also available in 日本語) — start there if you want a gentler 5-minute introduction. This README is the technical reference (config schema, all 55 tools with parameter tables, deployment).

Release history and changelog: GitHub Releases.

Deployment shapes and how to pick between them: see docs/deploy/.

Demo

24-second loop showing real output from the Claude iPhone app calling jquants-mcp tools:

  • Sector performance ranking (業種別騰落率) — get_sector_performance
  • Top turnover by trading value (売買代金ランキング) — get_top_turnover_value
  • Candlestick chart with SMA — get_candlestick_data
  • Quarterly financial summary (決算ダイジェスト) — get_fins_summary
  • 5-stock return comparison — get_comparison_chart_data

Individual frames are in docs/screenshots/.

Features

  • 55 MCP tools — 22 J-Quants API v2 endpoints, 11 market overview + valuation, 10 offline screener, 1 technical indicators, 1 single-stock summary, 3 cache-only equity search + earnings (schedule + results), 2 chart tools (JSON, no optional dependencies), and 5 server utilities
  • Two-tier SQLite cache — row-level cache for time-series data, response-level cache with TTL for others
  • Stock split detection — automatic cache invalidation when AdjFactor changes
  • Rate limiting — plan-aware sliding window (Free: 5/min, Light: 60, Standard: 120, Premium: 500)
  • Retry with backoff — automatic retry for 429/5xx errors
  • Pagination — transparent multi-page fetching
  • Plan-aware — all tools registered regardless of plan; graceful error messages on restriction

Requirements

Installation

# Using uv (recommended)

uv pip install jquants-mcp

Using pip

pip install jquants-mcp

From source
git clone https://github.com/shigechika/jquants-mcp.git

cd jquants-mcp uv sync --dev

Configuration

Settings are loaded with the following priority (later wins):

  1. ~/.jquants-api/jquants-api.toml — API key only (J-Quants official config)
  2. ~/.config/jquants-mcp/config.ini (user global)
  3. ./config.ini (current directory)
  4. Environment variables (from MCP client or shell)
API Key (zero-config)

If you already use jquants-api-client, your API key is automatically read from ~/.jquants-api/jquants-api.toml. No extra configuration needed.

API Key via browser login
jquants-mcp login

Opens a browser to J-Quants (AWS Cognito, PKCE flow), and on success writes the API key to ~/.config/jquants-mcp/config.ini (mode 0600). Same auth backend as the official jquants-cli. Use jquants-mcp logout to clear the saved key.

config.ini

MCP-specific settings (cache, client behavior):

[jquants]

cache_dir = ~/.cache/jquants-mcp

base_url = https://api.jquants.com/v2

[client]

max_retries = 5

retry_base_delay = 1.0

max_pages = 10

[server]

encryption_key = # enables per-user API key storage (multi-user mode)

allowed_emails = alice@example.com,bob@example.com

Environment Variables
VariableRequiredDefaultDescription
JQUANTS_API_KEYNo*—J-Quants API key
JQUANTS_API_TOML_PATHNo~/.jquants-api/jquants-api.tomlPath to the J-Quants official config file. Override to avoid macOS 26+ launchd sandbox restrictions (see macOS launchd note below)
JQUANTS_PLANNoauto-detectPlan: free / light / standard / premium (auto-detected from the API key at server startup; set this variable only to override)
JQUANTS_CACHE_DIRNo~/.cache/jquants-mcpCache directory path
JQUANTS_BASE_URLNohttps://api.jquants.com/v2API base URL
MAX_RETRIESNo5Max retry attempts for failed requests
RETRY_BASE_DELAYNo1.0Base delay (seconds) for exponential backoff
MAX_PAGESNo10Max pages to fetch per paginated request
JQUANTS_MCP_USERNo—Identity of the authenticated user, injected by the gateway (see Authentication). Never set this by hand
MCP_ENCRYPTION_KEYNo—Passphrase for AES-256-GCM encryption of per-user API keys
MCP_ENCRYPTION_KEY_PREVIOUSNo—Previous encryption passphrase — enables dual-key decrypt during a rotation window. See secrets rotation runbook
RATE_LIMIT_PER_MINUTENo60Per-user request ceiling (multi-user mode). Applies per JQUANTS_MCP_USER identity
RATE_LIMIT_BURSTNo20Per-user burst allowance (token-bucket capacity)
JQUANTS_ALLOWED_EMAILSNo—Comma-separated allowlist of emails. Empty = allow any user the gateway authenticated (self-host default). Set this on public Cloud Run instances to restrict access; unauthorized users get a 403-style message pointing them to self-host

\* API key is auto-detected from ~/.jquants-api/jquants-api.toml. Set JQUANTS_API_KEY only to override.

Environment variables override both config.ini and jquants-api.toml. This allows MCP clients (Claude Desktop, Claude Code, Codex, …) to pass settings via their env block while keeping defaults elsewhere.

macOS launchd note

If you run jquants-mcp as a macOS LaunchAgent and the API key lives in ~/.jquants-api/jquants-api.toml, the server may silently hang during startup on macOS 26 or later. The TCC sandbox applied to launchd-spawned processes blocks open() on some dotfiles under $HOME (mode 600), and the process never finishes starting.

Workaround: copy the toml outside the sandboxed home hierarchy and point the server at it via JQUANTS_API_TOML_PATH:

sudo mkdir -p /usr/local/etc/jquants-mcp

sudo cp ~/.jquants-api/jquants-api.toml /usr/local/etc/jquants-mcp/jquants-api.toml sudo chown "$USER":staff /usr/local/etc/jquants-mcp/jquants-api.toml sudo chmod 600 /usr/local/etc/jquants-mcp/jquants-api.toml

Then add the following to your LaunchAgent plist's EnvironmentVariables dict:

<key>JQUANTS_API_TOML_PATH</key>

/usr/local/etc/jquants-mcp/jquants-api.toml

Alternatives: set JQUANTS_API_KEY directly in the plist (simpler but puts the key in a plist file that Time Machine / iCloud may back up), or put api_key = directly in ~/.config/jquants-mcp/config.ini (if that path is not sandbox-blocked on your macOS version).

Linux/systemd and other init systems are not affected.

Authentication

The server speaks stdio only and binds no network socket, so it performs no authentication of its own — there is no listener to authenticate against. Access control is a property of whoever starts the process:

DeploymentWho controls access
Local (Claude Code, Claude Desktop, Codex, …)The OS. The MCP client spawns the server as a subprocess; the API key comes from config.ini / jquants-api.toml / JQUANTS_API_KEY
RemoteA gateway in front of the server. The gateway terminates authentication and spawns the stdio server per session
Gateway identity

For remote or multi-user deployments, put a gateway in front of the stdio server. mcp-stdio serve is the gateway both production deployments use: it accepts MCP over HTTP, authenticates the caller, and spawns one jquants-mcp child process per session.

The gateway passes the authenticated identity down to that child as the JQUANTS_MCP_USER environment variable (mcp-stdio serve --trusted-user-header X-Forwarded-Email --user-env JQUANTS_MCP_USER). One child process serves exactly one principal for its whole lifetime, and the server reads JQUANTS_MCP_USER as that principal's verified email — it applies the JQUANTS_ALLOWED_EMAILS allowlist and per-user rate limits to it, and looks up that user's stored API key.

Trust model: JQUANTS_MCP_USER is trusted as-is; the server does no verification of its own. Whoever can set the child process's environment *is* that user, so the variable must be injected by the gateway and never by a user-supplied value.

When JQUANTS_MCP_USER is absent — the normal local case — the server runs single-user against the globally configured API key.

A worked example of the whole shape (auth proxy in front, gateway, stdio child, cache download) is scripts/entrypoint-stdio.sh, the entrypoint of the Cloud Run deployment described below. There is no other documented remote-access story: the server itself has no transport, TLS, or token options.

Multi-user Mode

When the server receives a gateway identity (JQUANTS_MCP_USER, see Authentication) and MCP_ENCRYPTION_KEY is configured, it operates in multi-user mode: each user stores their own J-Quants API key on the server, and all data tools use that key automatically. All users share the read cache; each user gets an independent J-Quants client with isolated rate limiting and their own plan's date-range window.

User flow
sequenceDiagram

participant U as User participant C as MCP client participant G as Gateway (mcp-stdio serve) participant S as jquants-mcp (stdio child) participant J as J-Quants API U->>C: Connect C->>G: Authenticate (gateway's own auth layer) G->>S: Spawn child with JQUANTS_MCP_USER = verified email U->>C: "Register my J-Quants API key: " C->>G: register_api_key(api_key=" ") G->>S: forward over stdio S->>J: Probe plan-specific endpoints (auto-detect) J-->>S: Detected plan S->>S: Encrypt & store key + plan (AES-256-GCM) S-->>C: {"status": "ok", "plan": " "} U->>C: "Get TOPIX daily prices" C->>S: get_indices_bars_daily_topix(...) S->>J: API call with user's key J-->>S: Data S-->>C: Result

Tools for multi-user mode
ToolRequiredDescription
register_api_keyJQUANTS_MCP_USER + MCP_ENCRYPTION_KEYEncrypt and store your J-Quants API key
delete_api_keyJQUANTS_MCP_USER + MCP_ENCRYPTION_KEYRemove your stored key

Both tools return an explanatory error instead of failing silently when either requirement is missing.

Registering a key (tell your AI agent):

"Register my J-Quants API key: "

The agent calls register_api_key(api_key="..."). The server probes plan-specific endpoints with the key to auto-detect the plan (free / light / standard / premium) and stores it alongside the encrypted key — no manual selection needed. Subsequent tool calls use the detected plan for rate limiting and date-range restrictions.

This is the only way to register a key on a multi-user deployment; the server exposes no web form and no HTTP endpoint of any kind.

Security
  • API keys are encrypted with AES-256-GCM (authenticated encryption — integrity-protected)
  • The encryption key is derived via PBKDF2-HMAC-SHA256 (200,000 iterations) from MCP_ENCRYPTION_KEY, with a random 16-byte salt per encryption
  • Each ciphertext uses a unique random 12-byte nonce — encrypting t

Nur der Anfang wird gezeigt; den Rest findest du im Repo

PopNx fragen