# Get the industry placement benchmark for a sending domain `GET /v1/email/inbox-insights/benchmarks/industry` Returns how senders in a sending domain's industry place: the median inbox rate across the industry's measured senders, how many senders that median covers, and the industry the domain was classified into. The benchmark describes the industry rather than the domain, so it carries no comparison of its own. Compare it against the domain's own inbox rate from the placement resource. Its weighting is a general default rather than any one account's audience mix, a deliberate asymmetry with the placement figure it is compared against, and one worth naming wherever the two appear together. The status is `no_data` when too few measured senders share the industry for a median to be meaningful, when the domain's industry is not classified, or before the industry figures have been computed. That state is normal for a young cohort rather than an edge case, so handle it from the start. API-key calls require Insights preview access for your organization. ## Code samples ### TypeScript ```ts // Requires Insights preview access for the organization. let sendingDomain: string | undefined; for await (const domain of bird.email.inboxInsights.domains.list({ search: "mail.example.com" })) { if (domain.domain === "mail.example.com") { sendingDomain = domain.domain; break; } } if (!sendingDomain) throw new Error("Verify mail.example.com in this workspace first"); const report = await bird.email.inboxInsights.benchmarks.industry({ sending_domain: sendingDomain }); console.log(report); ``` ### Python ```py # Requires Insights preview access for the organization. sending_domain = None for domain in client.email.inbox_insights.domains.list(search="mail.example.com"): if domain.domain == "mail.example.com": sending_domain = domain.domain break if sending_domain is None: raise ValueError("Verify mail.example.com in this workspace first") report = client.email.inbox_insights.benchmarks.industry(sending_domain=sending_domain) print(report.model_dump_json()) ``` ### Go ```go // Requires Insights preview access for the organization. client, err := bird.NewClient(option.WithAPIKey(os.Getenv("BIRD_API_KEY"))) if err != nil { log.Fatal(err) } ctx := context.Background() sendingDomain := "" for domain, err := range client.Email.InboxInsights.Domains.List(ctx, bird.EmailInboxInsightsDomainsListParams{Search: "mail.example.com"}) { if err != nil { log.Fatal(err) } if domain.Domain != nil && *domain.Domain == "mail.example.com" { sendingDomain = *domain.Domain break } } if sendingDomain == "" { log.Fatal("Verify mail.example.com in this workspace first") } report, err := client.Email.InboxInsights.Benchmarks.Industry(ctx, bird.EmailInboxInsightsBenchmarksIndustryParams{SendingDomain: sendingDomain}) if err != nil { log.Fatal(err) } encoded, err := json.MarshalIndent(report, "", " ") if err != nil { log.Fatal(err) } fmt.Println(string(encoded)) ``` ### PHP ```php // Requires Insights preview access for the organization. $sendingDomain = null; foreach ($bird->email->inboxInsights->domains->list(['search' => 'mail.example.com']) as $domain) { if ($domain->getDomain() === 'mail.example.com') { $sendingDomain = $domain->getDomain(); break; } } if ($sendingDomain === null) { throw new \RuntimeException('Verify mail.example.com in this workspace first'); } $report = $bird->email->inboxInsights->benchmarks->industry(['sending_domain' => $sendingDomain]); var_dump($report); ``` ### CLI ```sh bird email inbox-insights benchmarks industry ``` ### cURL ```sh curl -X GET "https://us1.platform.bird.com/v1/email/inbox-insights/benchmarks/industry" \ -H "Authorization: Bearer $TOKEN" \ --url-query "sending_domain=mail.acme.com" ``` ## Example response `200` ```json { "resource": "placement", "domain": "mail.acme.com", "measurement": { "sources": [ "panel", "intelliseed_public" ], "weighting": { "weight_set_id": "12", "source": "account", "basis": "weighted-mean-of-per-isp-rates" } }, "generated_at": "2026-08-18T09:34:00Z", "freshness": { "as_of": "2026-08-17", "lag_hint": "daily" }, "cached_at": "2026-08-18T09:40:02Z", "industry": { "id": "44", "name": "Apparel" }, "median_inbox_rate_percent": 92.1, "window_days": 30, "cohort_size": 214, "status": "ok" } ``` ## Query parameters - `sending_domain` (string): The sending domain whose industry to benchmark: one of the workspace's verified sending domains, exactly as it appears there. A domain that is not verified in this workspace answers not-found. ## Response body - `resource` (string, required): Which resource this response is, echoed for self-description. - `domain` (string, required): The sending domain the figures describe. - `measurement` (object): How the figures were measured. Present only where a figure was weighted or drawn from a named set of sources, which today means placement and the industry benchmark. Absent on the reputation resources and on a live lookup, neither of which weights anything. - `measurement.sources` (array of string, required): Identifiers of the measurement systems that contributed to these figures. The set grows as measurement coverage does, so treat the values as labels rather than a closed list. - `measurement.weighting` (object): How the figures were weighted. Present on figures weighted against an audience mix, which is placement's method; measurements that weight nothing carry no weighting block. - `measurement.weighting.weight_set_id` (string, required): The measurement's own identifier for the audience mix, carried through so a client can tell two weightings apart without comparing `basis` strings. No operation accepts it. - `measurement.weighting.source` (nullable string, required): Which audience mix the weighting used. Null when the measurement weighted these figures by a method this API does not model: the enum is closed so that a client can branch on it exhaustively, which means an unfamiliar method has to answer "not one of these" rather than be passed through. `basis` usually still describes the method in words when that happens. - `measurement.weighting.basis` (nullable string, required): The weighting method behind the rates, as the measurement names it. A slug rather than a sentence, so render it as a label and do not expect it to read as English. Null when the measurement did not state one, which pairs with `source`: both describe the method, so neither can claim to know it when the measurement was silent. - `generated_at` (string, required): When the measurement service computed these figures. - `freshness` (object, required): How current the figures are. Freshness differs per resource (authentication data can lag a day or more while blocklist lookups are near real time), so any "as of" label binds from this field, never from a fixed string. - `freshness.as_of` (nullable string, required): The most recent UTC day the figures include, or null for a live lookup that has no measurement window. - `freshness.lag_hint` (nullable string, required) How far behind real time this resource usually runs. A lowercase identifier rather than a display label, so pick your own wording for it, and treat the set as open: the measurement names a hint per resource and can add one without notice. Null when the measurement reports no hint, which several resources do: show the figures without an age rather than inventing one. Possible values (may grow over time): `daily`, `nightly`, `near_real_time` - `cached_at` (string): Present when the response was served from a short-lived copy rather than fetched for this request: when that copy was fetched. - `industry` (nullable object, required): The cohort the median describes, or null when the domain is not classified into an industry. This description already names that as a `no_data` cause and a normal state for a young cohort, so it needs a representation: without one the only way to report an unclassified domain is a cohort with a blank name. - `industry.id` (string, required): The measurement's own identifier for this industry, carried through so a client can tell two cohorts apart without comparing labels. No operation accepts it. - `industry.name` (string, required): Display name of the industry. The classification is broad, so bind this label rather than assuming a finer category exists. - `median_inbox_rate_percent` (nullable number, required): The industry's median inbox rate, as a percentage. - `window_days` (integer): How many days the cohort figure covers. Reported rather than assumed because the period is the one the nightly computation produced, not one the caller chose, so a label built from a requested window would be wrong. Absent when the computation does not report it, in which case a label must not name a period at all. - `cohort_size` (nullable integer, required): How many measured senders the median was computed across. - `status` (string, required) Whether a section of the response carries figures, and when it does not, why. `ok` means the section is populated. `no_data` means the measurement ran and observed nothing to report for this domain in the period. `not_configured` means the section needs a setup step that has not been completed yet, such as connecting Google Postmaster Tools; treat it as an invitation to finish setup rather than a fault. `unavailable` means the figures could not be retrieved this time and the same request may well succeed on a retry; the rest of the response is unaffected. `not_applicable` means the section is meaningless for this domain in this period, so there is nothing to show or fix. A successful response never implies every section is populated; read each section's status rather than assuming figures are present. Possible values: `ok`, `no_data`, `not_configured`, `unavailable`, `not_applicable` ## Related resources - [Should I use a Bird SDK or call the API directly?](/explained/platform/should-i-use-an-sdk-or-call-the-api-directly) (answer) - [Build your first integration](/learn/paths/integration) (course) - [Send your first email](/docs/get-started/send-your-first-email) (docs) [Get an implementation brief](/learn/workspace?topic=api-basics)