Pinterest Comment Scraper With Commenter Profile Enrichment

Pinterest Comment Scraper — Comments, Commenter Bios and Followers

Pinterest Comment Scraper extracts the comments on any public pin as structured JSON: comment text in details, the commenter's username and display name, and per-comment like and helpful counts. With enrichment on, every unique commenter is looked up on their public Pinterest profile and the row also carries their follower count, pin count, board count, bio and join date. One row per comment, no HTML parsing, no login. Paste pin links and press Start.

What is Pinterest Comment Scraper With Commenter Profile Enrichment?

Pinterest Comment Scraper With Commenter Profile Enrichment is an Apify Actor that reads the comment feed under a public Pinterest pin and returns 25 top-level keys per comment — the comment itself, a nested user object for the person who wrote it, and nine commenter_* keys holding their public profile stats.

No Pinterest account, login, cookie or API key is required, and none can be supplied. The Actor mints the CSRF token it needs from the pin page itself and reads Pinterest's public surface exactly as a signed-out visitor's browser does.

It is built for social and community teams profiling who engages with a pin, creator-discovery and audience researchers, and developers piping comment threads into their own analysis or RAG pipelines.

What Pinterest comment data is publicly available to scrape?

Pinterest renders comments on a public pin to signed-out visitors, together with the commenter's username, display name and avatar, and it publishes follower, pin and board counts plus the bio and join date on every public profile page. What sits behind an account is your own analytics, private boards, and any way of contacting a person.

Data Category	Public to a signed-out visitor	Needs a signed-in Pinterest account
Comment text, comment ID and timestamp on a public pin	✅	❌
Commenter username, display name and avatar	✅	❌
Like and helpful counts on each comment	✅	❌
Photos a commenter attached to their comment	✅	❌
Commenter follower count, pin count and board count	✅	❌
Commenter bio and account join date	✅	❌
Pins and comments on a secret board	❌	✅ owner and collaborators only
Pin analytics — impressions, saves, outbound clicks	❌	✅ business account
Commenter email, phone number or website	❌	❌ Never published

Pinterest Comment Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

What data can I extract with Pinterest Comment Scraper?

Every row is one comment, with the commenter's identity nested under user and their profile stats flattened into commenter_* columns. Twenty-five top-level keys, written on every row of every run.

Field Name	Description
pinUrl	The pin this row came from, rebuilt from the domain the run actually resolved to
id	Pinterest's ID for the comment — the stable key for deduplicating across runs
node_id	Pinterest's internal GraphQL node identifier for the item
type	Pinterest's item type: aggregatedcomment, comment or userdiditdata
details	The comment body as plain text. Falls back to the item's text field, then to an empty string
user	Nested object with the commenter's public identity — see below
like_count	Likes on that single comment, read from Pinterest's reaction_counts
helpful_count	Helpful votes on that single comment, from the same source
comment_count	Number of replies to this comment. The replies themselves are not collected
done_at	Pinterest's timestamp for the item, falling back to its created_at
tags	Array of tags Pinterest attaches to the item, usually empty on plain comments
videos	Array of videos attached to the comment
images	Array of image objects with real dimensions — see below
image_signatures	Array of Pinterest image hashes for any attached photos
marked_helpful_by_me	Viewer-relative flag — always false here, since the run is unauthenticated
liked_by_me	The other viewer-relative flag, false for the same reason
commenter_enriched	true when a public profile was read for this commenter, false when it was not
commenter_follower_count	Followers on the commenter's public profile
commenter_pin_count	Pins on that profile
commenter_board_count	Boards on that profile
commenter_bio	The commenter's own "about" text, free-form and written by them
commenter_full_name	Display name as it appears on the profile page
commenter_image_xlarge_url	Extra-large avatar image URL from the profile
commenter_created_at	When the account was created — the profile's join date
commenter_is_verified_merchant	Pinterest's verified-merchant flag on the profile

Commenter identity — the user object

Field Name	Description
user.username	The commenter's Pinterest handle. Empty string when Pinterest omits it
user.full_name	Display name. Falls back to first_name when the payload has no full name
user.first_name	First name as Pinterest returns it
user.id	Numeric user ID, falling back to the payload's user_id
user.node_id	Internal node identifier for the user
user.image_medium_url	Medium avatar URL. Substituted, not nulled: when Pinterest omits it the Actor writes https://s.pinimg.com/images/user/default_75.png, so a value here does not prove the person set a photo
user.is_private_profile	Whether the account is marked private. Defaults to false when absent
user.type	Always user

user.username is the join key for enrichment: it is what the profile lookup is keyed on, and a row with an empty username is never enriched.

Attached media — the images array

Each entry in images is an object keyed by Pinterest's size names — originals, 550x and 150x150 — and each size holds url, width and height. A size the API did not return is omitted from the object entirely, so an entry can carry one size or all three. Width and height are passed through exactly as Pinterest sends them and are null when a dimension is missing; no dimension is ever synthesised to fill a gap. Comments with no attached photo return images as an empty array.

🤖 Add-on: Need additional Pinterest data?

If you want the pin's own performance rather than its comment thread, Pinterest Pin Engagement Analytics Scraper covers the same pins from the engagement side and joins to these rows on the pin URL. For the same commenter-profiling pattern on other platforms, Instagram Comment Leads Scraper and TikTok Comments Scraper By Real Comment Filter return comment threads with commenter identity attached.

What "commenter profile enrichment" actually is

Read this before you plan a workflow around the Actor's name.

Enrichment is a real second request, not a reshuffle of the comment payload. Pinterest's comment feed ships a thin user object — username, names, IDs, a medium avatar and a private-profile flag — and nothing more. To get follower count, pin count, board count, bio, join date, the extra-large avatar and the merchant flag, the Actor fetches https://<domain>/<username>/ for that commenter and parses the profile data embedded in the page. Nine keys on the row exist only because of that lookup: the eight commenter_* value keys and the commenter_enriched flag.

Every unique commenter costs one profile request; repeats cost nothing. There is no cap on how many commenters get enriched. Lookups are cached per username for the whole run, across every pin in it, so a person who comments on five of your pins is fetched once. Each new lookup gets up to two attempts, and after each one the Actor sleeps a random 1–2 seconds. Practically, a run with enrichment on issues roughly one extra request and one extra pause per distinct commenter — turning it off is the faster mode, and the input description says so.

A failed lookup still produces a full, charged row. When a profile cannot be read — the page does not return 200, or the embedded profile data is not where the parser expects it — all eight commenter_* values are written as null and commenter_enriched is set to false. The comment row is still pushed and still charged as a row_result. The failure is also cached, so that username is not retried later in the same run.

No contact detail of any kind is extracted. There is no email address, no phone number, no website field and no linked social account anywhere in the output. Pinterest does not publish those on a public comment or profile page and the Actor makes no attempt to find them elsewhere. commenter_bio is free text the person wrote themselves, so it contains whatever they chose to publish there and nothing the Actor went looking for. The only route to a commenter from this data is their public profile, opened by hand.

Enrichment does not add reach scores, tiers or rankings. The nine keys are the profile values as Pinterest publishes them. Nothing is computed, bucketed or ranked, and no aggregated per-commenter summary row is emitted at the end of a run.

Why not build this yourself?

Pinterest does run a developer platform, but it is not a route to this data. Access requires registering an app and passing Pinterest's app review, and the documented endpoints at developers.pinterest.com operate on content belonging to the authenticated account — your pins, your boards, your analytics. Reading the comment thread on somebody else's pin means reading the public surface, and that is the part worth understanding before you write it yourself.

The specific costs this Actor absorbs:

• A comment thread is not keyed by the ID in the URL. Pinterest's comment endpoint wants an aggregated_pin_id, which is a different number from the pin ID you pasted. The unauthenticated pin page frequently ships as a deferred shell with that value nowhere in it, so the Actor tries six regex patterns, then decodes every embedded application/json script block and every window.__PWS_* blob and deep-walks them for aggregated_pin_data.id, and finally asks Pinterest's own PinResource with field_set_key=unauth_react_main_pin. Hardcode any single one of those paths and it breaks on the next front-end change.
• The resource endpoints require a CSRF header you have to earn. UnifiedCommentsResource rejects a request without an x-csrftoken header, and the token comes from a csrftoken cookie that only exists after you have loaded the pin page. Warm-up, cookie read, header injection — in that order, per pin.
• A soft block looks like success. Pinterest answers a refused request with HTTP 200 and a resource_response whose data is null. Treat the status code as the truth and you will confidently report an empty comment thread on a pin with hundreds of comments.
• Enrichment is a second scraper. Profile pages are a different surface with a different parser, a different failure mode and their own rate-limit exposure — plus a cache, or you refetch the same prolific commenter on every row they appear in.
• TLS fingerprinting. Plain HTTP libraries are recognisable to Pinterest before the first byte of your request body is read. This Actor uses curl_cffi with Chrome 131 impersonation on every request it makes.
• The proxy ladder. Direct works most of the time and costs nothing; residential works when nothing else does and costs money. Getting the escalation order right, and only ever ratcheting it upward, is the difference between a cheap run and an expensive one.

How to use Pinterest Comment Scraper With Commenter Profile Enrichment

The Actor runs on Apify. Start it from the Apify Console or call it through the Apify API — your Apify token is the only credential involved, and there is no separate signup.

1. Open Pinterest Comment Scraper With Commenter Profile Enrichment on Apify and click Try for free
2. Paste one or more pins into Pin URLs or IDs (urls). A full link such as https://www.pinterest.com/pin/636977941054343221/ works, and so does the bare number 636977941054343221
3. Set Comments Limit (per pin) (limit). It defaults to 10 — raise it for deeper commenter lists
4. Leave Enrich commenter profiles (enrichCommenterProfiles) on for the commenter_* columns, or turn it off for a faster comments-only run
5. Optionally pick a Region / Domain (domain) matching where your pins live, and a Comments sort order (commentsSortOrder)
6. Click Start — rows stream into the output table as they are collected — then export as JSON, CSV or Excel

The Console form arrives with one example pin pre-filled, so pressing Start without editing scrapes that example pin rather than doing nothing. Leave the proxy off to begin with: the Actor starts on a direct connection and escalates by itself only when Pinterest pushes back.

How to scale to bulk comment extraction

urls is an array, so one run handles as many pins as you list, processed one at a time in the order you gave them. limit applies per pin, not per run — twenty pins at 50 comments each is a 1,000-row target. The per-run profile cache spans every pin in the job, so listing related pins together is cheaper than running them separately: a commenter who appears on several of them is looked up once for the whole run rather than once per run. Beyond the documented string list, urls also accepts a comma-separated string and a list of {"url": "…"} objects when you call the Actor over the API.

What can you do with Pinterest comment and commenter data?

• 🔍 A social listening analyst profiling who engages with a brand's pins pulls details with commenter_follower_count and commenter_pin_count, then sorts the comment thread by reach instead of by recency.
• 🎯 A creator-discovery researcher runs a competitor's top pins in one job and ranks the distinct user.username values by commenter_follower_count and commenter_board_count to find active curators worth approaching through their public profile.
• 📊 A content strategist measuring which pins start conversations groups rows by pinUrl and compares row counts against like_count and helpful_count, using comment_count to see which comments themselves spawned reply threads.
• 🕵️ A community moderator screening a viral pin filters on commenter_created_at and commenter_pin_count to separate long-standing accounts from ones registered last week, with commenter_enriched showing which rows had no profile to check.
• 🤖 An AI engineer building a social-listening agent indexes details into a vector store with commenter_follower_count, commenter_bio and pinUrl as metadata filters, so the agent can answer "what are high-reach pinners saying about this product" against the real thread rather than a summary.

Every one of these is callable from an agent framework over the Apify API, since the Actor is a standard HTTP-triggered run returning typed JSON.

How does Pinterest Comment Scraper handle rate limits and blocking?

Four mechanisms, all automatic and all in the source.

Chrome TLS impersonation on every request. Requests go out through curl_cffi impersonating Chrome 131 — the pin warm-up, the PinResource call, each page of comments and every profile lookup. There is no headless browser anywhere in the Actor.

Soft-block detection, not status-code trust. A resource_response whose data is null before any row has been collected is treated as a block and raised as an error, even though Pinterest returned HTTP 200. A non-200 from the comments endpoint is raised as UnifiedCommentsResource HTTP <status>.

Retry then escalate. Each pin gets four attempts, with a 1, 2 and 4 second backoff between them. If all four fail, the connection tier climbs: direct → Apify datacenter proxy → Apify residential proxy, with the residential rung retried three times. The tier is a run-level state that only ratchets upward, so once a run escalates, the remaining pins start from the raised floor.

Pacing. Every pin fetch, every comment page and every profile lookup is preceded or followed by a random 1–2 second sleep. Profile lookups get two attempts of their own, sleeping 1 then 2 seconds on HTTP 403, 429 or any 5xx.

There is no CAPTCHA solving in this Actor and none is claimed — blocking is answered by changing route, not by defeating a challenge. A pin that still cannot be read after every retry and every escalation is added to a skipped list and named in the run log; it contributes no rows and no error row, and the run continues to the next pin.

⬇️ Input

Six parameters, read straight from the Actor's input schema. One is required: urls. A run that reaches the Actor with an empty urls list logs No URLs provided. Exiting. and exits with code 1 before a single request is made — nothing is collected and nothing is charged.

Parameter	Required	Type	Description	Example Value
urls	Yes	array	Pinterest pin links or bare numeric pin IDs, one per entry. Prefilled with one example pin.	["https://www.pinterest.com/pin/636977941054343221/", "138626494769888646"]
domain	No	string	Pinterest regional domain, chosen from 22 values: www.pinterest.com, jp, br, uk, au, nz, co, de, fr, in, es, it, nl, pl, ru, tr, mx, ar, id, ph, th and kr .pinterest.com. Default "www.pinterest.com".	"uk.pinterest.com"
limit	No	integer	How many comments to collect per pin. Minimum 1, no maximum, default 10.	100
enrichCommenterProfiles	No	boolean	Fetch each unique commenter's public profile and merge the commenter_* fields onto the row. Default true.	true
commentsSortOrder	No	string	"popular" or "recent". Sets the is_reversed option on Pinterest's comment request. Default "popular".	"recent"
proxyConfiguration	No	object	Apify Proxy settings. Prefilled with {"useApifyProxy": false} — the Actor escalates on its own from direct to datacenter to residential.	{"useApifyProxy": false}

Six honest notes on how these behave in the code:

• limit is per pin and it also sets the page size. The Actor requests min(500, remaining) comments per page, so limit: 10 asks Pinterest for ten and stops. Omitting limit entirely through the API removes the cap and pages 500 at a time until Pinterest runs out — the Console always sends the default of 10.
• commentsSortOrder may not change anything. It is wired to the API's is_reversed toggle and sent on every request, but Pinterest has been observed returning the same order for both values on the same pin. The input is kept for forward compatibility; do not build ordering logic on it. Any value other than "popular" or "recent" silently falls back to "popular".
• domain can silently resolve to www.pinterest.com. If a regional domain fails to yield the pin's aggregated ID, the Actor retries the same pin on www.pinterest.com and, if that works, uses it for the comment requests, the profile lookups and the pinUrl written into every row. So pinUrl may not carry the domain you selected.
• proxyConfiguration is honoured but relabelled. Whatever groups you select are passed to Apify Proxy and one exit URL is created for the whole run — it is not rotated per request. Internally the run is then labelled as being on the datacenter rung, so the first failure escalates it straight to residential regardless of what you chose.
• enrichCommenterProfiles: false does not remove the columns. All nine enrichment keys are still written on every row, with the eight value keys as null and commenter_enriched as false, so the CSV shape stays identical between enriched and unenriched runs.
• limit counts rows, not comments. Pinterest's comment feed also carries "tried it" entries; the Actor keeps items of type aggregatedcomment, comment and userdiditdata, and all three count against your limit. Read type if you need to separate them.

Example input

{
  "urls": [
    "https://www.pinterest.com/pin/636977941054343221/",
    "https://www.pinterest.com/pin/138626494769888646/",
    "636977941054343221"
  ],
  "domain": "www.pinterest.com",
  "limit": 100,
  "enrichCommenterProfiles": true,
  "commentsSortOrder": "popular",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

⬆️ Output

One row per comment, 25 top-level keys, the same shape on every run whether enrichment is on or off. Rows are pushed the moment each one is parsed, so the dataset fills while the run is still going. Export as JSON, CSV or Excel, or read the dataset through the Apify API. The default table view surfaces 15 of the keys; the remaining 10, including node_id, images, tags, videos, image_signatures, comment_count and the merchant and board-count fields, are in the JSON and CSV exports.

Every row in the dataset is a comment row, and every comment row is charged as one row_result event. This Actor writes no error rows, no diagnostic rows and no accounting rows: there is no errorReason, isError, status, rowType or equivalent marker anywhere in the output, because no such row is ever pushed. Pins that could not be read live in the run log as a Skipped: [...] line, not in the data. The type key is Pinterest's own content-type discriminator, not an error marker.

A row whose enrichment failed is charged exactly like one that succeeded. commenter_enriched is false and the eight commenter_* values are null, but the row is a full result. Filter on commenter_enriched when you need only enriched records — after the run, not before it.

Values are nulled rather than dropped, with two exceptions. Missing sizes inside an images entry are omitted from the object, and user.image_medium_url is substituted with Pinterest's default avatar asset rather than left empty. Everything else that Pinterest does not supply arrives as null, an empty string, an empty array or false — the keys are always present.

Deduplication applies to profile lookups only, never to comments. Comment rows are pushed exactly as Pinterest paginates them, with no comment-ID dedupe, so listing the same pin twice in urls collects and charges for its comments twice. The only cache in the run is keyed on user.username and governs profile fetches.

Two things that stop a pin early. Pagination for a pin ends when Pinterest returns no further bookmark, when the limit is reached, or after two pages that contained no usable items. Separately, if your run hits its pay-per-event charge limit, the last row is discarded, Pay-per-event charge limit reached; stopping output. is logged, and the run walks the remaining pins without emitting anything further.

Example output

An enriched row — all 25 keys:

{
  "pinUrl": "https://www.pinterest.com/pin/636977941054343221/",
  "id": "5443675882856180764",
  "node_id": "QWdncmVnYXRlZENvbW1lbnQ6NTQ0MzY3NTg4Mjg1NjE4MDc2NA==",
  "type": "aggregatedcomment",
  "details": "Made this for a dinner party last weekend and everyone asked for the recipe. I swapped the cream for coconut milk and it still set perfectly.",
  "user": {
    "node_id": "VXNlcjo3ODA5MjM0NTYxMjM0NTY3",
    "image_medium_url": "https://i.pinimg.com/75x75_RS/13/12/cb/1312cb2d86dd7af0f727ae0cab839c37.jpg",
    "is_private_profile": false,
    "username": "harriet_bakes",
    "first_name": "Harriet",
    "full_name": "Harriet Doyle",
    "type": "user",
    "id": "780923456123456789"
  },
  "like_count": 14,
  "helpful_count": 3,
  "comment_count": 2,
  "done_at": "Tue, 17 Mar 2026 14:22:08 +0000",
  "tags": [],
  "videos": [],
  "images": [
    {
      "originals": {
        "url": "https://i.pinimg.com/originals/2f/6b/1a/2f6b1a94c07b5d3e8a41f2c9b6d70e15.jpg",
        "width": 1200,
        "height": 1600
      },
      "150x150": {
        "url": "https://i.pinimg.com/150x150/2f/6b/1a/2f6b1a94c07b5d3e8a41f2c9b6d70e15.jpg",
        "width": 150,
        "height": 150
      }
    }
  ],
  "image_signatures": ["2f6b1a94c07b5d3e8a41f2c9b6d70e15"],
  "marked_helpful_by_me": false,
  "liked_by_me": false,
  "commenter_enriched": true,
  "commenter_follower_count": 1281,
  "commenter_pin_count": 8361,
  "commenter_board_count": 42,
  "commenter_bio": "Home baker in Leeds. Sourdough, slow puddings and too many tart tins.",
  "commenter_full_name": "Harriet Doyle",
  "commenter_image_xlarge_url": "https://i.pinimg.com/600x600_R/13/12/cb/1312cb2d86dd7af0f727ae0cab839c37.jpg",
  "commenter_created_at": "Thu, 28 Nov 2019 00:05:18 +0000",
  "commenter_is_verified_merchant": false
}

A row from the same pin whose commenter profile could not be read — same 25 keys, still charged:

{
  "pinUrl": "https://www.pinterest.com/pin/636977941054343221/",
  "id": "5442792156024585568",
  "node_id": "QWdncmVnYXRlZENvbW1lbnQ6NTQ0Mjc5MjE1NjAyNDU4NTU2OA==",
  "type": "comment",
  "details": "Obsessed with this",
  "user": {
    "node_id": null,
    "image_medium_url": "https://s.pinimg.com/images/user/default_75.png",
    "is_private_profile": true,
    "username": "greenyellow550",
    "first_name": "",
    "full_name": "",
    "type": "user",
    "id": "412998001772340118"
  },
  "like_count": 0,
  "helpful_count": 0,
  "comment_count": 0,
  "done_at": "Wed, 23 Jul 2025 19:58:11 +0000",
  "tags": [],
  "videos": [],
  "images": [],
  "image_signatures": [],
  "marked_helpful_by_me": false,
  "liked_by_me": false,
  "commenter_enriched": false,
  "commenter_follower_count": null,
  "commenter_pin_count": null,
  "commenter_board_count": null,
  "commenter_bio": null,
  "commenter_full_name": null,
  "commenter_image_xlarge_url": null,
  "commenter_created_at": null,
  "commenter_is_verified_merchant": null
}

How does it work?

For each pin you supply, the Actor pulls the numeric ID out of your URL and loads the pin page once over plain HTTP with Chrome TLS impersonation. That warm-up does two jobs: it seeds the csrftoken cookie the resource endpoints demand, and it is the first place the Actor looks for the pin's aggregated_pin_id. When the page does not carry that ID — which is now the normal case for a signed-out visitor — the Actor asks Pinterest's own PinResource for it instead.

With the ID and the CSRF header in hand, it pages through UnifiedCommentsResource using Pinterest's bookmark cursor, keeping the comment and "tried it" item types and normalising each one into a fixed row shape. If enrichment is on, the commenter's username is checked against a run-wide cache and, if it is new, their public profile page is fetched and parsed for the follower, pin, board, bio, avatar, join-date and merchant fields. Each finished row is pushed immediately.

Requests start on a direct connection and escalate through Apify's datacenter and residential proxies only when Pinterest pushes back. Only publicly visible data is collected — no Pinterest account, cookie or session is involved anywhere. Because the output keys are defined by the Actor rather than by Pinterest's page markup, a site redesign can affect coverage but never your field names or their types.

Integrations

Pinterest Comment Scraper is an Apify Actor, so it works with anything that can call the Apify API or consume a dataset — scripts, schedules, webhooks, no-code builders and agent frameworks.

Calling Pinterest Comment Scraper from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/pinterest-comment-scraper-commenter-profile-enrichment").call(run_input={
    "urls": ["https://www.pinterest.com/pin/636977941054343221/", "138626494769888646"],
    "limit": 100,
    "enrichCommenterProfiles": True,
    "commentsSortOrder": "popular",
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
enriched = [r for r in rows if r["commenter_enriched"]]

for r in sorted(enriched, key=lambda x: x["commenter_follower_count"], reverse=True):
    print(r["user"]["username"], r["commenter_follower_count"], r["details"][:60])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request. Filter on commenter_enriched before reading any commenter_* value, since those keys are null on rows whose lookup failed.

No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node — or an HTTP Request node pointed at the Actor's run endpoint with your token — and pass the same JSON input shown above; an IF node on commenter_enriched routes unenriched rows away from a follower-count step before they reach Google Sheets or Airtable. In Make, the Apify module supports run-and-wait, so a weekly sweep of your brand's pins can feed a spreadsheet or CRM step directly. In LangChain, wrap the run call as a tool and hand details and commenter_bio straight to the model — both are plain text with no markup to strip. Apify schedules and webhooks cover recurrence and completion triggers.

⚠️ Is it legal to scrape Pinterest comments and commenter profiles?

Collecting comments published on a public pin, with no login bypassed, is generally treated as permissible, and this Actor reads only what any visitor sees. But the output is personal data about identifiable private individuals, and profile enrichment deepens the record you hold on each one rather than leaving it at a display name.

Pinterest commenters are consumers writing in a personal capacity, not businesses. user.username, user.full_name, user.first_name, user.id, user.node_id, user.image_medium_url, commenter_full_name, commenter_bio, commenter_image_xlarge_url, commenter_created_at, commenter_follower_count, commenter_pin_count, commenter_board_count and commenter_is_verified_merchant identify a person, and details is that person's own words, tied to them by id and pinUrl. What someone comments on can reveal health interests, religion, family circumstances and finances. The moment you store a row, you are a data controller.

Under GDPR and UK GDPR you need a lawful basis before storing or reusing these rows. If you rely on legitimate interest, that requires a documented balancing test, and it is materially harder to satisfy for private individuals in a personal context than for business contacts. Because the data is collected indirectly rather than from the person, GDPR Article 14 transparency duties apply, alongside retention limits and the duty to answer access, objection and erasure requests — keep id and user.username so a specific person's rows can be located and deleted. Under the CCPA, commenters are consumers with access and deletion rights.

Minimise concretely: drop commenter_bio, commenter_image_xlarge_url, user.image_medium_url and commenter_created_at first, since they are the most revealing and the least often needed. If your analysis is about the pin rather than the people, run with enrichCommenterProfiles off and keep details, like_count, helpful_count, done_at and pinUrl only. Set a retention period and delete on schedule.

No email, phone number, website or linked social account is returned by this Actor, so it supplies no contact channel. Approaching anyone you find here is regulated separately from collecting the data, and "it was public" is not a lawful basis for contacting someone. Consult legal counsel if your use case involves bulk storage of personal data.

❓ Frequently asked questions

What Pinterest comment fields does Pinterest Comment Scraper return?

Twenty-five top-level keys per comment. The five you will use most are details, user.username, commenter_follower_count, like_count and commenter_bio, with commenter_pin_count close behind as a signal of how active the commenter is. See the data fields table above for the full list, including the nested user object and the images array.

Does Pinterest Comment Scraper require a Pinterest account, login or cookie?

No, and none can be supplied — there is no cookie or session field in the input schema. The Actor loads the public pin page to seed the csrftoken cookie Pinterest's own front end uses, sends it back as an x-csrftoken header, and resolves the pin through the endpoint variant meant for signed-out visitors. Your Apify token is the only credential involved. One consequence: the viewer-relative fields Pinterest ships, liked_by_me and marked_helpful_by_me, are always false and carry no signal.

How many comments can I extract in one run?

limit has a minimum of 1, no maximum, and applies per pin — twenty pins at 50 each is a 1,000-row target in one run. Whether you reach it depends on how many comments the pin actually has. Two ceilings are Pinterest's rather than the Actor's: it serves at most 500 comments per page, and pagination for a pin ends when it stops returning a bookmark cursor.

What happens if a pin has no comments, is deleted, or is not publicly visible?

A pin whose comment list comes back empty produces no rows and no error — the Actor logs Collected 0 items and moves to the next pin. A pin that cannot be resolved at all, which covers deleted pins, bad IDs and pins Pinterest will not serve to a signed-out visitor, fails its four attempts, exhausts the proxy escalation ladder, and is added to the skipped list named in the run log. It contributes nothing to the dataset and costs nothing, but there is no error row to find it by — compare your input list against the distinct pinUrl values in the output.

One honest ambiguity: Pinterest answers a soft block with the same empty payload it would use for a genuinely dataless response, so before the first row of a pin is collected the Actor treats an empty payload as a block and retries. That is the safe reading, but it means a heavily blocked run and a run of comment-free pins look similar in the log.

Does the Actor collect replies to comments?

No. Only the items Pinterest returns in the pin's top-level comment feed are collected — types aggregatedcomment, comment and userdiditdata. The reply thread under a comment is a separate fetch that the Actor does not make. Each row's comment_count tells you how many replies that comment has, so you can see what you are not collecting.

Can I scrape comments from multiple Pinterest pins at once?

Yes — urls is an array and bulk is the normal mode. Pins are processed one at a time with a randomised 1–2 second gap between requests, which is what keeps Pinterest's blocking from engaging. limit applies per pin, so run size is your pin count multiplied by that limit. Over the API, urls also accepts a comma-separated string or a list of {"url": "…"} objects, and any entry can be a bare numeric pin ID.

Does Pinterest Comment Scraper work with Claude, ChatGPT and other AI agent tools?

Yes. It is callable as a standard HTTP endpoint through the Apify API, so LangChain, CrewAI, n8n or a hand-written tool definition can invoke it and receive typed JSON with no parsing step. There is no separate signup and no separate API key — the Apify token you already have is the only credential.

How does this compare to other Pinterest and commenter-enrichment scrapers?

Checked on the Apify Store on 25 July 2026. memo23/pinterest-scraper is the broadest Pinterest Actor and reads comments from the same UnifiedCommentsResource endpoint, but its dataset item is a pin, with comments nested underneath as comments.0.*, comments.1.* dot keys; the comment fields its listing documents are id, created_at, content, name, url, like_count, reply_count, helpful_count and avatar. Its optional user enrichment merges Pinterest's UserResource into the pin-side users — pinner, owner, board.owner, native_creator, via_pinner — so the follower_count fields its listing documents belong to the pin's creator rather than to the commenters. That is the main structural difference: one row per pin with commenter names, versus one row per comment with the commenter's own follower, pin, board, bio and join-date fields attached.

The other two Actors carrying this Actor's shape in their titles are LinkedIn tools, not Pinterest ones. kuldip_parmar/linkedin-post-comments-scraper documents a flat one-row-per-comment output with commenterName, commenterLinkedinUrl, commenterPosition and commenterPictureUrl, and states that replies are included as separate rows only when scrapeReplies is on. anchor/linkedin-profile-enrichment is a profile enricher rather than a comment scraper: it takes profile URLs as input and its listing documents follower_count, skills, experiences and company_website among its person fields. Where a competitor's listing is silent on something, that is not documented rather than not supported.

Does Pinterest Comment Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with consistent field names across runs, no HTML and no selectors. Pass a row straight into an LLM context window, index it into a vector store, or hand it to an agent tool. The only branch you need is commenter_enriched, since the commenter_* values are null on rows whose profile lookup failed.

What happens when Pinterest changes its layout or anti-bot system?

The Actor is maintained, and the output field names and types stay stable on your side regardless. It reads Pinterest's own JSON resources rather than scraping rendered markup, so a visual redesign does not affect the comment data. The one part that does track Pinterest's front end is the aggregated_pin_id lookup, which is why it is layered — six regex patterns, then a deep walk through the page's embedded JSON blobs, then a direct PinResource call — so that a change to any single one of them is covered by the next.

Can I use Pinterest Comment Scraper without managing proxies or browser infrastructure?

Yes, and the default is to configure nothing. No browser is launched at any point — requests are plain HTTP with Chrome TLS impersonation. The run begins on a direct connection, escalates to Apify's datacenter proxy if Pinterest refuses a pin, then to residential, and stays on the raised tier for the rest of the run. You never create a proxy account. Setting proxyConfiguration yourself simply starts the ladder one rung up.

Which Pinterest comment fields work best for AI training data and RAG indexing?

For RAG, details carries the entire information payload of a comment and chunks cleanly one row per chunk, with commenter_bio as useful metadata for filtering by the kind of person who wrote it and pinUrl as the citation anchor. For training data and analytics, the most structurally consistent fields are like_count, helpful_count, comment_count, commenter_follower_count, commenter_pin_count, commenter_board_count and type — all typed primitives, present on every row of every run. done_at and commenter_created_at arrive as Pinterest's own date strings and need parsing before any time series is valid. Keep the personal-data obligations in the legal section in mind before pushing commenter identity into a training set or a shared vector store.

🔗 Related scrapers

Scraper Name	What it extracts
Pinterest Pin Engagement Analytics Scraper	Pin-level saves, reactions and engagement metrics
Instagram Comment Leads Scraper	Instagram comment threads with commenter identity
LinkedIn Post Comments Scraper	Post comments with author name, profile URL and reactions
TikTok Comments Scraper By Real Comment Filter	TikTok video comments with spam filtering
YouTube Shorts Scraper With Creator Lead Enrichment	Shorts metadata with creator reach data
Goodreads Review Scraper With Reviewer Lead Enrichment	Book reviews with reviewer follower and review counts

💬 Your feedback

Found a bug, or a pin whose comments come back short of what the page shows? Open an issue on the Actor's Issues tab. Reports that include the exact input JSON — the pin URL, your limit and whether enrichment was on — are the fastest to reproduce and fix.