google-scholar-search-mcp
This MCP server lets AI assistants and automation workflows search Google Scholar for papers, citations, and BibTeX entries.
Paper search: keyword queries with year filters, relevance/date sorting, optional patents, and up to 20 results.
Citation tracking: list papers that cite a given work, with total citation counts.
Paper details: full metadata, abstract, public-access status, citations-per-year history, and BibTeX for a title lookup.
BibTeX export: get a ready-to-use citation entry for any paper.
Author lookup: find an author profile with h-index, i10-index, interests, and top publications.
Bulk search: run up to 10 queries in one call, with per-query errors that don't abort the batch.
Built-in safeguards: automatic rate limiting/delays, in-memory caching, retries, and optional proxy support to avoid blocks.
Provides tools for searching Google Scholar, including paper search, author lookup, citation tracking, paper details, and BibTeX export.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@google-scholar-search-mcp search for recent papers on quantum machine learning"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
google-scholar-search-mcp
An MCP (Model Context Protocol) server for searching Google Scholar, built for AI assistants and automation workflows that need papers, citations, and BibTeX entries.
Table of Contents
Related MCP server: Scholar MCP
Features
Paper Search: Query Google Scholar by keyword with filtering, sorting, and paging (
offset/next_offset, also for citations)Citation Tracking: Retrieve papers that cite a given work
ID Lookups: Fetch details, citations and BibTeX by
scholar_idinstead of a fragile title searchPaper Details: Get full metadata, citations-per-year graphs, and public access info
BibTeX Export: Generate citation entries in BibTeX format
Bulk Search: Batch search multiple queries with automatic rate limiting
Caching: Repeated lookups are answered from memory (no delay, no request to Scholar)
Rate Limiting: Every HTTP request to Scholar is spaced by a random delay (also the several requests inside one tool call), to avoid being blocked
Proxy Support: Optional proxy configuration (free, single, or ScraperAPI)
Installation
Requirements
Python 3.12or later
Recommended: uv + one-command setup
uv tool install google-scholar-search-mcp # or: pip install google-scholar-search-mcp
google-scholar-mcp setupsetup registers the server with Claude Desktop (claude_desktop_config.json) and Claude Code (claude mcp add --scope user), plus Cursor (~/.cursor/mcp.json), Windsurf and Gemini CLI when installed, and downloads the agent skill into ~/.claude/skills/google-scholar-mcp/. Existing entries in your config are preserved. Skip parts with --no-claude-desktop, --no-claude-code or --no-skill. Restart your client afterwards.
Try it without installing: uvx google-scholar-search-mcp setup.
Command | Purpose |
| Run the MCP server over stdio |
| Check whether Google Scholar answers this client (one request; exit code 1 if blocked) |
| Save Scholar cookies and User-Agent copied from the browser's developer tools (clipboard or |
| Configure clients and install the skill |
| Download the skill into every detected agent in the project (falls back to the bundled copy offline) |
install-skill detects which agents the current project uses and writes to each; name targets explicitly with --target. It never overwrites a differing file without --force, and only edits the marked block in shared files.
Target | Detected by | Written to |
| always |
|
|
|
|
|
|
|
|
|
|
|
| pointer block in |
|
| pointer block in |
Codex stores MCP servers in TOML (~/.codex/config.toml), which setup does not edit; its skill is covered by the agents target.
Build from Source
git clone https://github.com/LWaetzig/google-scholar-search-mcp.git
cd google-scholar-search-mcp
pip install -e .Note: This server uses the scholarly library to access Google Scholar. Respect Google's Terms of Service and use rate limiting appropriately to avoid being blocked.
Configuration
Configure the MCP server via environment variables:
Variable | Default | Description |
|
| Minimum seconds between two HTTP requests to Scholar. A tool call that needs several requests (e.g. a title lookup: search, then fetch) takes that many delays |
|
| Maximum seconds between requests |
|
| Number of retries on failure |
|
| Proxy mode: |
| — | HTTP proxy URL (for |
| — | HTTPS proxy URL (for |
| — | ScraperAPI key (for |
|
| Request timeout in seconds |
| — | File containing your browser's |
| — | Same, as a value (ends up in client config files; prefer the file) |
| — | User-Agent of the browser the cookies came from; must match |
|
| Seconds to stop querying Scholar after it blocked the client (bot check / sign-in redirect); calls fail fast with |
|
| Seconds a successful result is reused from memory ( |
|
| Most cached results kept; the least recently used is dropped first |
| GitHub raw URL of | URL advertised to agents in the server instructions; set to an empty string to omit |
Agent skill
The package ships SKILL.md, which tells an agent when and how to use the tools (tool choice, rate limits, error handling). google-scholar-mcp setup (or install-skill) downloads it from GS_SKILL_URL into ~/.claude/skills/google-scholar-mcp/, falling back to the bundled copy if the download fails. The server also advertises the URL in the MCP server instructions.
Proxy Configuration Examples
No Proxy (Default)
export GS_PROXY_TYPE=noneFree Proxy
export GS_PROXY_TYPE=freeSingle Proxy
export GS_PROXY_TYPE=single
export GS_PROXY_HTTP=http://proxy.example.com:8080
export GS_PROXY_HTTPS=https://proxy.example.com:8080ScraperAPI
export GS_PROXY_TYPE=scraperapi
export GS_SCRAPERAPI_KEY=your_key_hereUsage
Detailed documentation about single tools can be found here
Integration with Claude Desktop
Add the server to your Claude Desktop configuration:
Platform | Path |
macOS |
|
Windows |
|
Add the google-scholar entry under mcpServers:
{
"mcpServers": {
"google-scholar": {
"command": "google-scholar-mcp",
"env": {
"GS_MIN_DELAY": "5.0",
"GS_MAX_DELAY": "15.0",
"GS_PROXY_TYPE": "none"
}
}
}
}After updating the config, restart Claude Desktop. The Google Scholar tools will appear in the MCP Tools panel.
Integration with Other MCP Clients
Any MCP client (e.g., Cline, Continue, or custom tools) can use this server. Configure the connection to:
Command: google-scholar-mcp
Transport: stdioRate Limiting
The server automatically enforces rate limiting between requests to avoid overloading Google Scholar's servers:
Min Delay (default 5s): Minimum wait between consecutive requests
Max Delay (default 15s): Maximum wait (randomized to avoid patterns)
Max Retries (default 3): Retry failed requests up to this many times
These settings help prevent being blocked by Google Scholar. Adjust via environment variables if needed:
export GS_MIN_DELAY=3.0
export GS_MAX_DELAY=10.0
export GS_MAX_RETRIES=5⚠️ IP Blocking Warning
If you exceed Google Scholar's rate limits despite the rate limiter:
Your IP may be temporarily blocked (usually 24-48 hours)
All requests will fail with connection errors or 429 responses
Blocked IPs cannot make requests even with valid proxies on the same IP range
Repeated violations may trigger permanent blocks or require CAPTCHA solving
Recommended Practices:
Never decrease delays below 5 seconds — the defaults are tuned for reliability
Use the bulk_search tool instead of rapid sequential searches — it includes built-in delays
Add extra buffer during bulk operations — consider setting
GS_MIN_DELAY=10.0for large jobsUse a proxy service (free proxy or ScraperAPI) to distribute requests across multiple IPs
Monitor for 429 errors — if you see them, increase delays immediately and wait before retrying
Spread requests over time — don't run 100 queries in 5 minutes, even with delays
Recovery from IP Blocks
If your IP gets blocked:
Wait 24-48 hours for the temporary block to expire
Use a proxy — enable
GS_PROXY_TYPE=freeorscraperapito route through different IPsChange your network — use a different WiFi/ISP temporarily if possible
Contact support — for persistent blocks, escalate to Google Scholar support
Choosing Appropriate Delays
Scenario | GS_MIN_DELAY | GS_MAX_DELAY | Notes |
Single searches | 5.0 | 15.0 | Default; safe for occasional queries |
Bulk operations | 10.0 | 20.0 | Use for batch jobs; prevents rapid-fire requests |
Heavy load | 15.0 | 30.0 | Use with proxy for large-scale research |
Aggressive ⚠️ | <5.0 | <10.0 | Not recommended; high risk of IP blocking |
Troubleshooting
"Error: 429 Too Many Requests"
You've hit Google Scholar's rate limit. Solutions:
Increase delays: Set higher
GS_MIN_DELAYandGS_MAX_DELAYUse a proxy: Set
GS_PROXY_TYPE=freeor use ScraperAPIWait and retry: Google Scholar may be temporarily blocking; try again later
"No results found"
Check your query syntax (Google Scholar supports advanced search operators)
Ensure the paper title is spelled correctly
Try a simpler query with fewer keywords
[BLOCKED] / "JavaScript bot verification"
Google Scholar sometimes answers automated clients with a JavaScript "Verifying..." page or a
sign-in redirect instead of results. The server detects this and pauses Scholar requests for
GS_BLOCK_COOLDOWN seconds and returns [BLOCKED] instead. Delays and ordinary
proxies do not get past the bot check; a JavaScript-capable proxy (GS_PROXY_TYPE=scraperapi) may.
Using browser cookies (experimental)
Scholar's bot check needs JavaScript, which scholarly does not run. A real browser passes it once
and keeps the resulting cookies; handing those cookies (and the same User-Agent) to the server lets
scholarly reuse that verified session.
Open a private/incognito window and do not log in to Google.
Go to https://scholar.google.com, run any search, solve the CAPTCHA if one appears, and wait until results show.
Open the developer tools, Network tab, reload, right-click the request named
scholar?...and choose Copy > Copy as cURL (or Copy request headers).Run:
google-scholar-mcp set-cookiesIt reads the clipboard, saves the cookies and the User-Agent to
~/.config/google-scholar-mcp/cookies(readable only by you) and runsdoctor. The server reads that file automatically, so no environment variables are needed: just restart it. Without a clipboard tool, usegoogle-scholar-mcp set-cookies --stdin < copied.txt.
To manage the file yourself instead, put the cookie header value in a file (chmod 600) and set
GS_COOKIES_FILE and GS_USER_AGENT.
Notes: use the same machine and network as the server (cookies are usually tied to IP address and
User-Agent); they expire, so repeat the steps when doctor reports BLOCKED again; never use
cookies from a logged-in Google session (the server warns about login cookies such as SAPISID).
Cookie values are never logged or printed; doctor shows only their names.
Author profile pages (/citations) now require a signed-in Google session. This server deliberately
does not use login cookies, so it has no author tool.
"Connection timeout"
Increase
GS_TIMEOUTif your network is slowCheck your internet connection
Verify proxy settings if using a proxy
Contributing
Contributions are welcome! Please:
Fork the repository
Create a feature branch (
git checkout -b feature/your-feature)Commit your changes with clear messages
Push to your fork
Open a pull request
Tests
poetry run pytest tests/unit # fast, offline
poetry run pytest tests -m "not integration" # what CI runs
poetry run pytest tests -m integration # live Google Scholar, slowtests/integration drives the real server through an in-memory MCP client against live
Google Scholar and is marked integration automatically. If Scholar blocks your IP, those
tests skip instead of failing. They also run weekly via the Integration tests workflow.
Support
For issues, questions, or feature requests, please open an issue on GitHub.
License
Available Tools
5 toolsbulk_searchA
Search Google Scholar for multiple queries sequentially with rate limiting.
Use this for batch literature reviews. Each query runs one at a time with
delays between them to avoid being blocked. Only first pages are returned;
to see more of one query, call search_papers with its next_offset.
Args: queries (list[str]): List of search queries (maximum 10). max_results_per_query (int): Results per query (1-10, default 5). year_from (int | None): Filter to papers published in or after this year. year_to (int | None): Filter to papers published in or before this year.
Returns: BulkSearchResponse: One result per query plus per-query errors; failed queries do not abort the batch.
Inputs: queries (required), year_to, year_from, max_results_per_query. Returns: Combined result of several searches run in one call.
get_bibtexA
Get BibTeX citation entry for a paper.
Identify the paper with scholar_id from an earlier search result when
you have one.
Args:
title (str | None): Title of the paper to get BibTeX for.
scholar_id (str | None): scholar_id of a paper from an earlier search result.
Returns: str: BibTeX entry.
Raises: ScholarBlockedError: If Google Scholar blocks the client. ScholarRateLimitError: If Google Scholar throttles the request after retries. ScholarInvalidArgumentError: If no identifier is given. ScholarNotFoundError: If nothing matches.
Inputs: title, scholar_id. Returns: result
get_citationsA
Get papers that cite a given paper.
With only scholar_id the cited paper's title is not fetched (one
request fewer) and is omitted. To page, call again with offset set to
the next_offset of the previous response (None: no more), and
prefer scholar_id for the following pages.
Args:
title (str | None): Title of the paper whose citations to retrieve.
max_results (int): Maximum citing papers to return (1-20, default 10).
scholar_id (str | None): scholar_id of a paper from an earlier search result.
offset (int): Number of citing papers to skip (default 0). Scholar
serves at most the first 1000.
Returns:
CitationResponse: Citing papers, the cited paper's title and the total citation count when known, and offset / next_offset for paging.
Raises: ScholarBlockedError: If Google Scholar blocks the client. ScholarRateLimitError: If Google Scholar throttles the request after retries. ScholarInvalidArgumentError: If no identifier is given. ScholarNotFoundError: If nothing matches.
Inputs: title, offset, scholar_id, max_results. Returns: Papers that cite a given paper.
get_paper_detailsA
Get full details of a specific paper.
Identify the paper with scholar_id from an earlier search result when
you have one; a title search takes the first hit, which can be a different
paper.
Args:
title (str | None): The exact (or close) title of the paper.
scholar_id (str | None): scholar_id of a paper from an earlier search result.
Returns: PaperDetails: Details of the best-matching paper.
Raises: ScholarBlockedError: If Google Scholar blocks the client. ScholarRateLimitError: If Google Scholar throttles the request after retries. ScholarInvalidArgumentError: If no identifier is given. ScholarNotFoundError: If nothing matches.
Inputs: title, scholar_id. Returns: A paper with details, citation history and BibTeX.
search_papersA
Search Google Scholar for academic papers by keyword.
To page, call again with offset set to the next_offset of the
previous response (None means there are no more results). Each page
costs at least one slow request: only page when the user needs more.
Args: query (str): Search query (same syntax as Google Scholar search box). max_results (int): Maximum number of results to return (1-20, default 10). year_from (int | None): Filter to papers published in or after this year. year_to (int | None): Filter to papers published in or before this year. sort_by (str): Sort order — "relevance" (default) or "date". include_patents (bool): Include patents in results (default True). offset (int): Number of results to skip (default 0). Scholar serves at most the first 1000 results of a query.
Returns:
SearchResponse: Matching papers, with offset and next_offset for paging.
Raises:
ScholarBlockedError: If Google Scholar blocks the client.
ScholarRateLimitError: If Google Scholar throttles the request after retries.
ScholarInvalidArgumentError: If offset reaches past the first 1000 results.
Inputs: query (required), offset, sort_by, year_to, +3 more. Returns: Result of a single keyword search.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool targets a distinct operation: keyword search, single-paper details, citations, batch search, and BibTeX export. The only overlap is bulk_search versus search_papers, but the description explicitly frames bulk_search as a rate-limited multi-query batch whose results must be paged via search_papers, which resolves the boundary. get_paper_details and get_bibtex are close but differentiated by output type.
Names are uniformly snake_case and verb-first (search_papers, get_paper_details, get_citations, get_bibtex), so an agent can predict behavior from the name. The minor deviation is bulk_search, which uses a modifier rather than a clear object noun in the get_/search_ pattern.
Five tools is a tight, well-scoped surface for a Google Scholar search server, with each tool covering a distinct research workflow (discover, inspect, trace citations, export, batch). No tool feels redundant or padded.
Core lifecycle is covered: search, page, inspect details, follow citing papers, export BibTeX, and batch queries. The notable gap is the reverse citation direction (references/cited-by is one-sided) plus no author-profile or related-articles lookup, which are common scholarly research needs an agent would hit.
Maintenance
Related MCP Connectors
Academic research MCP server for paper search, citation checks, graphs, and deep research.
One MCP server for all web data. Scrape, search, crawl, and AI research in one install.
MCP server for Google search results via SERP API
Web search API and MCP server for developers building AI agents.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenance🔍 Enable AI assistants to search and access Google Scholar papers through a simple MCP interface.435-
- AlicenseBqualityDmaintenanceA local MCP server that allows users to search Google Scholar for academic papers by topic, author, and year range without requiring API keys. It utilizes web scraping to provide paginated results for research and academic exploration through natural language.2MIT
- AlicenseNot gradedqualityCmaintenanceAn MCP server that enables academic research by searching Google Scholar, fetching paper content, and converting web pages to clean Markdown.1MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for searching academic papers via Google Scholar, retrieving metadata and abstracts, with support for Chinese queries and auto-translation.87MIT