# DBLP Scraper — Publications, Authors & Venues (`logiover/dblp-scraper`) Actor Scrape DBLP computer science bibliography by keyword or author. Extract titles, authors, venues, years, DOIs, and URLs for publications, authors, and venues. No API key, no login. - **URL**: https://apify.com/logiover/dblp-scraper.md - **Developed by:** [Logiover](https://apify.com/logiover) (community) - **Categories:** Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 1,000 results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## DBLP Scraper — Publications, Authors & Venues The fastest way to extract structured computer science research data from DBLP, the largest open bibliography of CS publications — no API key, no login, no rate-limit headaches. ### What does DBLP Scraper do? DBLP Scraper queries the official DBLP search API (`dblp.org/search/publ/api`, `/author/api`, `/venue/api`) in bulk using keyword or phrase queries, then paginates the results automatically in pages of up to 1,000 records. It operates in three distinct modes: **publications** (papers, conference proceedings, journal articles), **authors** (researcher profiles with affiliations and awards), and **venues** (conferences and journals). All endpoints return JSON natively — no HTML parsing, no browser required. A single run on a broad query such as "deep learning" can return tens of thousands of paper records covering titles, author lists, venue names, publication years, DOIs, electronic edition links, DBLP keys, page ranges, and volume numbers. The actor uses Apify's datacenter proxy pool for resilience and retries automatically on transient network errors. ### Who is it for? - **Academic researchers** who need bulk publication data for meta-analysis, citation network studies, or bibliometrics. - **Data scientists and ML engineers** building datasets of CS papers for training or benchmarking. - **Tech intelligence analysts** tracking research trends, prolific authors, or dominant venues in specific subfields. - **University librarians and knowledge managers** assembling curated reading lists or institution-level publication inventories. - **Competitive intelligence teams** monitoring how often companies or labs appear in academic literature. ### Use cases - Build a dataset of all neural-network papers published in the last decade for a systematic literature review. - Extract the full publication list of a specific researcher (e.g., "Yann LeCun") to map their career output. - Identify the top venues (conferences/journals) in a niche like "federated learning" or "quantum computing". - Feed paper titles and DOIs into an LLM pipeline that summarizes or clusters research trends. - Track how many papers mention a specific technology keyword year-over-year. ### Why use DBLP Scraper? - **Completely keyless** — uses the official public DBLP API, no account or token required. - **13 output fields** per publication: title, authors, venue, year, type, DOI, ee URL, DBLP key, pages, volume, URL, open-access flag, mode. - **Bulk pagination** — retrieves up to 10,000+ records per run by paginating DBLP's 1,000-per-page API automatically. - **Three search modes** — publications, authors, venues — all in one actor. - **Export to CSV, JSON, or Excel** — all Apify storage formats supported out of the box. - **Pay-per-result pricing** — you only pay for what you actually extract. ### What data can you extract? Each record from a **publications** search returns: | Field | Type | Description | |---|---|---| | `title` | string | Full paper title | | `authors` | string | Comma-separated list of author names | | `venue` | string | Conference name or journal title | | `year` | string | Publication year (e.g., "2023") | | `type` | string | Record type: "Journal Articles", "Conference and Workshop Papers", etc. | | `doi` | string | Digital Object Identifier (e.g., "10.1016/j.neunet.2023.10.057") | | `ee` | string | Electronic edition URL (full-text link, often open access) | | `key` | string | DBLP internal key (e.g., "journals/nn/Smith24") | | `pages` | string | Page range (e.g., "1-15") | | `volume` | string | Journal volume number | | `url` | string | DBLP record URL | | `access` | string | Open access status ("open" or empty) | | `mode` | string | The mode used for this run | **Example output record (publications mode):** ```json { "title": "An exact mapping from ReLU networks to spiking neural networks", "authors": "Ana Stanojevic, Stanislaw Wozniak, Guillaume Bellec, Giovanni Cherubini, Angeliki Pantazi, Wulfram Gerstner", "venue": "Neural Networks", "year": "2024", "type": "Journal Articles", "doi": "10.1016/J.NEUNET.2023.10.057", "ee": "https://doi.org/10.1016/j.neunet.2023.10.057", "key": "journals/nn/StanojevicWBCPG24", "pages": "622", "volume": "169", "url": "https://dblp.org/rec/journals/nn/StanojevicWBCPG24", "access": "open", "mode": "publications" } ```` For **authors** mode, `title`/`authors` hold the researcher name, `venue` holds affiliations, and `volume` holds awards (e.g., "Turing Award"). For **venues** mode, `title`/`venue` hold the venue name, `key`/`volume` hold the acronym, and `url` links to the DBLP venue page. ### How to use #### Option A — Search publications by keyword 1. Open the actor and set **Mode** to `publications`. 2. Enter your **Search Query** (e.g., `"transformer attention mechanism"`). 3. Set **Max Results** (e.g., 1000 for a broad search). 4. Click **Start**. ```json { "mode": "publications", "query": "transformer attention mechanism", "maxResults": 1000, "proxyConfiguration": { "useApifyProxy": true } } ``` #### Option B — Search authors or venues 1. Set **Mode** to `authors` or `venues`. 2. Enter your query (e.g., `"Geoffrey Hinton"` for authors, `"ICML"` for venues). 3. Set **Max Results**. 4. Click **Start**. ```json { "mode": "authors", "query": "Yoshua Bengio", "maxResults": 50, "proxyConfiguration": { "useApifyProxy": true } } ``` ### Input parameters | Parameter | Type | Default | Description | |---|---|---|---| | `mode` | string | `"publications"` | Search mode: `publications`, `authors`, or `venues` | | `query` | string | *(required)* | Keyword or phrase to search on DBLP | | `maxResults` | integer | `500` | Maximum number of results to retrieve (1–10,000) | | `proxyConfiguration` | object | Apify proxy | Proxy settings; datacenter proxies work fine | **Full input example:** ```json { "mode": "publications", "query": "federated learning privacy", "maxResults": 2000, "proxyConfiguration": { "useApifyProxy": true } } ``` ### Output example ```json { "title": "Communication-Efficient Learning of Deep Networks from Decentralized Data", "authors": "H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, Blaise Agüera y Arcas", "venue": "AISTATS", "year": "2017", "type": "Conference and Workshop Papers", "doi": "10.48550/arXiv.1602.05629", "ee": "http://proceedings.mlr.press/v54/mcmahan17a.html", "key": "conf/aistats/McMahanMRHA17", "pages": "1273-1282", "volume": "54", "url": "https://dblp.org/rec/conf/aistats/McMahanMRHA17", "access": "open", "mode": "publications" } ``` ### Tips for best results - **Use specific multi-word queries** like `"graph neural network node classification"` rather than just `"graph"` to get relevant results faster. - **DBLP wildcards are automatic** — the API adds `*` to your terms internally, so `"neural network"` matches "neural networks", "neural networking", etc. - **Start with maxResults 500** to validate your query, then scale to 5,000+ for comprehensive sweeps. - **Use author mode for people searches** — searching `"Yann LeCun"` in publications mode finds all papers; switching to authors mode returns the researcher profile with affiliations. - **Check the `access` field** — records marked `"open"` have free full-text available at the `ee` URL. - **Use the `key` field for deduplication** — DBLP keys are unique identifiers per record and stable across time. - **Venues mode is great for discovery** — search a topic abbreviation like `"NeurIPS"` or `"CVPR"` to get the official venue metadata. - **Combine with Apify schedules** — run weekly on a query like `"large language models"` to track the latest papers automatically. - **Export to Excel** from the dataset view to get a spreadsheet you can filter by year or venue immediately. - **For institution-level analysis**, run multiple author-mode queries for names associated with a university and aggregate by affiliation. ### Integrations - **Google Sheets** — use Apify's Google Sheets integration to push results directly to a spreadsheet for collaborative review. - **Slack** — configure a webhook to receive a Slack notification with a run summary when the actor finishes. - **Zapier / Make** — trigger downstream workflows (e.g., add papers to a Notion database) via Apify webhooks. - **Schedule** — use Apify Scheduler to run the actor daily or weekly on a saved query and accumulate a growing dataset. - **API / SDK** — call the actor programmatically and pipe results into your own data pipeline. ### API usage **cURL:** ```bash curl -X POST \ "https://api.apify.com/v2/acts/logiover~dblp-scraper/runs?token=YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"mode":"publications","query":"neural networks","maxResults":500}' ``` **Node.js:** ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_TOKEN' }); const run = await client.actor('logiover/dblp-scraper').call({ mode: 'publications', query: 'neural networks', maxResults: 500, }); const dataset = await client.dataset(run.defaultDatasetId).listItems(); console.log(dataset.items); ``` **Python:** ```python from apify_client import ApifyClient client = ApifyClient("YOUR_TOKEN") run = client.actor("logiover/dblp-scraper").call(run_input={ "mode": "publications", "query": "neural networks", "maxResults": 500, }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["title"], item["year"]) ``` ### Use with AI agents (MCP) DBLP Scraper is available via the Apify MCP server, so any Claude or GPT-based agent can call it directly. Example prompt: *"Use the DBLP scraper to find the 200 most recent papers on 'graph attention networks' and summarize the top 10 by citation impact."* The agent will invoke the actor, retrieve results, and synthesize findings without any manual steps. ### FAQ #### Does this actor require an API key or login? No. DBLP provides its search API completely publicly. You do not need a DBLP account, API key, or any credentials. The actor works out of the box. #### How many results can I retrieve in a single run? DBLP reports up to 112,000+ results for broad queries like "neural networks". The actor paginates automatically. Set `maxResults` up to 10,000 and the actor will page through DBLP's 1,000-per-request API until your limit is reached or results are exhausted. #### What publication types does DBLP cover? DBLP indexes journal articles, conference and workshop papers, books, book chapters, editorials, theses, and informal publications (e.g., arXiv preprints). The `type` field in each record tells you exactly what you're looking at. #### Why am I getting zero results? Check your query spelling. DBLP adds wildcards automatically so short common terms usually return results. If you search a very specific phrase with rare terms, try broadening it. Also confirm `mode` matches what you're looking for — searching an author name in `publications` mode finds their papers, while `authors` mode finds their profile. #### Some fields are empty — is that normal? Yes. Not every paper has a DOI, page numbers, or volume (especially arXiv preprints and informal papers). The `ee` field (electronic edition URL) is the most reliable link to the actual paper. #### Can I export results to Excel? Yes. After a run completes, open the dataset in the Apify UI and click "Export" to download CSV, JSON, XLSX, or XML. You can also use the Apify API to retrieve results programmatically in any format. #### How fast does the actor run? For 500 results it typically completes in under 30 seconds. For 5,000 results expect 2–5 minutes. DBLP's API is fast and stable; most of the time is network latency and Apify's proxy routing. #### Is DBLP data always up to date? DBLP updates continuously as publishers submit new records. In practice, papers appear in DBLP within days to weeks of publication. For the very latest preprints, also query the arXiv API directly. #### How often should I re-run for fresh data? For active research areas, weekly runs will capture new publications. For stable historical queries (e.g., "Hinton papers before 2010"), a single run is sufficient as the data rarely changes. #### Can I scrape a specific author's full publication list? Use `mode: "publications"` with the author's name as the query (e.g., `"Yann LeCun"`). DBLP's search matches author names precisely. For disambiguation, add a co-author or institution keyword. #### What is the DBLP key field? The DBLP key is a stable, unique identifier for each record, structured as `type/venue/AuthorYear` (e.g., `journals/nn/Smith24`). Use it to deduplicate results across multiple runs or to construct direct DBLP record URLs. #### Is there a related actor for Google Scholar or Semantic Scholar? Yes — check out the other actors in the Logiover store for academic data sources. DBLP focuses on computer science; for broader academic search you may want to combine it with specialized scrapers for other databases. ### Is it legal? DBLP is a public, open-access bibliography service operated by Schloss Dagstuhl. Its search API is documented and publicly accessible without authentication. Scraping publicly available metadata for research, analysis, and non-commercial use is generally considered lawful under standard fair-use and database-use principles. This actor does not bypass any access controls, does not scrape full paper texts (only metadata), and respects DBLP's server resources via polite request pacing. Always review DBLP's terms of service and your jurisdiction's data regulations before using the output commercially. ### Related scrapers - **[Logiover GitHub Activity Scraper](https://apify.com/logiover/github-activity-scraper)** — track open source contributions alongside academic output. - **[Logiover CVE Advisory Scraper](https://apify.com/logiover/cve-advisory-scraper)** — monitor security vulnerabilities for tech stacks identified in research papers. - **[Logiover CT Monitor](https://apify.com/logiover/ct-monitor)** — certificate transparency monitoring for domains mentioned in CS research. # Actor input Schema ## `mode` (type: `string`): What to search: 'publications' for papers, 'authors' for researcher profiles, 'venues' for conferences/journals. ## `query` (type: `string`): Keyword or phrase to search for. Examples: 'neural networks', 'deep learning', 'Yann LeCun'. Leave empty to browse a broad popular slice of the bibliography. ## `maxResults` (type: `integer`): Maximum number of results to retrieve. The actor paginates automatically (100 per DBLP request). ## `proxyConfiguration` (type: `object`): Apify proxy settings. Uses automatic proxy selection by default, with a direct-connection fallback for this clean public API. ## Actor input object example ```json { "mode": "publications", "maxResults": 500, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `results` (type: `string`): All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("logiover/dblp-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "proxyConfiguration": { "useApifyProxy": True } } # Run the Actor and wait for it to finish run = client.actor("logiover/dblp-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "proxyConfiguration": { "useApifyProxy": true } }' | apify call logiover/dblp-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=logiover/dblp-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "DBLP Scraper — Publications, Authors & Venues", "description": "Scrape DBLP computer science bibliography by keyword or author. Extract titles, authors, venues, years, DOIs, and URLs for publications, authors, and venues. No API key, no login.", "version": "1.0", "x-build-id": "s4DlWTp1VKkbgDZ1d" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/logiover~dblp-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-logiover-dblp-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/logiover~dblp-scraper/runs": { "post": { "operationId": "runs-sync-logiover-dblp-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/logiover~dblp-scraper/run-sync": { "post": { "operationId": "run-sync-logiover-dblp-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "mode": { "title": "Mode", "enum": [ "publications", "authors", "venues" ], "type": "string", "description": "What to search: 'publications' for papers, 'authors' for researcher profiles, 'venues' for conferences/journals.", "default": "publications" }, "query": { "title": "Search Query", "type": "string", "description": "Keyword or phrase to search for. Examples: 'neural networks', 'deep learning', 'Yann LeCun'. Leave empty to browse a broad popular slice of the bibliography." }, "maxResults": { "title": "Max Results", "minimum": 1, "maximum": 10000, "type": "integer", "description": "Maximum number of results to retrieve. The actor paginates automatically (100 per DBLP request).", "default": 500 }, "proxyConfiguration": { "title": "Proxy Configuration", "type": "object", "description": "Apify proxy settings. Uses automatic proxy selection by default, with a direct-connection fallback for this clean public API.", "default": { "useApifyProxy": true } } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```