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

# AI use rules

> Find the rules in which a court or judge says something about artificial intelligence in filings, and read what each one asks of a filer

An AI use rule is a rule in which a court or judge says something about artificial intelligence (AI) in filings or proceedings. Some ask something of the filer, such as saying that AI was used. Others only remind filers of duties they already have, or set a court's policy for its own staff. The API marks these rules with a `topics` field and finds them with `topic=ai_use`.

## Why teams use it

* **Check a judge before filing.** Read a judge's rules and look for a rule whose `kind` is `requirement`: a disclosure, a certificate, a ban on a use of AI.
* **Keep a list of orders current.** Page through `topic=ai_use` for a court and keep the rules whose `kind` is `requirement`.
* **Show the court's own words.** Each rule keeps the court's quote and the address of the court's document, so a filer can read the order itself.
* **Tell a duty from a mention.** `kind` separates an order that asks something of the filer from a reminder, a passing mention and a court's policy for its own staff.

## How it works

* Every rule the API returns can carry a `topics` field. A rule about AI use has `topics.ai_use`. A rule about anything else has no `topics` field.
* `topics.ai_use` has three parts. `kind` says what the rule is. `label` says what it is mainly about. `fields` answers specific questions, such as whether the rule asks for a disclosure, who must follow it and how to comply.
* A rule has the topic once the document it comes from has been read for it. A document that has not been read yet has no AI use rules in the API, so an empty answer does not prove that a court has no AI order.
* `ai_use` is the only topic today. `topics` is keyed by topic, so read the keys you know and ignore the others.

## Terms

| Term | Meaning |
| - | - |
| `kind` | What the rule is: an order that asks something of the filer, a reminder, a mention, or a court's own policy. Use it to decide. |
| `label` | What the rule is mainly about, in one word. It summarizes the rule and does not say which duties apply. |
| `fields` | The answers about the rule: what it asks, when, of whom, how, and what follows if the filer does not comply. |
| `unknown` | The answer was not confirmed. It is not `no`, and it is not `not_stated`. Read the court's document. |

## Kinds

Every AI use rule has one `kind`.

| Kind | What it is |
| - | - |
| `requirement` | An order that asks something of the filer, such as a disclosure, a certificate or a ban on a use of AI. |
| `reminder_only` | A reminder that adds no duty. The rule restates duties filers already have, or says no disclosure is needed. |
| `other` | A rule that mentions AI where no requirement was confirmed. |
| `court_internal` | A court's policy for its own judges and staff. It asks nothing of filers. |

When more than one could apply, the first of these wins, in the order `court_internal`, `reminder_only`, `requirement`, `other`. A rule that only reminds filers of an existing duty, such as the duty to check their own work, is a `reminder_only` even when one of its yes or no fields says `yes`.

## Labels

| Label | What the rule is mainly about |
| - | - |
| `disclosure` | Saying that AI was used, or saying whether it was. |
| `certification` | A signed certificate that a person reviewed or verified content that AI generated. |
| `verification` | The filer's responsibility to check AI-generated text, citations or quotations, with no disclosure or certificate. |
| `prohibition` | A ban or limit on a use of AI. |
| `evidence` | AI in evidence or in proceedings: exhibits made or changed by AI, experts who rely on AI, AI transcription of hearings. |
| `other_ai` | AI is the main subject but none of the other labels fits, such as a general AI policy or permission to use AI. |

## Fields

A yes or no field holds `yes`, `no` or `unknown`. `yes` means the rule says the thing described and `no` means it does not. A field that lists values holds one of them or `unknown`. `not_stated` and `none_stated` are confirmed answers: the rule says nothing on the point.

| Field | What it says | Values |
| - | - | - |
| `req_disclose` | The rule asks the filer to tell the court or the other parties that AI was used, in a disclosure, a notice, a label or a statement. A duty that applies only if the court asks does not count. | `yes`, `no`, `unknown` |
| `req_certify_review` | The rule asks the filer to certify that a person reviewed or checked the content that AI generated. | `yes`, `no`, `unknown` |
| `req_certify_citations` | The rule asks the filer to certify that the citations or legal authorities were checked and are real. | `yes`, `no`, `unknown` |
| `req_certify_nonuse` | The rule asks for a statement about AI from every filer, including one who did not use AI, such as a certificate that says whether AI was used. A certificate owed only when AI was used does not count. | `yes`, `no`, `unknown` |
| `req_name_tool` | The rule asks the filer to name the AI tool that was used, in the filing or in a certificate. A duty to name it only if the court asks does not count. | `yes`, `no`, `unknown` |
| `req_mark_parts` | The rule asks the filer to identify which parts of a filing AI drafted. A duty to keep records, or to identify the parts only if the court asks, does not count. | `yes`, `no`, `unknown` |
| `req_confidentiality` | The rule asks the filer to certify that confidential, privileged or sealed information was kept out of an AI tool, or forbids putting it in. | `yes`, `no`, `unknown` |
| `req_not_allowed` | The rule forbids a use of AI, such as drafting filings, creating or altering evidence, or recording or transcribing proceedings. | `yes`, `no`, `unknown` |
| `no_requirement` | The rule adds no duty about AI: it says disclosure is not required, or only reminds filers of duties they already have, such as checking their own work. | `yes`, `no`, `unknown` |
| `court_own_use` | The rule is about how the court, its judges or its staff may use AI, such as an internal policy. It asks nothing of filers. | `yes`, `no`, `unknown` |
| `applies_when` | When the filer owes the disclosure, certificate or statement. | `only_if_ai_used` (only when AI was used to prepare the filing), `every_filing` (on every filing, whether or not AI was used), `not_stated`, `unknown` |
| `stage` | Which documents or stage of the case the rule covers. | `any_filing`, `pleadings_motions_briefs`, `discovery`, `evidence_trial`, `expert`, `proposed_orders`, `hearings_recordings`, `not_stated`, `unknown` |
| `binds` | Who must follow the rule. | `lawyers`, `self_represented` (parties without a lawyer), `lawyers_and_parties`, `experts`, `not_stated`, `unknown` |
| `how` | How the filer complies. | `separate_document` (a separate certificate, declaration, affidavit, notice or letter), `in_the_filing`, `signature_block`, `by_signing` (signing or filing the paper is the certification), `court_form`, `not_stated`, `unknown` |
| `exempt` | Which tools the rule exempts. | `research_tools` (legal research services and search engines), `basic_tools` (spelling, grammar and other tools that do not generate text), `research_and_basic`, `none_stated`, `unknown` |
| `consequence` | What the rule says happens when a filer does not comply. | `struck` (the filing may be struck, rejected or not considered), `sanctions` (sanctions, contempt, fees or discipline, including a referral to the bar), `none_stated`, `unknown` |

## Find the rules

The examples use a made-up court, judge and order.

### 1. Search a court

[`GET /api/v1/extracted-rules`](https://docs.courtrules.app/api-reference/extracted-rules) with `topic=ai_use` returns only the rules that have the topic. Add `district_id` for one court. The other filters of that endpoint work with it.

```bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
curl 'https://api.courtrules.app/api/v1/extracted-rules?topic=ai_use&district_id=example-court' \
  -H "Authorization: Bearer YOUR_API_KEY"
```

```json theme={"theme":{"light":"github-light","dark":"github-dark"}}
{
  "rules": [
    {
      "rule_id": "8f1c2a4e-6b3d-4f5a-9c7e-2d1b0a9e8f77",
      "district_id": "example-court",
      "judge_slug": "example-judge",
      "source_url": "https://courts.example.org/judges/example-judge/standing-order.pdf",
      "source_url_key": "example-standing-order",
      "document_version_id": "3b9d7c1e-5a2f-4e8b-a6d4-0c1f2e3d4b5a",
      "doc_kind": "standing_order",
      "logic_type": "DocumentRequirement",
      "workflow_phase": "FILING",
      "content": {
        "source_text": "Any attorney or party who uses generative artificial intelligence to draft a pleading, motion or brief must file a certificate with it that says so and states that a person checked every citation. Failure to comply may result in sanctions.",
        "summary": "An attorney or party who uses generative AI to draft a pleading, motion or brief must file a certificate that says so and that a person checked every citation. Failure to comply may lead to sanctions.",
        "rule_tags": ["ai_disclosure", "certificate"],
        "workflow_phase": "FILING",
        "visual_severity": "WARNING",
        "structured_data": {
          "logic_type": "DocumentRequirement",
          "location": "certificate_section",
          "required_elements": { "ai_disclosure": true }
        },
        "citation_source": { "section": "Section 4" }
      },
      "topics": {
        "ai_use": {
          "label": "disclosure",
          "kind": "requirement",
          "fields": {
            "req_disclose": "yes",
            "req_certify_review": "unknown",
            "req_certify_citations": "yes",
            "req_certify_nonuse": "no",
            "req_name_tool": "no",
            "req_mark_parts": "no",
            "req_confidentiality": "no",
            "req_not_allowed": "no",
            "no_requirement": "no",
            "court_own_use": "no",
            "applies_when": "only_if_ai_used",
            "stage": "pleadings_motions_briefs",
            "binds": "lawyers_and_parties",
            "how": "separate_document",
            "exempt": "none_stated",
            "consequence": "sanctions"
          }
        }
      }
    }
  ],
  "meta": {
    "total": 1,
    "returned": 1,
    "limit": 100,
    "offset": 0,
    "next_offset": null,
    "district_id": "example-court",
    "include_court_rules": true,
    "topic": "ai_use"
  }
}
```

`meta.total` counts the rules that have the topic, and paging works as it does for any search. Each rule is one row against your daily limit, however much its `topics` holds.

### 2. Read a judge's rules

[`GET /api/v1/rules`](https://docs.courtrules.app/api-reference/rules) returns a judge's rules in two layers, the court's and the judge's own, and each rule carries its `topics` when it has them. Read `kind` first, then `fields` for the detail.

```bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
curl 'https://api.courtrules.app/api/v1/rules?district_id=example-court&judge_slug=example-judge' \
  -H "Authorization: Bearer YOUR_API_KEY"
```

### 3. Keep the orders

Keep the rules that ask something of the filer, and show each one with the court's quote and its source.

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
orders = [
    rule
    for rule in page["rules"]
    if rule.get("topics", {}).get("ai_use", {}).get("kind") == "requirement"
]
for rule in orders:
    print(rule["judge_slug"], rule["content"]["source_text"], rule["source_url"])
```

## Behavior details

* **The filter returns every kind.** `topic=ai_use` returns reminders, mentions and a court's own policies as well as orders. There is no filter by `kind` yet, so check `topics.ai_use.kind` in each result.
* **The filter runs before the count and the paging.** `meta.total` and the pages are those of the rules that have the topic.
* **It combines with the other filters.** `district_id`, `judge_slug`, `include_court_rules`, `logic_type`, `workflow_phase`, `case_type` and `q` narrow the rules that have the topic.
* **A rule without the topic has no `topics`.** The field is left out, not empty. A rule that was read and found not to be about AI use looks the same as a rule that was not read.
* **Court-wide and judge rules both carry topics.** A court-wide rule has `judge_slug` `court`. Read both layers: a court-wide order applies to every courtroom of the court.
* **Rulebook requirements carry topics too.** A requirement read from a [rulebook](https://docs.courtrules.app/concepts/rulebooks.md) shows `topics` when it has them, but `topic` does not filter them. Sending `rulebook_id` with `topic` is a `400`.
* **Compliance profiles have no topics.** `/rules` and `/profile` return a compliance profile for a court that has one (`edny` today), and a profile carries no `topics`. Read that court's AI use rules with `/extracted-rules?topic=ai_use&district_id=edny`.
* **Order.** Rules come newest first, as they do for every search of `/extracted-rules`.

## Errors and limits

| Status | When |
| - | - |
| `400` | `topic` is not a topic the API offers. The answer lists the values it accepts. |
| `400` | `topic` is sent with `rulebook_id`. |
| `404` | `district_id` is a court we do not map, as for any search. |
| `500` | A temporary problem on our side. Retry the request. A rule is never returned without the topics it has. |

```json 400 theme={"theme":{"light":"github-light","dark":"github-dark"}}
{
  "error": "Invalid request",
  "details": [
    {
      "path": "topic",
      "message": "Invalid enum value. Expected 'ai_use', received 'ai'"
    }
  ],
  "docs_url": "https://docs.courtrules.app/api-reference/extracted-rules"
}
```

* **A rule appears once its document was read.** A court's new order is not an AI use rule in the API until its document has been read for the topic.
* **`unknown` is not an answer.** It means the answer was not confirmed, so do not read it as `no`.
* **Read the court's document before filing.** The API reports what a court's document says, and `source_url` links to it. It does not work out which rule governs a filing or whether a rule applies to your case.
* **A text or case-type search scans at most 10,000 rules.** With `topic` the scan covers only the rules that have the topic.

## Common mistakes

* **Counting every result as an order.** Results include reminders, mentions and a court's own policies. Count the rules whose `kind` is `requirement`.
* **Reading `topics.ai_use.label` as the duty.** The label names the subject. A rule labeled `verification` can still be a `requirement`, and a rule labeled `disclosure` can be a `reminder_only`.
* **Treating `unknown` as `no`.** `unknown` means the answer was not confirmed, and `no` means the rule does not say it.
* **Reading a missing `topics` as "no AI rule".** The rule may not be about AI use, or its document may not have been read for the topic.
* **Sending `topic` with `rulebook_id`.** Rulebook requirements cannot be filtered by topic yet.

## Related

* [Search extracted rules](https://docs.courtrules.app/api-reference/extracted-rules.md)
* [Get rules](https://docs.courtrules.app/api-reference/rules.md)
* [Read a court's rules](https://docs.courtrules.app/guides/read-court-rules.md)
* [Rulebooks](https://docs.courtrules.app/concepts/rulebooks.md)
* [Coverage](https://docs.courtrules.app/concepts/coverage-levels.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.