# Indian Cinemas Directory (`apicrawlers/indian-cinemas-directory`) Actor

Query 3,000+ Indian cinemas from a daily-updated dataset covering 2,000+ cities across India. Instantly filter by city, chain, IMAX, 4DX, Dolby Atmos, amenities, and more. Get fast structured JSON output — no scraping delays, no browser automation, results in seconds.

- **URL**: https://apify.com/apicrawlers/indian-cinemas-directory.md
- **Developed by:** [API Crawlers](https://apify.com/apicrawlers) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.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.

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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Indian Cinemas Directory

### What does Indian Cinemas Directory do?

Indian Cinemas Directory provides instant access to a comprehensive database of 3,000+ Indian cinemas without the need for scraping or browser automation. Instead of querying websites in real-time, this actor accesses a daily-updated dataset covering 2,000+ cities across India, delivering structured JSON results in seconds.

Indian Cinemas Directory can provide:

- Cinema names and locations
- Cinema chains and independent theaters
- Advanced format support (IMAX, 4DX, Dolby Atmos)
- Amenities and facilities information
- City and region-based filtering
- Contact details and operational information

### Why use Indian Cinemas Directory?

India is home to the world's largest cinema industry with thousands of theaters spread across the country. Whether you're building a movie ticketing platform, conducting market research, or analyzing the cinema landscape, Indian Cinemas Directory provides a reliable, fast, and structured data source.

Here are some ways you could use this data:

- Build cinema discovery and ticketing platforms
- Analyze regional cinema distribution and market gaps
- Research premium format availability across cities
- Create location-based cinema recommendation systems
- Develop cinema chain analytics and benchmarking tools
- Plan cinema expansion strategies based on regional data

If you would like more inspiration on how cinema data could help your business or organization, check out our [industry pages](https://apify.com/industries).

### How to get cinema data

Getting cinema data with Indian Cinemas Directory is straightforward:

1. Click on **Try for free**.
2. Select your filtering preferences:
   - Filter by city or region
   - Select cinema chains of interest
   - Filter by advanced formats (IMAX, 4DX, Dolby Atmos)
   - Filter by amenities and facilities
3. Click on **Run**.
4. When the actor finishes, preview or download your data from the **Dataset** tab in JSON format.

Results are returned in seconds with no scraping delays or browser automation overhead.

### Free vs Premium

| Feature | Free | Paid |
|---------|------|------|
| Fields returned | cinema_id, cinema_name, chain, city | All fields (+ coordinates, formats, amenities, address, state, country) |
| Records per query | 50 (unfiltered) / 100 (filtered) | Unlimited |
| City filters | 1 city max | Unlimited |
| Full export (no filters) | Blocked | Allowed |
| Multi-city queries | Blocked | Allowed |
| Detection | Automatic | Automatic |

**Free tier** requires at least one filter (city, chain, format, or amenity). This gives you enough data to evaluate quality before upgrading.

**Paid tier** unlocks the full dataset automatically when you're on any paid Apify plan — no API keys or extra configuration needed.

### How much will it cost?

Apify gives you $5 free usage credits every month on the [Apify Free plan](https://apify.com/pricing). Free tier queries are fast and low-cost — perfect for evaluation.

For full dataset access with all fields, coordinates, and unlimited records, upgrade to any [paid Apify plan](https://apify.com/pricing) — detection is automatic.

For enterprise-scale usage, the [Scale plan](https://apify.com/pricing) at $499/month offers unlimited queries and priority support.

### Example output

#### Free plan (4 fields)

```json
[
  {
    "cinema_id": "inox_r_city_ghatkopar",
    "cinema_name": "INOX R-City, Ghatkopar",
    "chain": "INOX",
    "city": "Mumbai"
  }
]
````

#### Paid plan (all fields)

```json
[
  {
    "cinema_id": "inox_megaplex_sky_city_mall_borivali",
    "cinema_name": "INOX Megaplex Sky City Mall, Borivali",
    "chain": "INOX",
    "city": "Mumbai",
    "state": "Maharashtra",
    "country": "India",
    "address": "Oberoi Sky City Mall, Datta Pada Road, Borivali East, Devi Pada Metro Station, Mumbai, Maharashtra 400066, India",
    "latitude": 19.2218,
    "longitude": 72.8629,
    "formats": "2D, IMAX 2D, 4DX, 3D, 4DX 3D",
    "amenities": "Car Parking, Food & Beverages"
  }
]
```

### Tips for using Indian Cinemas Directory

- Use city filters to focus on specific markets and reduce API response times
- Combine format filters (IMAX, 4DX) to find premium cinema locations
- Leverage amenities data to understand theater offerings in different regions
- Schedule regular queries to track cinema updates and new openings
- Use chain filtering to analyze competitor presence in target cities
- Batch your queries during off-peak hours for optimal performance

### Is it legal to use this data?

Indian Cinemas Directory provides aggregated, public business information about cinema locations and facilities. This data is sourced from publicly available information and does not contain personal data.

However, note that personal data is protected by regulations including India's Digital Personal Data Protection Act and GDPR in the European Union. You should ensure your use case complies with all applicable data protection laws.

If you have questions about the legality of your specific use case, we recommend consulting with your legal team. You can also read our blog post on [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) for more context.

# Actor input Schema

## `cities` (type: `array`):

Filter by city name. Free plan: 1 city max. Paid plan: unlimited.

## `chains` (type: `array`):

Filter by cinema chain (e.g. PVR, INOX, Cinepolis). Leave empty to return all chains.

## `formats` (type: `array`):

Filter by screen format — only cinemas that support ANY of the listed formats are returned (e.g. IMAX, 4DX). Full format data in paid plan only.

## `amenities` (type: `array`):

Filter by amenity — only cinemas that have ANY of the listed amenities are returned (e.g. Recliners, Dine-In). Full amenity data in paid plan only.

## `limit` (type: `integer`):

Maximum number of records to return. Free plan: capped at 50-100 regardless. Paid plan: no cap.

## Actor input object example

```json
{
  "cities": [
    "Mumbai"
  ],
  "chains": [],
  "formats": [],
  "amenities": []
}
```

# Actor output Schema

## `queryResults` (type: `string`):

Cinema records filtered by city, chain, screen format, or amenity. Each record includes name, location, GPS coordinates, formats, and amenities.

# 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 = {
    "cities": [
        "Mumbai"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apicrawlers/indian-cinemas-directory").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 = { "cities": ["Mumbai"] }

# Run the Actor and wait for it to finish
run = client.actor("apicrawlers/indian-cinemas-directory").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 '{
  "cities": [
    "Mumbai"
  ]
}' |
apify call apicrawlers/indian-cinemas-directory --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apicrawlers/indian-cinemas-directory",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indian Cinemas Directory",
        "description": "Query 3,000+ Indian cinemas from a daily-updated dataset covering 2,000+ cities across India. Instantly filter by city, chain, IMAX, 4DX, Dolby Atmos, amenities, and more. Get fast structured JSON output — no scraping delays, no browser automation, results in seconds.",
        "version": "1.0",
        "x-build-id": "LgmfK4XM2nWjaytCS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apicrawlers~indian-cinemas-directory/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apicrawlers-indian-cinemas-directory",
                "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/apicrawlers~indian-cinemas-directory/runs": {
            "post": {
                "operationId": "runs-sync-apicrawlers-indian-cinemas-directory",
                "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/apicrawlers~indian-cinemas-directory/run-sync": {
            "post": {
                "operationId": "run-sync-apicrawlers-indian-cinemas-directory",
                "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": {
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Filter by city name. Free plan: 1 city max. Paid plan: unlimited.",
                        "default": [
                            "Mumbai"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "chains": {
                        "title": "Chains",
                        "type": "array",
                        "description": "Filter by cinema chain (e.g. PVR, INOX, Cinepolis). Leave empty to return all chains.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "formats": {
                        "title": "Formats",
                        "type": "array",
                        "description": "Filter by screen format — only cinemas that support ANY of the listed formats are returned (e.g. IMAX, 4DX). Full format data in paid plan only.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "amenities": {
                        "title": "Amenities",
                        "type": "array",
                        "description": "Filter by amenity — only cinemas that have ANY of the listed amenities are returned (e.g. Recliners, Dine-In). Full amenity data in paid plan only.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records to return. Free plan: capped at 50-100 regardless. Paid plan: no cap."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
