Semantic Scholar Scraper

Pricing

Pay per event

Try for free

Go to Apify Store

Semantic Scholar Scraper

Try for free

Extract detailed academic paper data from Semantic Scholar, including abstracts, citations, authors, and publication details. Ideal for researchers, academics, and analysts who need structured scholarly data for literature reviews, research workflows, and large-scale academic analysis.

Pricing

Pay per event

Rating

5.0

(1)

Developer

ParseForge

Maintained by Community

Actor stats

Bookmarked

Total users

Monthly active users

3 days ago

Last modified

Categories

Automation

Developer tools

Other

You can access the Semantic Scholar Scraper programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in Integrations settings in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "1.0",
    "x-build-id": "87ts2PU9zg6Zbgu3d"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/parseforge~semantic-scholar-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-parseforge-semantic-scholar-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/parseforge~semantic-scholar-scraper/runs": {
      "post": {
        "operationId": "runs-sync-parseforge-semantic-scholar-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/parseforge~semantic-scholar-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-parseforge-semantic-scholar-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": {
          "startUrl": {
            "title": "Start URL",
            "type": "string",
            "description": "Semantic Scholar search URL to start scraping from. Use this for custom searches with specific filters. Cannot be used together with searchQuery or other API filters. Example: https://www.semanticscholar.org/search?q=machine+learning&sort=relevance"
          },
          "searchQuery": {
            "title": "Search Query",
            "type": "string",
            "description": "Search query to find papers on Semantic Scholar. Examples: 'machine learning', 'neural networks', 'quantum computing'. Required if startUrl is not provided."
          },
          "yearMin": {
            "title": "Minimum Year",
            "minimum": 1900,
            "maximum": 2100,
            "type": "integer",
            "description": "Filter papers published on or after this year. Example: 2020"
          },
          "yearMax": {
            "title": "Maximum Year",
            "minimum": 1900,
            "maximum": 2100,
            "type": "integer",
            "description": "Filter papers published on or before this year. Example: 2024"
          },
          "hasPdf": {
            "title": "Has PDF",
            "type": "boolean",
            "description": "Only include papers that have an open access PDF available.",
            "default": false
          },
          "maxItems": {
            "title": "Max Items",
            "minimum": 1,
            "maximum": 1000000,
            "type": "integer",
            "description": "Maximum number of papers to collect (up to 1,000,000). Leave empty for unlimited."
          },
          "author": {
            "title": "Author",
            "type": "string",
            "description": "Filter papers by author name. Note: This is treated as a suggestion by the Semantic Scholar API, not a strict filter. Results may include papers that match the search query but may not have the specified author. Example: 'John Smith'"
          },
          "venues": {
            "title": "Venues",
            "type": "string",
            "description": "Filter papers by publication venue (journal or conference). Note: This is treated as a suggestion by the Semantic Scholar API, not a strict filter. Results may include papers that match the search query but may not match the specified venue. Example: 'Nature', 'IEEE'"
          }
        }
      },
      "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
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Semantic Scholar Scraper OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Semantic Scholar Scraper from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Semantic Scholar Scraper API in Python

Semantic Scholar Scraper API in JavaScript

Semantic Scholar Scraper API through CLI

Semantic Scholar Scraper API

Semantic Scholar Search Scraper

powerai/semantic-scholar-search-scraper

Scrape academic papers from Semantic Scholar by keyword search, with automatic pagination and comprehensive research data extraction.

PowerAI

5.0

(1)

Researchgpt Deep Research Agent

wheat_tourist/researchgpt-deep-research-agent

🔬 Transform any topic into a comprehensive research report in minutes! Scrapes Wikipedia, arXiv, Semantic Scholar, news & web sources. Outputs professional JSON, HTML & PDF reports. Perfect for students, researchers, content creators & businesses. No API keys needed.

Varun Chopra

Education & Research Email Scraper – Cheap & Advanced 🎓📧

scrapestorm/education-research-email-scraper---cheap-advanced

🔍 Scrape Education & Research Emails Easily Enter your search parameters (e.g. academic title, email domains & platform) to collect verified academic or institutional contacts along with role title, research snippet & more 📊 Perfect for academic outreach & education database enrichment 🧩

Storm_Scraper

5.0

(1)

YouTube Most Replayed Scraper (Heatmap extractor)

karamelo/youtube-most-replayed-scraper-heatmap-extractor

Extract 1 or 1000s of YouTube Most Replayed heatmap parts of videos fast. Save time & effort. Get detailed normalized graphs with coordinates, timestamps. Extremely useful for creators for identifying viral content, marketers, researchers... Export in various formats, JSON, HTML, CSV, EXCEL...

karamelo

220

Google Scholar Scraper

easyapi/google-scholar-scraper

Powerful Google Scholar scraper collect up to 5000 scholarly results per run with flexible search options, citation filtering. Perfect for academic research, bibliometric analysis, and scientific trend tracking. 🎓🔍

EasyApi

264

5.0

(2)

Google Scholar Scraper

marco.gullo/google-scholar-scraper

Scrape publication details from scholar.google.com. Add your query, time range, and optionally document type (PDF or HTML only). Extract information about articles such as titles, authors, links, related articles, and more.

Marco Gullo

1.4K

4.9

(5)

Google Scholar Search Scraper

ecomscrape/google-scholar-search-scraper

Extract comprehensive academic data from Google Scholar including research papers, citations, author information, and PDF links. Automate your literature review process with advanced scraping capabilities for researchers and academics.

ecomscrape

1.0

(1)

Web Crawler & Semantic Schema-Enhanced Extractor

devil_port369-owner/web-crawler

Depth-controlled web crawler that transforms websites into structured analytics-ready data. Starting from one or more URLs, it crawls internal links up to a configurable depth and outputs detailed JSON records per page

DataFusionX

5.0

(7)

Google Scholar Scraper: Cheap & Affordable (Rental) 📚⚡

scrapestorm/google-scholar-scraper-cheap-affordable-rental

Unlock the potential of the Google Scholar scraper tool! 📚✨ Easily collect academic papers based on your chosen keyword or research topic 🔍. Get essential details like the title 📝, author(s) 🖋️, publication date ⏰, journal/source 🌐, and direct links to full texts 🔗—ideal for researchers ! 🚀

Storm_Scraper

5.0

(1)

Google Scholar Article Scraper

agenscrape/google-scholar-article-scraper

Extract academic articles, citations, authors, and publication data from Google Scholar. Perfect for research analysis and literature reviews with fast, reliable scraping.