# Vinted Seller Products (`pintostudio/vinted-seller-products`)

The Vinted Seller Products Actor allows you to extract comprehensive product data from any Vinted seller's profile page.

- **URL**: https://beta-securitybyobscurity.apify.com/pintostudio/vinted-seller-products.md
- **Developed by:** [Pinto Studio](https://beta-securitybyobscurity.apify.com/pintostudio) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 6 total users, 3 monthly users, 96.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 results

This Actor is paid per result. You are not charged for the Apify platform usage, but only a fixed price for dataset items the Actor outputs.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-result

# README

## Vinted Seller Products Actor

A powerful Apify actor for scraping detailed product information from Vinted seller profiles across multiple countries and languages.

### Overview

The Vinted Seller Products Actor allows you to extract comprehensive product data from any Vinted seller's profile page. It supports all major Vinted domains and provides detailed information about each product including pricing, images, condition, availability status, and engagement metrics.

### Features

- **Multi-country Support**: Works with all 22 Vinted country domains
- **Pagination Control**: Scrape specific pages or ranges of products
- **Detailed Product Data**: Extract comprehensive information for each item
- **Error Handling**: Robust error handling with detailed logging
- **Data Validation**: Input validation for all parameters
- **Summary Statistics**: Automatic calculation of seller metrics

### Input Configuration

#### Required Fields

##### Seller URL

- **Type**: String
- **Description**: The full URL of the Vinted seller profile
- **Format**: `https://www.vinted.[country]/member/[seller_id]`
- **Example**: `https://www.vinted.pt/member/74292334`
- **Validation**: Must match the pattern for valid Vinted seller URLs

#### Optional Fields

##### Country Domain

- **Type**: String (Dropdown)
- **Description**: The country domain for Vinted
- **Default**: `com` (International)
- **Supported Countries**:
  - `com` - International
  - `fr` - France
  - `de` - Germany
  - `es` - Spain
  - `it` - Italy
  - `be` - Belgium
  - `nl` - Netherlands
  - `at` - Austria
  - `ch` - Switzerland
  - `cz` - Czech Republic
  - `dk` - Denmark
  - `fi` - Finland
  - `hu` - Hungary
  - `lt` - Lithuania
  - `lv` - Latvia
  - `lu` - Luxembourg
  - `pl` - Poland
  - `pt` - Portugal
  - `ro` - Romania
  - `se` - Sweden
  - `sk` - Slovakia
  - `si` - Slovenia

##### Page Number

- **Type**: Integer
- **Description**: The page number to scrape (starting from 1)
- **Default**: `1`
- **Range**: Must be a positive integer
- **Use Case**: Navigate through multiple pages of products

##### Items Per Page

- **Type**: Integer
- **Description**: Number of items to retrieve per page
- **Default**: `20`
- **Range**: 1-100
- **Use Case**: Control the amount of data retrieved per request

#### Example Input

```json
{
  "sellerUrl": "https://www.vinted.pt/member/74292334",
  "country": "pt",
  "page": 1,
  "perPage": 20
}
```

### Output Data Structure

The actor returns an array of product objects, each containing detailed information about a single item from the seller's catalog.

#### Product Object Fields

| Field | Type | Description |
|-------|------|-------------|
| `sellerUrl` | String | Original seller profile URL |
| `country` | String | Country domain used |
| `page` | Integer | Page number scraped |
| `perPage` | Integer | Items per page setting |
| `productId` | Integer | Unique Vinted product ID |
| `title` | String | Product title/name |
| `price` | Object | Price information with amount and currency |
| `currency` | String | Currency code (e.g., "EUR", "USD") |
| `brand` | String/null | Brand name if available |
| `size` | String/null | Size information if available |
| `condition` | String | Item condition (e.g., "New without tags") |
| `description` | String | Product description |
| `photos` | Array | Array of image URLs |
| `url` | String | Direct link to the product page |
| `isVisible` | Boolean | Whether the item is currently visible |
| `isSold` | Boolean | Whether the item has been sold |
| `isReserved` | Boolean | Whether the item is reserved |
| `createdAt` | String | Creation timestamp |
| `updatedAt` | String | Last update timestamp |
| `viewCount` | Integer | Number of views |
| `favouriteCount` | Integer | Number of favorites |
| `category` | String/null | Product category if available |
| `timestamp` | String | Scraping timestamp (ISO format) |

#### Example Output

```json
[
  {
    "sellerUrl": "https://www.vinted.pt/member/74292334",
    "country": "pt",
    "page": 1,
    "perPage": 20,
    "productId": 6778683487,
    "title": "Casaco, cardigan amarelo. Tam S /M. Há Outras cores e modelos diferentes.",
    "price": {
      "amount": "7.5",
      "currency_code": "EUR"
    },
    "currency": "EUR",
    "brand": null,
    "size": null,
    "condition": "New without tags",
    "description": "Beautiful yellow cardigan in excellent condition...",
    "photos": [
      "https://images1.vinted.net/t/02_00303_UXe2HPfMwtYSKeAAY365rGrB/f800/1753880031.jpeg?s=30123f11c8496d66077411cf496cf36021bfe6ea",
      "https://images1.vinted.net/t/01_00476_in49mA74L8pZBwspYryaFs1h/f800/1753880031.jpeg?s=3c848ea1d7513701fa2cbe4d0ccfe262df0dd1c1"
    ],
    "url": "https://www.vinted.pt/items/6778683487-casaco-cardigan-amarelo-tam-s-m-ha-outras-cores-e-modelos-diferentes",
    "isVisible": true,
    "isSold": false,
    "isReserved": false,
    "createdAt": "2024-01-15T10:30:00Z",
    "updatedAt": "2024-01-20T14:22:00Z",
    "viewCount": 156,
    "favouriteCount": 44,
    "category": "Women's Clothing",
    "timestamp": "2025-07-31T07:39:40.189Z"
  }
]
```

### Additional Features

#### Summary Statistics

The actor automatically generates summary statistics saved to the key-value store under `seller_products_summary`:

```json
{
  "sellerUrl": "https://www.vinted.pt/member/74292334",
  "country": "pt",
  "page": 1,
  "perPage": 20,
  "timestamp": "2025-07-31T07:39:40.189Z",
  "totalItemsOnPage": 20,
  "totalPages": 15,
  "totalItems": 287,
  "hasNextPage": true,
  "summary": {
    "itemsProcessed": 20,
    "averagePrice": 12.45,
    "soldItems": 3,
    "reservedItems": 1,
    "visibleItems": 19
  }
}
```

#### Error Handling

The actor includes comprehensive error handling:

- **URL Validation**: Ensures seller URLs are properly formatted
- **Country Validation**: Warns about unsupported country codes
- **Pagination Validation**: Validates page numbers and items per page
- **Network Error Handling**: Graceful handling of connection issues
- **Data Parsing**: Safe handling of missing or malformed data

### Usage Examples

#### Basic Usage

Scrape the first 20 products from a Portuguese seller:

```json
{
  "sellerUrl": "https://www.vinted.pt/member/74292334",
  "country": "pt"
}
```

#### Pagination Example

Scrape page 3 with 50 items per page:

```json
{
  "sellerUrl": "https://www.vinted.fr/member/12345678",
  "country": "fr",
  "page": 3,
  "perPage": 50
}
```

#### Large Batch Scraping

For scraping multiple pages, run separate actor instances or use the pagination information from the summary to iterate through pages.

### Best Practices

1. **Respect Rate Limits**: Don't run too many concurrent instances
2. **Use Appropriate Page Sizes**: Balance between efficiency and resource usage
3. **Monitor for Changes**: Vinted's structure may change; monitor for errors
4. **Data Storage**: Use Apify's dataset for large amounts of data
5. **Error Monitoring**: Check logs for validation warnings and errors

### Troubleshooting

#### Common Issues

**Invalid Seller URL**

- Ensure the URL follows the correct format
- Check that the seller ID is numeric
- Verify the country domain matches the URL

**No Products Returned**

- Seller may have no products or all products are sold
- Check if the seller profile is active
- Verify the country setting matches the seller's location

**Pagination Issues**

- Check if the requested page number exists
- Some sellers may have fewer products than expected
- Use the summary data to understand total available pages

#### Error Messages

- `sellerUrl is required`: Provide a valid seller URL
- `page must be a positive integer`: Use page numbers starting from 1
- `perPage must be a positive integer between 1 and 100`: Adjust the items per page value
- `No seller products retrieved`: The seller may have no visible products

### API Integration

This actor can be integrated into your applications using Apify's API:

```javascript
// Example API call
const client = new ApifyClient({
    token: 'your-token',
});

const run = await client.actor('the-actor-id').call({
    sellerUrl: 'https://www.vinted.pt/member/74292334',
    country: 'pt',
    page: 1,
    perPage: 20
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### Support

If you have any questions or encounter any issues, please consult the Apify documentation or reach out to us through one of the following channels:

- **Telegram**: [@pintoflow](https://t.me/pintoflow)
- **Email**: <pintoflowpt@gmail.com>
- **Apify Platform**: You can also contact us directly through this platform.

***

# Actor input Schema

## `sellerUrl` (type: `string`):

The full URL of the Vinted seller profile (e.g., https://www.vinted.com/member/12345678)

## `country` (type: `string`):

The country domain for Vinted (e.g., 'com' for vinted.com, 'fr' for vinted.fr)

## `page` (type: `integer`):

The page number to scrape (starting from 1)

## `perPage` (type: `integer`):

Number of items to retrieve per page (1-100)

## Actor input object example

```json
{
  "sellerUrl": "https://www.vinted.pt/member/74292334",
  "country": "com",
  "page": 1,
  "perPage": 20
}
```

# 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 = {
    "sellerUrl": "https://www.vinted.pt/member/74292334",
    "country": "com",
    "page": 1,
    "perPage": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("pintostudio/vinted-seller-products").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 = {
    "sellerUrl": "https://www.vinted.pt/member/74292334",
    "country": "com",
    "page": 1,
    "perPage": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("pintostudio/vinted-seller-products").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 '{
  "sellerUrl": "https://www.vinted.pt/member/74292334",
  "country": "com",
  "page": 1,
  "perPage": 20
}' |
apify call pintostudio/vinted-seller-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=pintostudio/vinted-seller-products",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Seller Products",
        "description": "The Vinted Seller Products Actor allows you to extract comprehensive product data from any Vinted seller's profile page.",
        "version": "0.0",
        "x-build-id": "j4DHwrznXJmRyKtmO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pintostudio~vinted-seller-products/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pintostudio-vinted-seller-products",
                "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/pintostudio~vinted-seller-products/runs": {
            "post": {
                "operationId": "runs-sync-pintostudio-vinted-seller-products",
                "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/pintostudio~vinted-seller-products/run-sync": {
            "post": {
                "operationId": "run-sync-pintostudio-vinted-seller-products",
                "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",
                "required": [
                    "sellerUrl"
                ],
                "properties": {
                    "sellerUrl": {
                        "title": "Seller URL",
                        "pattern": "^https://www\\.vinted\\.[a-z]{2,3}/member/\\d+/?.*$",
                        "type": "string",
                        "description": "The full URL of the Vinted seller profile (e.g., https://www.vinted.com/member/12345678)"
                    },
                    "country": {
                        "title": "Country Domain",
                        "enum": [
                            "com",
                            "fr",
                            "de",
                            "es",
                            "it",
                            "be",
                            "nl",
                            "at",
                            "ch",
                            "cz",
                            "dk",
                            "fi",
                            "hu",
                            "lt",
                            "lv",
                            "lu",
                            "pl",
                            "pt",
                            "ro",
                            "se",
                            "sk",
                            "si"
                        ],
                        "type": "string",
                        "description": "The country domain for Vinted (e.g., 'com' for vinted.com, 'fr' for vinted.fr)"
                    },
                    "page": {
                        "title": "Page Number",
                        "type": "integer",
                        "description": "The page number to scrape (starting from 1)"
                    },
                    "perPage": {
                        "title": "Items Per Page",
                        "type": "integer",
                        "description": "Number of items to retrieve per page (1-100)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
