> ## Documentation Index
> Fetch the complete documentation index at: https://docs.signa.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Track any public company's trademarks

> Go from a stock ticker to a public company's worldwide trademark portfolio, including its subsidiaries, then stand up a watch that fires on every new filing.

You cover a basket of listed companies and you want their trademarks keyed the way you already think about them: by ticker. Give Signa a ticker like `NKE` and it resolves to the underlying entity, hands you the company's worldwide portfolio (subsidiaries included), and lets you subscribe to every future filing.

This works because Signa links public-company facts onto [entities](/guides/entities): SEC tickers on the members that matched, plus a listing decoration that flows a listed parent's ticker down to its subsidiaries through the GLEIF corporate family. So a ticker is not just the parent's own marks, it is the whole listed group.

## Prerequisites

* A Signa API key with `trademarks:read` scope
* A stock ticker (uppercased, for example `NKE` or `AAPL`)

***

<Steps>
  <Step title="Resolve the ticker to an entity">
    Filter [`GET /v1/entities`](/api-reference/parties/list-entities) by `ticker`. The match is subsidiary-inclusive, so `ticker=NKE` returns Nike **and** its subsidiary entities. Sort by `-trademark_count` to put the parent first.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -G "https://api.signa.so/v1/entities" \
        -H "Authorization: Bearer $SIGNA_API_KEY" \
        --data-urlencode "ticker=NKE" \
        --data-urlencode "sort=-trademark_count" \
        --data-urlencode "limit=20"
      ```

      ```typescript TypeScript theme={null}
      import { Signa } from "@signa-so/sdk";

      const signa = new Signa({ api_key: process.env.SIGNA_API_KEY });

      const entities = await signa.entities.list({
        ticker: "NKE",
        sort: "-trademark_count",
        limit: 20,
      });

      for await (const entity of entities) {
        console.log(entity.id, entity.name, entity.ticker, entity.trademark_count);
      }
      ```
    </CodeGroup>

    The first row is the listed parent. Keep its `id` (an `ent_*`) for the next step.
  </Step>

  <Step title="Read the listing block">
    Fetch the entity with [`GET /v1/entities/{id}`](/api-reference/parties/get-entity). When an entity is listed or a subsidiary of a listed company, the response carries a `listing` block. The block is **omitted entirely** when there is no listing, so its absence means "no listing or unknown," never confirmed-private.

    ```json Listing block theme={null}
    {
      "id": "ent_R3jK9mN2",
      "name": "Converse Inc.",
      "ticker": "NKE",
      "tickers": ["NKE"],
      "listing": {
        "status": "subsidiary_of_listed",
        "ticker": "NKE",
        "exch_code": "XNYS",
        "lei": "INR2EJN1ERAN0W5ZP974",
        "source": "inherited",
        "listed_ancestor": {
          "id": "ent_9Km2nPq4",
          "name": "Nike, Inc.",
          "ticker": "NKE"
        }
      }
    }
    ```

    Read it as two axes:

    * **`status`**: `listed` (the entity is itself publicly listed) or `subsidiary_of_listed` (it inherits a ticker from a listed ancestor).
    * **`source`**: `direct` (the ticker is the entity's own) or `inherited` (the ticker comes from the nearest listed ancestor, surfaced in `listed_ancestor`). `source` is just `status` restated: `listed` is always `direct`, `subsidiary_of_listed` is always `inherited`.

    A directly-listed parent (`status: "listed"`, `source: "direct"`) has `listed_ancestor: null`. For a subsidiary, `listed_ancestor` points at the listed parent when it resolves to a live entity in our system (it is `null` when the ancestor exists only in the GLEIF graph).
  </Step>

  <Step title="Pull the worldwide portfolio, subsidiaries included">
    Call [`GET /v1/entities/{id}/trademarks`](/api-reference/parties/entity-trademarks) on the listed parent with `include_family=true`. That expands the query to the entity and every descendant in its GLEIF family tree, so one call returns the whole listed group's marks across all 21 offices. Drop `include_family` (or set it `false`) to get just that one entity.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -G "https://api.signa.so/v1/entities/ent_9Km2nPq4/trademarks" \
        -H "Authorization: Bearer $SIGNA_API_KEY" \
        --data-urlencode "include_family=true" \
        --data-urlencode "status_primary=active" \
        --data-urlencode "sort=-filing_date" \
        --data-urlencode "limit=20"
      ```

      ```typescript TypeScript theme={null}
      const page = await signa.entities.trademarks("ent_9Km2nPq4", {
        include_family: true,
        status_primary: "active",
        sort: "-filing_date",
        limit: 20,
      });
      ```
    </CodeGroup>

    The full [List Trademarks](/api-reference/trademarks/list-trademarks) filter set applies here (status, Nice classes, jurisdiction, date ranges), so you can narrow the group's portfolio to, say, active class 25 marks filed this year. A family graph larger than the walk bounds returns `422` with `error.reason` `family_graph_too_large`.
  </Step>

  <Step title="Stand up a public-company watch">
    To be notified of future filings under the ticker, add `ownerTicker` to a watch's `filters`. Watch filters share the same public-company/listing fields as search, so `ownerTicker` is subsidiary-inclusive too: `ownerTicker: "NKE"` fires on Nike's own filings and its subsidiaries' filings alike.

    Every watch needs a base scope from its `watch_type` (see [Monitoring watches](/guides/monitoring/watches)); `ownerTicker` is an additional filter layered on top. A common preset scopes a `class` watch to the Nice classes you care about and narrows it to the ticker, so you only hear about the group's filings in your core classes:

    ```bash cURL theme={null}
    curl -X POST "https://api.signa.so/v1/watches" \
      -H "Authorization: Bearer $SIGNA_API_KEY" \
      -H "Content-Type: application/json" \
      -H "Idempotency-Key: watch-nke-class25-001" \
      -d '{
        "name": "Nike group, class 25 filings",
        "watch_type": "class",
        "query": {
          "version": "v2",
          "filters": { "niceClasses": [25], "ownerTicker": "NKE" },
          "trigger_events": ["trademark.created"]
        }
      }'
    ```

    Prefer a broader net? Swap `ownerTicker` for `"ownerPubliclyTraded": true` to watch new filings by **any** owner with an active listing association (a confirmed SEC ticker, or a resolved entity that is listed or a subsidiary of one), still scoped by your chosen classes. Preview the volume with [`POST /v1/watches/preview`](/api-reference/monitoring/watches/preview) before you commit, and wire delivery through a [webhook](/guides/monitoring/webhooks).
  </Step>
</Steps>

## Coverage caveats

Public-company linkage is confirmed-positive only, and this shapes how you read a result:

* **Absent is not private.** A missing ticker, `publicly_traded: false`, or an omitted `listing` block means no confirmed match was found, not that the company is confirmed private or unlisted. Never infer "private" from absence.
* **Coverage is strongest for large caps.** Linkage leans on SEC tickers and GLEIF LEI reporting, so widely-held, LEI-reporting issuers resolve best. Thinly-covered small caps and non-reporting subsidiaries are likelier to be missing an edge.
* **Subsidiary reach depends on GLEIF Level 2.** The inherited-ticker walk follows the GLEIF corporate family, which covers LEI-reporting companies only. An absent parent/subsidiary edge does not imply the absence of a corporate relationship.

Coverage is measured with the ENG-118 eval harness; the production number is pending rollout and will be cited here once it lands.

## Related

* [Entities & owners](/guides/entities): how Signa resolves and links companies
* [Entity Family](/api-reference/parties/entity-family): the GLEIF parent and subsidiaries behind `include_family`
* [Monitoring watches](/guides/monitoring/watches): the full watch filter and trigger reference