# Atida Portugal Scraper - Portuguese Online Pharmacy (`studio-amba/atida-pt-scraper`) Actor

Scrape products, prices, brands, ratings and stock from Atida Portugal (atida.pt), a major Portuguese online pharmacy and parapharmacy in the Atida group. Extract vitamins, supplements, cosmetics and health products. No login required.

- **URL**: https://apify.com/studio-amba/atida-pt-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 11.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result scrapeds

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/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

## Atida Portugal Scraper

Scrape products from [Atida Portugal](https://www.atida.pt), one of Portugal's larger online pharmacies and parapharmacies and part of the Atida group. Search by keyword and pull clean, structured product data: names, prices, original (was) prices, brands, ratings, review counts, stock status, categories, pack format, and images.

No login. No cookies. No account required.

### Why use this scraper?

- **Price monitoring** — Track Atida Portugal prices for vitamins, supplements, cosmetics and health products over time and spot promotions.
- **Competitive analysis** — Compare Atida Portugal pricing against other Portuguese pharmacies (Farmácia Saúde, Farmácias Portuguesas, Wells) on matching brands and formats.
- **Market research** — Analyse assortment, brand coverage, and pricing across pharmacy and parapharmacy categories.
- **Retail intelligence** — Monitor stock availability and discount depth across large product ranges.
- **Catalogue enrichment** — Enrich your own catalogue with images, ratings, descriptions, and category paths.
- **Brand monitoring** — Track how your brand's products are priced, rated, and merchandised on Atida Portugal.
- **Data journalism & academia** — Build datasets on Portuguese health and beauty retail pricing and consumer ratings.
- **Reselling & arbitrage** — Find discounted lines and price gaps against other Portuguese and EU health retailers.

### How to scrape atida.pt data

1. **Create an Apify account** — Sign up at [apify.com](https://apify.com) (free tier available).
2. **Open the Atida Portugal Scraper** — Navigate to this actor's page in the Apify Store.
3. **Enter a search term** — Type a Portuguese product keyword (e.g., "vitamina c", "protetor solar", "colagenio", "paracetamol"). The scraper searches the full Atida Portugal catalogue.
4. **Refine (optional)** — Filter by brand, price range, stock status, or choose a sort order (price low-to-high, price high-to-low, newest).
5. **Set a result limit** — Choose how many products you want (default: 100).
6. **Run the actor** — Click "Start". Most searches finish in well under a minute.
7. **Download your data** — Export as JSON, CSV, or Excel from the Dataset tab, or pull it via the Apify API for automated workflows.

### How it works

Atida Portugal runs on the same Magento + Algolia platform as the rest of the Atida group. The storefront HTML sits behind a Cloudflare "verify real visitors" wall, but the product catalogue is powered by a public product-search index (the same search the site's own search box queries directly from your browser). This scraper reads from that same index, so it is fast and reliable and does not need a headless browser or residential proxies for normal use. Each request returns up to 1000 fully hydrated products.

If the site ever rotates its public search credentials, the actor can automatically refresh them (set an optional Bright Data API key). This is not needed for normal use.

### Input parameters

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Product search term in Portuguese (e.g., "vitamina c", "protetor solar"). Defaults to "vitamina c" if left empty. |
| `maxResults` | integer | Maximum number of products to scrape (default: 100). |
| `sort` | select | Sort order: relevance (default), price low-to-high, price high-to-low, or newest. |
| `brand` | string | Filter to a single brand (exact match, e.g., "Avene", "La Roche-Posay", "CeraVe"). |
| `inStockOnly` | boolean | Only return products currently in stock. |
| `minPrice` | integer | Only return products at or above this price (EUR). |
| `maxPrice` | integer | Only return products at or below this price (EUR). |
| `brightDataApiKey` | string | Optional. Fallback to refresh the built-in search credentials if they ever rotate. Not needed for normal use. |
| `proxyConfiguration` | object | Legacy proxy settings. The catalogue is fetched from a public search API, so this can be left at its default. |

### Output fields

| Field | Type | Example |
|-------|------|---------|
| `name` | string | "Solgar Vitamina C 1000 mg 100 Cápsulas Vegetais" |
| `brand` | string | "Solgar" |
| `price` | number | 19.99 |
| `originalPrice` | number | 33.79 |
| `currency` | string | "EUR" |
| `sku` | string | "855636147623" |
| `productId` | string | "59723" |
| `inStock` | boolean | true |
| `rating` | number | 5 |
| `reviewCount` | integer | 12 |
| `category` | string | "Vitaminas e Suplementos > Suplementos" |
| `packFormat` | string | "Cápsulas - 100" |
| `isOtc` | boolean | false |
| `imageUrl` | string | "https://assets.atida.com/transform/..." |
| `url` | string | "https://www.atida.com/pt-pt/solgar-vitamina-c-1000-mg-100-comprimidos" |
| `productDescription` | string | "Suplemento alimentar à base de vitamina C..." |
| `scrapedAt` | string | "2026-07-07T20:00:00.000Z" |

### Example output

```json
{
  "name": "Freshly Cosmetics Soro concentrado de vitamina C 30 ml",
  "brand": "Freshly",
  "price": 21.99,
  "originalPrice": 33.79,
  "currency": "EUR",
  "sku": "970217284863",
  "productId": "90453",
  "inStock": true,
  "rating": 4,
  "reviewCount": 8,
  "category": "Beleza > Rosto > Serum",
  "packFormat": "Serum - 30 ml",
  "isOtc": false,
  "imageUrl": "https://assets.atida.com/transform/c66d65b0-c6e1-4201-92af-72bae8343836/Freshly",
  "url": "https://www.atida.com/pt-pt/freshly-cosmetics-vitamin-c-concentrate-serum-30-ml",
  "productDescription": "Sérum concentrado de vitamina C.",
  "scrapedAt": "2026-07-07T20:00:00.000Z"
}
````

### Cost estimate

The scraper reads from a fast public search index, so runs are cheap and quick. A typical search of a few hundred products finishes in well under a minute and costs a fraction of a cent in Apify compute plus the per-result event fee. Pricing scales linearly with the number of results you request.

### Limitations / known issues

- **Search-based** — Results come from the site's search index. Use specific Portuguese keywords for best coverage; very broad terms return the site's relevance-ranked top matches.
- **EAN not exposed** — The public index does not carry the EAN barcode. Products are keyed by SKU and internal product id instead.
- **Category depth** — The `category` field reports the deepest available category path for each product.
- **Not affiliated with Atida** — This is an independent tool for publicly available product data. Respect the site's terms and applicable laws when using scraped data.

### Related actors

Building a European pharmacy price dataset? Pair this with our other pharmacy and parapharmacy scrapers to compare pricing across chains and markets:

- **Mifarma Scraper** — Atida's Spanish online pharmacy (atida.com/es-es) products and prices.
- **Atida France Scraper** — Atida's French online pharmacy (atida.fr) products and prices.
- **Newpharma Scraper** — Belgian online pharmacy products.
- **Farmaline Scraper** — Belgian/EU pharmacy catalogue.
- **Dr. Max Scraper** — Central European pharmacy prices.
- **Farmacia Tei Scraper** — Romania's largest online pharmacy.

Atida runs sibling storefronts on the same platform across Spain, France and Portugal, so equivalent per-market scrapers are straightforward to add.

# Actor input Schema

## `searchQuery` (type: `string`):

Product search term in Portuguese (e.g., 'vitamina c', 'protetor solar', 'paracetamol', 'colagenio').

## `maxResults` (type: `integer`):

Maximum number of products to scrape.

## `sort` (type: `string`):

Sort order for results.

## `brand` (type: `string`):

Filter to a single brand (exact match, e.g., 'Avene', 'La Roche-Posay', 'CeraVe').

## `inStockOnly` (type: `boolean`):

Only return products currently in stock.

## `minPrice` (type: `integer`):

Only return products at or above this price.

## `maxPrice` (type: `integer`):

Only return products at or below this price.

## `brightDataApiKey` (type: `string`):

Optional: your own Bright Data Web Unlocker API key. Only used as a fallback to refresh the built-in search credentials if they ever rotate. Not needed for normal use.

## `proxyConfiguration` (type: `object`):

Legacy proxy settings. The product catalogue is fetched from a public search API, so this can be left at its default.

## Actor input object example

```json
{
  "searchQuery": "vitamina c",
  "maxResults": 20,
  "sort": "",
  "inStockOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PT"
  }
}
```

# 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 = {
    "searchQuery": "vitamina c",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "PT"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/atida-pt-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 = {
    "searchQuery": "vitamina c",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "PT",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/atida-pt-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 '{
  "searchQuery": "vitamina c",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PT"
  }
}' |
apify call studio-amba/atida-pt-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/atida-pt-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Atida Portugal Scraper - Portuguese Online Pharmacy",
        "description": "Scrape products, prices, brands, ratings and stock from Atida Portugal (atida.pt), a major Portuguese online pharmacy and parapharmacy in the Atida group. Extract vitamins, supplements, cosmetics and health products. No login required.",
        "version": "0.1",
        "x-build-id": "Tol4eTV8jxs71WV05"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~atida-pt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-atida-pt-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/studio-amba~atida-pt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-atida-pt-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/studio-amba~atida-pt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-atida-pt-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Product search term in Portuguese (e.g., 'vitamina c', 'protetor solar', 'paracetamol', 'colagenio')."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to scrape.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "",
                            "price_asc",
                            "price_desc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Sort order for results.",
                        "default": ""
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Filter to a single brand (exact match, e.g., 'Avene', 'La Roche-Posay', 'CeraVe')."
                    },
                    "inStockOnly": {
                        "title": "In Stock Only",
                        "type": "boolean",
                        "description": "Only return products currently in stock.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products at or above this price."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products at or below this price."
                    },
                    "brightDataApiKey": {
                        "title": "Bright Data API Key (optional)",
                        "type": "string",
                        "description": "Optional: your own Bright Data Web Unlocker API key. Only used as a fallback to refresh the built-in search credentials if they ever rotate. Not needed for normal use."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Legacy proxy settings. The product catalogue is fetched from a public search API, so this can be left at its default."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
