# Gem India Government Emarketplace Bids Scraper (`jungle_synthesizer/gem-india-government-emarketplace-bids-scraper`) Actor

Government e-Marketplace (GeM) is India's mandatory central procurement portal — every

- **URL**: https://apify.com/jungle\_synthesizer/gem-india-government-emarketplace-bids-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 record scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## GeM India Government e-Marketplace Bids Scraper

Scrape live and historical procurement bids from [GeM (Government e-Marketplace)](https://gem.gov.in), India's mandatory central procurement portal for every central and state government department. This actor pulls bid number, title, category, department and ministry attribution, quantity, bid type, rate-contract and global-tendering/single-packet flags, evaluation stage, and the bid's document PDF URL — structured and ready for export to JSON or CSV.

GeM is the single largest government e-marketplace in Asia by transaction volume. At the time of writing the live "Ongoing" bid board alone carries roughly 49,000 open bids, with millions more in the historical technical-evaluation, financial-evaluation and awarded stages.

### What Data This Scraper Extracts

| Field | Description |
|---|---|
| `bid_id` | GeM's internal numeric bid id |
| `bid_number` | Public bid/RA reference (e.g. `GEM/2026/B/7800616`) |
| `bid_url` | Direct URL to the bid's document PDF |
| `title` | Bid title / item description |
| `category_name` | Product/service category as published |
| `detail_category_name` | Detailed category label |
| `department_name` | Purchasing department |
| `ministry` | Purchasing ministry |
| `buyer_organisation` | Buying organisation |
| `total_quantity` | Quantity being procured |
| `estimated_value` | Bid value — GeM only publishes this inside the bid's own document, not on the listing; `null` when not present |
| `bid_type` | `BID` or `RA` (reverse auction) |
| `evaluation_type` | Source evaluation-method code |
| `is_global_tendering` | Whether the bid is open to global tendering |
| `is_single_packet` | Whether the bid uses single-packet submission |
| `is_high_value` | Whether GeM flags the bid as high-value |
| `is_rc_bid` | Whether this is a rate-contract bid |
| `status` | `ongoing`, `technical_evaluation`, `financial_evaluation`, or `awarded` |
| `start_date` | Bid start date/time |
| `end_date` | Bid end date/time |
| `document_urls` | Downloadable bid/RA document PDF URL(s) |
| `scraped_at` | ISO 8601 timestamp of when the record was scraped |

### Input Parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `maxItems` | integer | `10` | Maximum number of bids to collect |
| `bidStatus` | array | all four | Which bid-lifecycle bucket(s) to crawl: `ongoing` (live/open), `technicalEvaluation`, `financialEvaluation`, `awarded` (historical). Omit to cover the full corpus. |
| `searchKeyword` | string | — | Optional free-text keyword to filter bids by title/category |

#### Example Inputs

Scrape 50 live bids:

```json
{
  "maxItems": 50,
  "bidStatus": ["ongoing"]
}
```

Pull recently awarded bids for win-rate analysis:

```json
{
  "maxItems": 200,
  "bidStatus": ["awarded"]
}
```

Search for a specific product category across every bid stage:

```json
{
  "maxItems": 100,
  "searchKeyword": "battery"
}
```

### Sample Output

```json
{
  "bid_id": "9721998",
  "bid_number": "GEM/2026/R/712422",
  "bid_url": "https://bidplus.gem.gov.in/showradocumentPdf/9721998",
  "title": "011186 Losartan 25 mg Tab",
  "category_name": "011186 Losartan 25 mg Tab",
  "detail_category_name": "011186 Losartan 25 mg Tab",
  "department_name": "Department of Defence",
  "ministry": "Ministry of Defence",
  "buyer_organisation": "Department of Defence",
  "total_quantity": 2100000,
  "estimated_value": null,
  "bid_type": "RA",
  "evaluation_type": "0",
  "is_global_tendering": false,
  "is_single_packet": false,
  "is_high_value": false,
  "is_rc_bid": false,
  "status": "ongoing",
  "start_date": "2026-08-08T10:00:00.000Z",
  "end_date": "2026-08-10T10:09:13.000Z",
  "document_urls": ["https://bidplus.gem.gov.in/showradocumentPdf/9721998"],
  "scraped_at": "2026-08-10T04:38:50.516Z"
}
```

### Who Uses GeM Bid Data

- **Suppliers and manufacturers** — monitor new procurement opportunities across every central and state department before the bid closes
- **Business development teams** — identify which government departments and ministries are actively buying in your product category
- **Export and trading companies** — track global-tendering and rate-contract bids that are open to non-domestic suppliers
- **Market research and consulting** — analyze department/ministry spend patterns and category demand across India's public sector
- **Procurement intelligence** — pull awarded and evaluation-stage bids to study historical win rates and competitor activity, not just live alerts

### Pricing

This actor uses pay-per-event (PPE) pricing:

- **$0.10** per actor start
- **$0.002** per bid record saved

A run collecting 100 bids costs approximately $0.30 total.

### Frequently Asked Questions

**How do I scrape GeM government bids?**
Run this actor with your desired `maxItems` and `bidStatus`. Results export as JSON, CSV, or via the Apify API.

**How many bids are on GeM?**
Roughly 49,000 live "Ongoing" bids at any given time, with several million more historical bids across the technical-evaluation, financial-evaluation and awarded stages. Set `bidStatus` to the stage(s) you need, or omit it to cover the full corpus.

**Can I get closed or awarded GeM bids, not just live ones?**
Yes. Set `bidStatus` to `technicalEvaluation`, `financialEvaluation`, or `awarded` — this actor covers the full bid lifecycle, not just the live board.

**Does this include the bid value / EMD amount?**
GeM does not publish bid value on the public bid board — it's only available inside the bid's own PDF document, which this actor links to via `document_urls`. `estimated_value` is emitted as `null` rather than an inaccurate guess.

**How often should I run the scraper for fresh data?**
For continuous opportunity monitoring, run daily. GeM does not provide a public change feed, so re-scraping the live bid board is the standard approach.

**Is there a GeM API for bid alerts?**
GeM does not publish a public bid API or alert feed. This actor is the closest equivalent: schedule it on Apify to re-scrape the bid board daily and pull results via the Apify API into your own alert or monitoring pipeline.

***

Need a custom filter, additional fields, or a scheduled pipeline? Get in touch.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

What will this data feed? E.g. lead lists, KYB checks, price tracking.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

We'll personally help with your use case. No spam.

## `maxItems` (type: `integer`):

Maximum number of records to scrape

## `bidStatus` (type: `array`):

Which GeM bid-lifecycle bucket(s) to crawl. Ongoing = live/open bids. The other three are historical Bid/RA-Award-process stages. Omitted = all four (the full corpus).

## `searchKeyword` (type: `string`):

Optional free-text keyword to filter bids by title/category (matches GeMs own full-text search box). Leave blank to crawl unfiltered.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10,
  "bidStatus": [
    "ongoing",
    "technicalEvaluation",
    "financialEvaluation",
    "awarded"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/gem-india-government-emarketplace-bids-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/gem-india-government-emarketplace-bids-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10
}' |
apify call jungle_synthesizer/gem-india-government-emarketplace-bids-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_synthesizer/gem-india-government-emarketplace-bids-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/edyBneBp7fX0g1QhH/builds/NLFjxhomMEUcVxfgo/openapi.json