Google Scholar MCP Server

A hosted Model Context Protocol (MCP) server that gives Claude, Cursor, Windsurf and any other MCP client two read-only Google Scholar tools. Search the literature with Scholar's own operators, year ranges and cited-by lookups, then pull a paper's citation in five styles with its BibTeX and EndNote export links, both as structured JSON, with nothing to host.

It reads public Google Scholar pages that a signed-out visitor can see.

1,000 free credits every month, no card required, which is 100 Scholar calls at the 10-credit rate.

https://mcp.hasdata.com/api/mcp?apis=google_scholar

Contents

• What you need

• Quick start

• Example prompts

• Tools

• Errors and failure paths

• Pricing, free tier and limits

• Tool selection

• How it compares

• FAQ

• HasData links

• Development

• Contributing

• License

Related MCP server: CiteNexus MCP

What you need

An MCP client and a HasData API key from the dashboard, free to create with no card, and the free tier covers about 100 calls a month at the 10-credit rate. This is a remote server, so the simplest path is a URL and an x-api-key header, with no container to run. A client that only speaks stdio reaches it through a thin launcher, published as @hasdata/google-scholar-mcp on npm and hasdata-google-scholar-mcp on PyPI, shown below.

Quick start

The server URL is the same for every client. We run it hands-on in Claude Code and Claude Desktop. The other blocks follow each client's own documented format for a remote server.

Clients with OAuth support can add the same URL as a connector and sign in without putting a key in a config file.

claude mcp add --transport http google-scholar "https://mcp.hasdata.com/api/mcp?apis=google_scholar" \
  --header "x-api-key: HASDATA_API_KEY"

Settings, then Connectors, then Add custom connector, then paste https://mcp.hasdata.com/api/mcp?apis=google_scholar and sign in.

For the config-file route, Claude Desktop loads only local (stdio) servers, so it reaches a remote server through a stdio launcher. The @hasdata/google-scholar-mcp package is that launcher, and it reads the key from the environment. Add this to claude_desktop_config.json:

{
  "mcpServers": {
    "google-scholar": {
      "command": "npx",
      "args": ["-y", "@hasdata/google-scholar-mcp"],
      "env": { "HASDATA_API_KEY": "YOUR_KEY" }
    }
  }
}

For Python instead of Node, swap the launcher for the PyPI package, which uvx runs without a manual install:

{
  "mcpServers": {
    "google-scholar": {
      "command": "uvx",
      "args": ["hasdata-google-scholar-mcp"],
      "env": { "HASDATA_API_KEY": "YOUR_KEY" }
    }
  }
}

~/.cursor/mcp.json for every project, or .cursor/mcp.json for one:

{
  "mcpServers": {
    "google-scholar": {
      "url": "https://mcp.hasdata.com/api/mcp?apis=google_scholar",
      "headers": { "x-api-key": "HASDATA_API_KEY" }
    }
  }
}

~/.codeium/windsurf/mcp_config.json. Windsurf calls the field serverUrl, not url:

{
  "mcpServers": {
    "google-scholar": {
      "serverUrl": "https://mcp.hasdata.com/api/mcp?apis=google_scholar",
      "headers": { "x-api-key": "HASDATA_API_KEY" }
    }
  }
}

.vscode/mcp.json in the workspace:

{
  "servers": {
    "google-scholar": {
      "type": "http",
      "url": "https://mcp.hasdata.com/api/mcp?apis=google_scholar",
      "headers": { "x-api-key": "HASDATA_API_KEY" }
    }
  }
}

Example prompts

Each of these lands on one tool, or on two in sequence when the second needs an id the first returns.

• Find papers on transformer architectures published since 2023 and sort them by citation count.

• Who has cited this paper, and how has that grown year on year?

• Give me the BibTeX for this paper.

• Find review articles only on this topic, excluding citations without full records.

• Show me every indexed version of this paper and which of them have a PDF.

• Find recent work by this author on this topic.

A prompt naming a paper takes two calls, one search to reach its resultId and one citation lookup. A prompt about who cites a paper also takes two, because the second call reuses citedBy.citesId from the first.

Tools

Two tools, 10 credits per successful call.

Get Scholar search results

hasdata_google_scholar_scholar_getScholarSearchResults

A page of Scholar results.

Returns searchInformation with totalResults, queryDisplayed and the time Scholar reported, an organicResults array, and pagination.

Each result carries position, resultId, title, link, snippet, a publicationInfo object, a resources array, citedBy, versions, relatedPagesLink and citeHasdataLink.

publicationInfo.authors is the part worth knowing about. Alongside the raw summary line it lists the authors Scholar has profiles for, each with a name, a profile link and an authorId, which is how you follow one author rather than parsing a byline.

citedBy and versions are the two ids that make this tool compose with itself. citedBy.citesId goes back into cites to walk a citation graph, and versions.clusterId goes into cluster to see every indexed copy of the same paper.

{
  "position": 1,
  "resultId": "A7L9JolPKkoJ",
  "title": "A historical survey of advances in transformer architectures",
  "link": "https://www.mdpi.com/2076-3417/14/10/4316",
  "snippet": "… of the Vision Transformer (ViT) opening a new realm of architectures which build … transformer architecture, it becomes pertinent to examine in detail the architecture of the transformer …",
  "publicationInfo": {
    "summary": "AR Sajun, I Zualkernan, D Sankalpa - Applied Sciences, 2024 - mdpi.com",
    "authors": [
      { "name": "AR Sajun", "authorId": "k6zWX4EAAAAJ", "link": "https://scholar.google.com/citations?user=k6zWX4EAAAAJ&hl=en" }
    ]
  },
  "resources": [{ "fileFormat": "Html", "title": "mdpi.com", "link": "https://www.mdpi.com/2076-3417/14/10/4316" }],
  "citedBy": { "total": 97, "citesId": "5344171358311789059" },
  "versions": { "total": 7, "clusterId": "5344171358311789059" }
}

Get Scholar citation formats

hasdata_google_scholar_cite_getScholarCitationFormats

The citation block for one paper.

Returns citations, the formatted string in MLA, APA, Chicago, Harvard and Vancouver, and links, the export URLs for BibTeX, EndNote, RefMan and RefWorks.

{
  "citations": [
    {
      "title": "APA",
      "snippet": "Sajun, A. R., Zualkernan, I., & Sankalpa, D. (2024). A historical survey of advances in transformer architectures. Applied Sciences, 14(10), 4316."
    }
  ],
  "links": [
    { "name": "BibTeX", "link": "https://scholar.googleusercontent.com/scholar.bib?q=info:A7L9JolPKkoJ:scholar.google.com/&output=citation..." }
  ]
}

Errors and failure paths

Plan for these rather than assuming a happy path.

On the citation tool, q is a paper id rather than a query. It takes the resultId from a search result, such as A7L9JolPKkoJ. Passing a title or a DOI there returns nothing useful, and the shared parameter name is the reason people get this wrong.

citesId and clusterId can hold the same value, and they are not interchangeable. They were identical on the paper above. One goes into cites to find papers citing this one, the other into cluster to find copies of this one. Sending the right number to the wrong parameter returns a plausible page of the wrong thing.

type arrives on some results and not others. It was present on one result in five, describing the format of the primary resource. Read resources[].fileFormat when you need to know whether a PDF exists.

A BibTeX link is a Scholar URL with a signature in it, not the BibTeX itself. The links array gives you addresses to fetch, and those carry expiring scisig tokens, so fetch them promptly rather than storing them for later.

totalResults is Scholar's estimate and it is very rough. The query above reported 2,080,000. Treat it as an order of magnitude, never as a count.

Scholar counts citations, not quality, and it indexes preprints, theses and citing-only records. asVis: 1 drops citation-only entries when you need records with full metadata.

Paging deep gets thin. Scholar limits how far a result set goes and starts repeating or blocking well before the estimate suggests, so narrow with asYlo, asYhi or asSdt rather than walking start upward.

Results that carry data also carry a requestMetadata.id worth quoting in support.

Pricing, free tier and limits

Each Scholar tool costs 10 credits per successful call. Response size does not change the price, so raising num is the cheap way to widen a search.

The free tier is 1,000 credits every month with no card, which is 100 Scholar calls at the base rate. It renews with the billing cycle, so a low-volume agent runs on the free tier indefinitely.

Paid plans start at $49 a month for 200,000 credits, which is 20,000 calls. The unit price falls with volume, from $2.45 per 1,000 calls on the entry plan to $1.00 on Business, $0.84 on Growth and $0.74 on the largest high-volume plans.

Your plan also sets concurrency. The free tier allows 1 request at a time, Startup 15, Business 30, Growth 50, and the high-volume plans run from 200 to 1,500. Retry on the 429 with a backoff in anything unattended, because an agent that walks a citation graph will reach the ceiling before you do.

A request that comes back non-200 is not billed. A successful call that finds nothing is still a call.

Tool selection

Start from what the prompt gives you. A topic, an author or a year range goes to the search tool. A resultId you already hold goes straight to the citation tool.

Then think about which id the next step needs. A literature sweep is one search call with a large num. A citation graph is a search call followed by one cites call per paper you follow. A deduplication pass across preprints and published versions is a cluster call per paper. Each of those reuses an id the first response already gave you, so a second search call is usually wasted.

Raise num before you page. Cost is per call rather than per result, so one wide page beats three narrow ones.

How it compares

Google Scholar has no public API, so the comparison worth making is against the open bibliographic APIs.

The row that decides it is whose citation count you need. For bibliometrics on typed, stable metadata, OpenAlex and Semantic Scholar are better instruments and they are free. Reach for this one when the question is specifically about what Google Scholar shows, which is what most researchers actually look at, or when you want the formatted citation rather than the fields to build one.

FAQ

Is there an official Google Scholar MCP server?

Google does not publish one, and Scholar has no public API either. This one is maintained by HasData and reads public Scholar pages.

What is a Google Scholar MCP server?

An MCP server exposes tools an AI client can call. This one turns Scholar search results and citation blocks into JSON an agent can reason over, without a browser or a scraping library in your stack.

Do I need a Google account?

No. The only credential is your HasData key.

How do I get the BibTeX for a paper?

Two calls. Search to get the paper's resultId, then pass that id as q to the citation tool, and take the BibTeX URL from links.

How do I find everything that cites a paper?

Take citedBy.citesId from the search result and send it back as the cites parameter. The response is the citing papers, paged like any other search.

What is the difference between cites and cluster?

cites finds papers that cite the one you named. cluster finds other indexed versions of that same paper, such as a preprint next to the published article. The two ids often look identical, so pick by what you want rather than by the number.

Can I search by author?

Yes, with Scholar's own operator, as author:"J Dean" in q. Search results also carry authorId for authors with a Scholar profile, which is the stabler handle.

Can I use this together with other HasData APIs?

Yes. One key covers everything, and one endpoint serves them all through the apis parameter. Point a client at ?apis=google_scholar,google_serp to get both tool sets in one connection, or at mcp.hasdata.com/api/mcp for the full catalogue.

Is HasData affiliated with Google?

No. HasData is an independent service and is not affiliated with, endorsed by, or sponsored by Google. Google Scholar is a trademark of its respective owner. The tools work with publicly available data only, and you are responsible for using the results in line with Google's terms and the law that applies to you.

Compliance and personal data

Author names, affiliations and Scholar profile ids are personal data, even though they are published as part of the scholarly record. Building a profile of one researcher's output is a different act from counting citations on a topic, and it is the one that needs a second thought about purpose and retention. The papers themselves stay under their own licences, so a link is not permission to redistribute a PDF.

HasData links

• Google Scholar API documentation, the REST endpoints behind these tools

• Citation formats endpoint

• MCP server documentation

• Pricing

• Dashboard

Other HasData MCP servers: Google Search, Google Images, Google Maps, Google Trends, Bing, DuckDuckGo, YouTube, TikTok, Instagram, Amazon, Walmart, Shopify, Yelp, Yellow Pages, Zillow, Redfin, Airbnb, Booking.com, Indeed, Glassdoor.

Development

The launcher is a thin stdio bridge to the remote server, so there is nothing to build.

npm install
HASDATA_API_KEY=your_key_here npm test

The tests in test/ assert the tool contract, the part that can break without a commit here. They check that ?apis=google_scholar returns the two expected tools, that no name changed, that both still require q and carry descriptions, that the search parameters this README documents are still in the schema, and that the key in use is actually accepted.

Two tests go further. One asserts that a live search still returns resultId, citedBy.citesId and versions.clusterId, because those three ids are what let the tools compose and nothing else in the response would reveal their loss. The other feeds a resultId straight into the citation tool, which is the two-call workflow this README documents, and checks the five styles come back. Together they cost 20 credits a run, which is the price of a canary that can fail for the right reason.

The contract suite also runs weekly on a schedule, because the upstream tool list can change without anyone touching this repository.

Contributing

A tool table, a response sample or a documented behaviour that does not match reality is worth an issue. There is a template for exactly that. Pull requests are welcome for the same, and for anything in the launcher.

License

MIT, see LICENSE.