Twitter X Posts Scraper With Contact Links

Twitter X Posts Scraper — Extract Posts and Contact Info

Twitter X Posts Scraper pulls posts from any X (formerly Twitter) profile and attaches each author's contact details — resolved website, location, bio-parsed email/phone, bio links, and professional category — inline on every row, with no separate lookup step. Point it at a handle, profile URL, or numeric user ID and get back structured JSON: post text, engagement counts, media, quoted posts, and contact fields ready to pass to an LLM, load into a CRM, or feed a lead-generation pipeline. No X login is required to run it.

What is Twitter X Posts Scraper?

Twitter X Posts Scraper queries one or more X profiles and returns their recent posts, each one carrying the full post payload (text, engagement counts, media, quoted post) plus a contact block resolved from the post author's public profile — website, location, best-effort email/phone parsed from the bio, bio links, and professional category. That contact block is what separates it from a plain post-timeline scraper: instead of a post list and a separate profile lookup, every row already carries both. No X account, login, or cookies are required — the Actor authenticates as a guest session against X's own web client.

• Scrape posts from any public profile via @handle, plain handle, profile URL, or numeric user ID
• Attach resolved author contact details to every post: real website URL (the t.co redirect resolved to its destination), location, bio-parsed email, bio-parsed phone, bio links, and professional category
• Sort collected posts by most recent, oldest, or most liked
• Cap how many posts are pulled per profile, from 1 to 100
• Filter output to only posts whose author has a contact method, and skip billing for the rows that get filtered out
• Route requests through Apify Proxy, with an automatic datacenter-then-residential fallback if X blocks a request

What data can you get with Twitter X Posts Scraper?

Every run returns one JSON row per post, and each row is really three things stitched together: the post itself, the author's public profile stats, and the author's resolved contact details.

Result Type	Extracted Fields	Primary Use Case
Post content & engagement	id, url, description, date_posted, likes, replies, reposts, quotes, views, bookmarks, hashtags, tagged_users, photos, videos, quoted_post, external_url, input	Content and engagement analysis, monitoring feeds
Author profile	user_posted, name, is_verified, followers, following, posts_count, profile_image_link, biography	Audience sizing, verification and reach checks
Author contact info	website, location, email, phone, bioLinks, professionalCategory, hasContact	Lead generation, outreach list building, prospect qualification

Author contact info

This is the field group none of the three top-ranked competing X post scrapers document (checked 2026-07-26 — see the comparison FAQ below). It's resolved from the same author object the post response already contains, so it costs no extra request: website is the real destination behind the author's t.co bio link, location comes from their profile location field, bioLinks lists every link embedded in the bio text, and professionalCategory captures the label X shows for business/professional accounts (for example Entrepreneur or Media & News Company). email and phone are a best-effort regex parse over the bio text — X has no dedicated email or phone field on a profile, so these two are heuristic and frequently null. hasContact is true when at least one of website, email, or phone resolved to a value, which is what the requireContact input filters on.

{
  "website": "https://openai.com",
  "location": "San Francisco, CA",
  "email": "press@openai.com",
  "phone": null,
  "bioLinks": [{ "url": "https://openai.com/careers" }],
  "professionalCategory": "Technology Company",
  "hasContact": true
}

Quoted post data

When a scraped post quotes another post, quoted_post carries data_posted, description, post_id, profile_id, and profile_name for the quoted post. Note that in the current build, quoted_post.url and quoted_post.videos are always null — they are not populated even when the quoted post has a URL or media, so treat the quoted post as text-and-attribution only, not a fully resolved object. When a post doesn't quote anything, quoted_post still returns with every field null rather than being omitted.

Why not build this yourself?

Twitter X Posts Scraper works against X's internal GraphQL client, not a stable public endpoint, and that surface moves under you. Getting a valid session requires harvesting a live guest Bearer token and guest token from a real browser session against x.com — there's no way to obtain one from a static request. Each GraphQL operation (like resolving a username to a user ID) is called by a queryId that X regenerates whenever it ships a new JS bundle, so a hardcoded ID breaks silently on the next deploy; this Actor instead scans X's currently-loaded JS chunks live and extracts the operation's current ID by pattern, on every run. On top of that, X blocks aggressively on IP reputation, which means building retry and proxy-escalation logic (this Actor steps from no proxy, to Apify's datacenter proxy, to residential proxy with retries) is not optional — it's what keeps a run from silently returning zero results. Maintaining all of that yourself means re-deriving the queryId extraction and the blocking response every time X changes its client, indefinitely.

How does Twitter X Posts Scraper work?

The run pipeline is the same for every profile in startUrls. First, the Actor opens a headless browser session against https://x.com and listens on outgoing network requests until it captures a guest Authorization: Bearer … header and an x-guest-token, plus the URLs of the JS bundles X loaded along the way — this is the guest session every later request authenticates with. Next, it scans those bundles for the current UserByScreenName GraphQL queryId, since that ID changes whenever X ships a new build and a hardcoded one would silently break. For each profile, the Actor resolves a user ID — directly, if you passed a numeric ID; otherwise via the guest GraphQL UserByScreenName call, falling back to the api.x.com/2/users/by/username endpoint and finally to a Playwright profile-page load if the faster paths fail. With a user ID in hand, it pages through the UserTweets GraphQL endpoint in batches of up to 20 posts per request until maxTweets is reached or the profile runs out of posts, transforms each tweet node into the base post record, and appends the contact block resolved from that same node's author data — no second request per author. Once every requested post is collected, results are sorted locally per sortOrder, the requireContact filter is applied (if enabled), and surviving rows are pushed to the dataset one at a time. If any network step fails — token harvesting, user-ID resolution, or tweet fetching — the Actor retries by escalating the proxy tier: no proxy, then Apify's datacenter proxy, then residential proxy with up to three retries, before giving up on that profile.

What is the difference between a Twitter posts scraper and a contact/lead-extraction scraper?

A plain Twitter/X posts scraper returns what's visible in the timeline: post text, timestamps, and engagement counts, plus basic author stats like follower count. A contact or lead-extraction layer goes one step further and resolves the author's public profile signals — bio links, the real URL behind their t.co website link, their stated location, and any professional category X has assigned them — into structured fields a sales or research workflow can filter and sort on. The distinction matters because X profiles increasingly function as a landing page for creators and small businesses: the bio link, not a separate "contact us" page, is often the only outbound contact signal an account exposes. A scraper that stops at post text misses that signal entirely. Twitter X Posts Scraper returns both in a single response — every post row carries the standard post/engagement fields alongside the appended contact block (website, location, email, phone, bioLinks, professionalCategory, hasContact), so there's no second lookup or join required to go from "who posted this" to "how do I reach them."

How to scrape X posts with contact info using Twitter X Posts Scraper?

1. Open Twitter X Posts Scraper on its Apify Store listing and start a new run from the Apify Console.
2. Add the profiles you want under startUrls — one handle, @handle, profile URL, or numeric user ID per line.
3. Set the query controls that matter for your use case: sortOrder for how posts are ordered, maxTweets for how many posts per profile, extractContactInfo and includeProfessionalCategory to control what gets resolved, and requireContact if you only want authors with a contact method.
4. Start the run.
5. Download the results as JSON, CSV, or another format the Apify platform supports, or pull them via the Apify API once the run finishes.

{
  "startUrls": ["elonmusk", "https://x.com/OpenAI"],
  "sortOrder": "recent",
  "maxTweets": 25,
  "extractContactInfo": true,
  "requireContact": true
}

How to run multiple profiles in one job

startUrls accepts a list, so a single run can process any number of profiles — each line can be a handle, @handle, profile URL, or numeric user ID, mixed freely. Inside a run, profiles are processed one after another in the order given; the input schema does not expose a concurrency setting, so treat throughput as roughly linear in the number of profiles and posts requested. For a large profile list, splitting across a few runs is a simpler lever than looking for a concurrency parameter that isn't there.

⬇️ Input

startUrls is the only required field — everything else has a default and can be left untouched for a first run. There is no separate query-string or raw-URL mode: every entry in startUrls is parsed the same way, whether it's a bare handle, an @handle, or a full profile URL, and the remaining fields control sorting, how many posts come back, which contact fields get resolved, and how proxying is handled.

Parameter	Required	Type	Constraints	Description
startUrls	Yes	array (stringList)	—	Accounts to pull posts + author contact details from — one per line. Accepts a profile URL (https://x.com/username), a handle (username or @username), or a numeric user ID. Contact fields are derived from each post author's public profile.
extractContactInfo	No	boolean	default true	Resolve each author's website (the real URL behind the t.co link), location, best-effort email/phone parsed from the bio, and bio links. Public profile data only — X has no email field, so email/phone are heuristic and often null.
includeProfessionalCategory	No	boolean	default true	When X flags the author as a professional/business account, capture its category label (e.g. Entrepreneur, Media & News Company).
requireContact	No	boolean	default false	Skip (and never bill) posts whose author has no website, email, or phone. Turn on to build a lean prospect list; leave off to keep every post.
sortOrder	No	string (enum)	"recent" | "popular" | "oldest", default "recent"	Order posts before saving. recent — newest first. oldest — oldest first. popular — most liked first.
maxTweets	No	integer	min 1, max 100, default 10	Upper limit of posts to collect per profile. Higher values take longer.
proxyConfiguration	No	object (proxy editor)	default: no proxy	Apify proxy settings. The Actor steps through datacenter then residential fallback if X blocks a request.

Example JSON input

{
  "startUrls": ["elonmusk", "@OpenAI", "https://x.com/nasa"],
  "extractContactInfo": true,
  "includeProfessionalCategory": true,
  "requireContact": false,
  "sortOrder": "recent",
  "maxTweets": 20,
  "proxyConfiguration": { "useApifyProxy": true }
}

Common pitfall: startUrls takes profile identifiers, not individual post links. A value like https://x.com/elonmusk/status/1234567890 is recognized as a post URL and skipped with a warning — pass the profile (elonmusk or https://x.com/elonmusk) instead, and use maxTweets and sortOrder to control which of that profile's posts come back.

⬆️ Output

Results are pushed to the Actor's dataset as one typed JSON row per post, with a consistent schema across every run. The dataset's default view surfaces all 32 fields the row actually carries — it is not a trimmed-down subset. Export the dataset as JSON, CSV, Excel, or any other format the Apify platform's dataset export supports.

Each row that reaches the dataset is billed once, under the row_result charged event. When requireContact is enabled, posts whose author has no website, email, or phone are dropped before the push call, not after — so filtered-out rows are never sent to the dataset and never billed.

Field reference

Field	Type	Description
id	string	The post's unique ID.
url	string	Full URL of the post.
user_posted	string	Author's screen name (handle).
name	string	Author's display name.
description	string	The post's text content.
date_posted	string / null	Post creation time, ISO 8601 (YYYY-MM-DDTHH:MM:SS.000Z).
likes	integer	Like count.
replies	integer	Reply count.
reposts	integer	Repost (retweet) count.
quotes	integer	Quote count.
views	string / null	View count, as returned by X.
bookmarks	integer	Bookmark count.
is_verified	boolean	Whether the author is blue-verified.
followers	integer	Author's follower count.
following	integer	Number of accounts the author follows.
posts_count	integer	Author's total post count.
profile_image_link	string	URL of the author's profile image.
biography	string / null	Author's bio text.
hashtags	array / null	Hashtags used in the post, or null if none.
tagged_users	array / null	Screen names mentioned in the post, or null if none.
photos	string / null	URL of the first photo attached to the post, if any.
videos	array / null	Video/GIF variant URLs, highest bitrate first, or null if none.
quoted_post	object	The quoted post, if any — see below. url and videos inside it are always null in the current build.
external_url	string / null	The raw (unresolved) t.co URL from the author's profile, as returned by X.
input	object	{ "url": "<post URL>" } — the post URL the row corresponds to.
website	string / null	Author's website, resolved from t.co to its real destination. null unless extractContactInfo is on.
location	string / null	Author's self-set profile location. null unless extractContactInfo is on.
email	string / null	Best-effort email parsed from the bio text. Frequently null.
phone	string / null	Best-effort phone number parsed from the bio text. Frequently null.
bioLinks	array / null	Links embedded in the bio text, as { "url": "…" } objects.
professionalCategory	string / null	Business/professional category label, when X assigns one and includeProfessionalCategory is on.
hasContact	boolean	true when website, email, or phone resolved to a value.

quoted_post is always an object, never null — when a post doesn't quote anything, every field inside it is null rather than the object being omitted: data_posted, description, post_id, profile_id, profile_name, url, videos.

Scraped results

[
  {
    "id": "1234567890123456789",
    "url": "https://x.com/OpenAI/status/1234567890123456789",
    "user_posted": "OpenAI",
    "name": "OpenAI",
    "description": "Announcing a new update to our developer platform.",
    "date_posted": "2026-07-20T14:32:00.000Z",
    "likes": 8421,
    "replies": 312,
    "reposts": 1290,
    "quotes": 87,
    "views": "245000",
    "bookmarks": 640,
    "is_verified": true,
    "followers": 3200000,
    "following": 120,
    "posts_count": 4521,
    "profile_image_link": "https://pbs.twimg.com/profile_images/xxxx/openai_normal.jpg",
    "biography": "Building safe AGI that benefits all of humanity.",
    "hashtags": ["AI", "DevPlatform"],
    "tagged_users": null,
    "photos": null,
    "videos": null,
    "quoted_post": {
      "data_posted": null,
      "description": null,
      "post_id": null,
      "profile_id": null,
      "profile_name": null,
      "url": null,
      "videos": null
    },
    "external_url": "https://openai.com/blog",
    "input": { "url": "https://x.com/OpenAI/status/1234567890123456789/" },
    "website": "https://openai.com",
    "location": "San Francisco, CA",
    "email": null,
    "phone": null,
    "bioLinks": [{ "url": "https://openai.com/careers" }],
    "professionalCategory": "Technology Company",
    "hasContact": true
  },
  {
    "id": "1234567890123456790",
    "url": "https://x.com/elonmusk/status/1234567890123456790",
    "user_posted": "elonmusk",
    "name": "Elon Musk",
    "description": "🚀",
    "date_posted": "2026-07-19T09:12:44.000Z",
    "likes": 152000,
    "replies": 9800,
    "reposts": 14200,
    "quotes": 610,
    "views": "18400000",
    "bookmarks": 3100,
    "is_verified": true,
    "followers": 221000000,
    "following": 900,
    "posts_count": 55000,
    "profile_image_link": "https://pbs.twimg.com/profile_images/xxxx/elon_normal.jpg",
    "biography": null,
    "hashtags": null,
    "tagged_users": null,
    "photos": null,
    "videos": ["https://video.twimg.com/xxxx/720p.mp4"],
    "quoted_post": {
      "data_posted": null,
      "description": null,
      "post_id": null,
      "profile_id": null,
      "profile_name": null,
      "url": null,
      "videos": null
    },
    "external_url": null,
    "input": { "url": "https://x.com/elonmusk/status/1234567890123456790/" },
    "website": null,
    "location": null,
    "email": null,
    "phone": null,
    "bioLinks": null,
    "professionalCategory": null,
    "hasContact": false
  },
  {
    "id": "1234567890123456791",
    "url": "https://x.com/nasa/status/1234567890123456791",
    "user_posted": "nasa",
    "name": "NASA",
    "description": "New imagery from the mission, with a link to the full press kit.",
    "date_posted": "2026-07-18T17:05:10.000Z",
    "likes": 9600,
    "replies": 240,
    "reposts": 2100,
    "quotes": 55,
    "views": "512000",
    "bookmarks": 780,
    "is_verified": true,
    "followers": 90000000,
    "following": 320,
    "posts_count": 78000,
    "profile_image_link": "https://pbs.twimg.com/profile_images/xxxx/nasa_normal.jpg",
    "biography": "Explore the universe and discover our home planet. contact: media@nasa.gov",
    "hashtags": ["Artemis"],
    "tagged_users": ["NASAWebb"],
    "photos": "https://pbs.twimg.com/media/xxxx.jpg",
    "videos": null,
    "quoted_post": {
      "data_posted": "2026-07-17T12:00:00.000Z",
      "description": "Original mission footage from the flight deck.",
      "post_id": "1234567890123456700",
      "profile_id": "11111111",
      "profile_name": "NASA Webb",
      "url": null,
      "videos": null
    },
    "external_url": "https://nasa.gov/press-kit",
    "input": { "url": "https://x.com/nasa/status/1234567890123456791/" },
    "website": "https://nasa.gov",
    "location": "Washington, DC",
    "email": "media@nasa.gov",
    "phone": null,
    "bioLinks": [{ "url": "https://nasa.gov/artemis" }],
    "professionalCategory": "Government Organization",
    "hasContact": true
  }
]

How can I use the data extracted with Twitter X Posts Scraper?

• 📈 Sales and growth teams: turn requireContact: true runs into ready-to-work prospect lists — filter on hasContact, then route rows by whichever of website, email, or phone actually resolved.
• 🤖 AI engineers and LLM developers: feed the structured JSON straight into an agent as grounding context — a post's description, engagement counts, and the author's professionalCategory give a model enough signal to summarize or qualify a lead without extra scraping.
• 📊 Market researchers: run the same profile list on a schedule with sortOrder: "popular" to track which posts and topics are gaining engagement over time.
• 🧑‍💻 Product and growth marketers: use bioLinks and website across a niche's active accounts to map who's driving traffic where, without visiting each profile by hand.

How do you monitor new contactable posts over time?

Monitoring here means re-running the same profile list on a schedule and diffing the result against the previous run, rather than treating each run as a one-off snapshot. Two kinds of change matter: new posts, and changed contact signals on existing authors. For new posts, diff on id — any id that wasn't in the previous run's dataset is new content from that profile. For contact drift, diff hasContact, website, email, phone, and bioLinks between runs on the same user_posted — an author who previously had hasContact: false and now resolves a website or email is a fresh lead that a one-time run would have missed. professionalCategory is worth tracking too, since a category change (for example an account switching to a business category) often coincides with a new bio link going live. A practical loop: schedule a run across your target profile list, pull the new run's dataset via the Apify API, diff it against the last stored dataset on id and hasContact, and alert only on the rows that changed. To automate the schedule itself, use Apify's built-in Schedules feature on the Actor to trigger runs on a recurring cron rather than kicking off runs by hand.

Integrate Twitter X Posts Scraper and automate your workflow

Twitter X Posts Scraper is an Apify Actor, so it works with anything that can call the Apify API or read an Apify dataset.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/twitter-x-posts-scraper-with-contact-links").call(run_input={
    "startUrls": ["elonmusk", "@OpenAI"],
    "requireContact": True,
    "maxTweets": 25,
})

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    if post.get("hasContact"):
        print(post["user_posted"], post.get("website"), post.get("email"))

Works the same way in Go, Ruby, Node.js, or cURL — any language that can send an HTTP request to the Apify API.

No-code tools (Zapier, Make, n8n)

Twitter X Posts Scraper can be triggered and its results consumed through Apify's built-in integrations, available from the Actor's Integrations tab in the Console — connect it to Zapier, Make, or n8n without writing a request by hand, and route each finished run's dataset into a spreadsheet, CRM, or messaging tool downstream.

Scheduled monitoring and delivery

Use an Apify Schedule on the Actor to trigger runs on a recurring cron. Each run writes to its own dataset, which you fetch afterward through the Apify API or the Console — there's no built-in webhook push from the Actor itself, so poll the run's dataset after each scheduled trigger, or wire the schedule to Apify's platform-level integrations if you need results pushed elsewhere.

Is it legal to scrape X posts and profile contact data?

Scraping publicly accessible X posts and profile pages is generally lawful in the US — courts have held that accessing data a website makes available to any visitor without a login does not violate the Computer Fraud and Abuse Act (hiQ Labs v. LinkedIn, 9th Cir., 2019). Twitter X Posts Scraper returns only what a logged-out visitor to a public profile can already see. Because the contact block resolves fields tied to an identifiable person — email, phone, location, and a real name — that output is personal data under regimes like the GDPR and CCPA, and your downstream storage and use must comply with those rules. X's own Terms of Service also govern automated access to the platform. Scraping for one-off research carries a different risk profile than scraping to train a model or run bulk outreach. Consult your legal team for commercial use involving bulk data storage.

❓ Frequently asked questions

What formats can startUrls accept?

A profile URL (https://x.com/username), a handle (username or @username), or a numeric user ID — mix them freely in the same list.

Can I pass a post URL instead of a profile?

No. A post/status URL (for example https://x.com/user/status/123) is detected and skipped with a log warning — startUrls expects a profile, not an individual post.

How does sortOrder change what I get back?

It controls the order posts are saved in, not which posts are included: recent returns newest first, oldest returns oldest first, and popular returns the most-liked posts first, all applied after the posts for that profile are fetched.

How does Twitter X Posts Scraper handle X's anti-bot measures?

It authenticates as a guest session by harvesting a live Bearer token and guest token from a real browser request to x.com, rather than using a static credential. It also resolves the current GraphQL queryId for username lookups by scanning X's own loaded JS bundles on each run, since X rotates that ID with client updates. If a request is blocked, the Actor automatically escalates from no proxy to Apify's datacenter proxy, then to residential proxy with retries.

Does Twitter X Posts Scraper extract author contact info?

Yes — every post row carries a contact block with website, location, email, phone, bioLinks, professionalCategory, and hasContact. website, location, and bioLinks come directly from the author's profile fields; email and phone are a best-effort regex parse over the bio text and are frequently null, since X does not expose a dedicated email or phone field.

How many posts does it return per profile?

Up to maxTweets per profile, from 1 to 100 (default 10) as set in the input schema. Posts are fetched in pages of up to 20 at a time until that limit is reached or the profile runs out of posts. maxTweets is a ceiling, not a guarantee — a profile with fewer posts than the limit simply returns fewer rows, and paging stops as soon as X stops returning a next-page cursor.

What happens if a profile doesn't exist or has no public posts?

That profile is skipped and the run continues with the next one. If the Actor can't resolve a user ID for an entry in startUrls — because the handle doesn't exist, the profile is private, or resolution failed — it logs an error for that entry, saves zero rows for it, and moves on to the next profile rather than failing the whole run.

How do I monitor new contactable posts over time?

Schedule recurring runs across the same profile list using Apify's Schedules feature, then diff each new dataset against the previous one on id (for new posts) and on hasContact / website / email / phone (for authors who newly resolved a contact method).

Does Twitter X Posts Scraper work with Claude, ChatGPT, and AI agent frameworks?

It's callable as an HTTP endpoint through the Apify API, so any agent framework that can make an HTTP call — including Claude and ChatGPT-based agents — can trigger a run and consume the resulting JSON as grounding context.

How does Twitter X Posts Scraper compare to other X post scrapers?

Checked on the Apify Store on 2026-07-26: X (Twitter) Profile Posts Scraper and X (Twitter) Posts Search (scraper_one) and Twitter Posts Scraper (pratikdani) all return post text, author stats, and engagement counts, but none of their documented output fields include a resolved website, location, bio-parsed email/phone, bio links, or professional category — the contact block is unique to this Actor among the three as documented on their listings.

Feature	Twitter X Posts Scraper	X Profile Posts Scraper (scraper_one)	X Posts Search (scraper_one)	Twitter Posts Scraper (pratikdani)
Author contact fields (website / email / phone)	✅ Yes	❌ Not documented	❌ Not documented	❌ Not documented
Filter to contactable authors only	✅ Yes (requireContact)	❌ Not documented	❌ Not documented	❌ Not documented
Max posts per profile (as documented)	100	200 (resultsLimit, default 5)	Not fixed (resultsCount)	Not documented
Input mode	Profile handle / URL / user ID	Profile URL	Keyword or hashtag search	Not documented
Requires X login	❌ No	Not documented	Not documented	Not documented

Rows for the three competitors reflect what is stated on their own listings as of 2026-07-26; anything not mentioned there is marked "Not documented" rather than assumed absent.

Can I use Twitter X Posts Scraper without managing proxies or X credentials?

Yes. No X login, password, or cookies are required — the Actor authenticates as a guest itself. Proxy handling is automatic too: by default it runs with no proxy and escalates to Apify's datacenter and then residential proxy if X blocks a request; you only need to supply proxyConfiguration if you want to force a specific proxy tier from the start.

🔗 Related scrapers

Scraper	What it extracts
X (Twitter) Posts Search — Reposter Finder	Posts matching a search plus the accounts that reposted them
Twitter Trends Scraper With Rank History & Staying Power	Trending topics on X with rank history over time
Twitter X Reply Scraper — Conversation Engagement Analytics	Replies to X posts with per-post engagement reporting

💬 Your feedback

Found a bug, or need a contact field this Actor doesn't extract yet? Open an issue on the Actor's Issues tab with the profile you ran it against and the exact input JSON — that's the fastest way to get it reproduced and fixed.