Source: https://seerepo.com/docs/api-world
Markdown source: https://seerepo.com/docs/api-world.md
Description: One module of the map: its parts and where it connects.

# Get a module

`GET https://seerepo.com/api/v1/repos/:repo/world`

Returns one module of the map: what it does, its parts (each with a one-line phrase and, if it opens, the path to go inside), the modules it connects to and the outside services. Start at `/` and follow the paths. It never returns code.

At `/` it also says how the product runs, read from its code: an import that's never called doesn't count, and a link for a person isn't a call. What the repo doesn't say isn't made up.

## Request

| Parameter | Where | Description |
|---|---|---|
| `repo` | path | The repo's id, or owner/name with the slash written %2F. |
| `path` | query | The module's path, like /checkout. By default /. |

```sh
curl "https://seerepo.com/api/v1/repos/6ad79fd8e89233277ded17c9/world?path=/checkout" \
  -H "Authorization: Bearer $SEEREPO_KEY"
```

## Response

| Field | Type | Description |
|---|---|---|
| `data.repo` | object | The repo: its id and owner/name. |
| `data.parent` | string\|null | The module above it; null at /. |
| `data.cables[]` | object | The ties between its parts: from, to, the verb and how many. |
| `data.path` | string | The module's path. |
| `data.name` | string | Its name. |
| `data.phrase` | string | What it does, in one sentence. |
| `data.crumbs[]` | object | The modules above it, from /. |
| `data.parts[].name` | string | A part's name. |
| `data.parts[].type` | string | What it is: world, screen, action, machine, scheduled, data, people, machines, clock… |
| `data.parts[].phrase` | string | What it does, in one line. Empty in a free repo, except in the part that changes most, whose sheet comes whole. |
| `data.parts[].path` | string | Only if it opens: the path to go inside. |
| `data.parts[].file` | string | Only for a part that is one file: its path. |
| `data.tests.byUrl` | object | Only at `/`: the routes the tests call by their address, `routes` and `called`. A floor, and not coverage. Absent when the repo has no routes read. |
| `data.tests` | object | What test files import here: `files`, `named` (imported directly), `reached` (through those), and `parts[]` with each module's `path`, `name`, `files`, `named` and `reached`, the fewest first. At `/`, also `folders`: `tests`, the test files against the code by folder (`thinnest[]`, with `path`, `tests` and `files`, the thinnest first) and the ones in a folder of their own (`apart[]`). It isn't coverage: a test that only calls a URL isn't followed. Not in a free repo. |
| `data.comesFrom[] / data.goesTo[]` | object | The modules it connects to, with the verb (enters, uses, reads, writes to, calls, triggers), how many ties and their path. |
| `data.services[]` | object | The outside services (Stripe, Supabase…), at /. |
| `data.halfMade` | object | Only at `/`, and only when more than `ceiling` % (30) of the map's files sit in boxes it didn't design («+N more», what's inside one, a box by letters): `files`, `under` and `share`. The map is half made: read its names as the designed part. Comes with each repo's next scan. |
| `data.runs` | object | Only at /: how the product runs. Empty for a library, which doesn't run. |
| `data.runs.traced` | boolean | True when each process's services were followed by what it really names; false in a language without that yet, where they go by whole files. |
| `data.runs.entries[]` | object | Who comes in: people, agents, notices or timers, with how many and into which process. |
| `data.runs.processes[]` | object | What runs: its id, its kind (web, app, worker, job, edge), the file that says so, its name and what it does. |
| `data.runs.homes[]` | object | Where they live, when the repo says: Docker, Vercel, Cloudflare… |
| `data.runs.deploys[]` | object | What deploys them, when the repo says. |
| `data.runs.services[]` | object | What it uses: its name, how that's known (`how`), which processes use it (`usedBy`), the file and line, what it does, and `solid`: false when the code only suggests it. |
| `data.moduleRuns` | object | Only inside a module: who comes in (`entries`) and what it uses (`uses`), with the path of each module beside it. |

### Example

```json
{
  "status": "success",
  "data": {
    "repo": {
      "id": "6ad79fd8e89233277ded17c9",
      "fullName": "ana/tienda"
    },
    "path": "/checkout",
    "parent": "/",
    "name": "Checkout",
    "phrase": "Takes the payment.",
    "parts": [
      {
        "id": "pay",
        "name": "Pricing page",
        "type": "screen",
        "side": "product",
        "phrase": "Where the plans are picked.",
        "file": "app/pricing/page.tsx",
        "webRoute": "/pricing"
      },
      {
        "id": "hook",
        "name": "Stripe webhook",
        "type": "action",
        "side": "product",
        "phrase": "Turns the plan on once Stripe confirms.",
        "file": "app/api/stripe/route.ts"
      }
    ],
    "comesFrom": [
      {
        "world": "Engine",
        "verb": "uses",
        "n": 2,
        "path": "/engine"
      }
    ],
    "goesTo": [],
    "services": []
  }
}
```

## Authentication

An API key as `Authorization: Bearer sr_…`. See [Authentication](/docs/api#authentication).

## Errors

| Code | `code` | When |
|---|---|---|
| 400 | `bad_path` | The path doesn't start with /. |
| 402 | `plan_required` | A module inside a repo on the free look: its first level only. |
| 404 | `no_world` | No module at that path, or the repo has no map (for example, SeeRepo found no code it can read in it). |

Besides the ones every endpoint has (401, 404, 429), see [Errors](/docs/api#errors).