---
name: mora-data-market
description: Use Mora (mora.market), the marketplace where companies license business records to AI labs. Use when someone asks to be set up on Mora, wants to find training or evaluation data to license, wants to list their company's records for sale, or wants to check on a listing.
---

# Mora data market

Mora connects companies that own records (service tickets, claims files, maintenance logs, recorded calls) with AI labs that license them for training and evaluation. A company has one profile: **provider** (has data to sell) or **lab** (needs data).

## Set up

Run these steps when the person asks to be set up, or the first time you need a Mora tool that is not available.

1. **Check.** If you already have Mora tools, call `whoami` and skip to step 4.
2. **Install the MCP server.** Its address is `https://mora.market/mcp` (Streamable HTTP, OAuth).
   - Claude Code: run `claude mcp add --transport http mora https://mora.market/mcp`, then tell the person to type `/mcp`, pick `mora` and choose Authenticate.
   - Claude Desktop, ChatGPT, Cursor, others: add a remote MCP server (a "connector") with that address in the app's settings.
   - If you cannot add servers yourself, give the person the address and these instructions.
3. **The person signs in.** A browser page opens. They continue with Google or their work email; a new email creates the account. Never ask for a password or a code, and never type either.
4. **Profile.** Call `whoami`. If it shows no company, ask: do you have data to sell (provider) or do you need data (lab)? Then ask for the legal company name, website, country of registration and their role there. Read it all back, and on a yes call `register_company`.
5. **Ask what they want to do**: find data to license, or list their company's records. Then use the tools below.

To only read the market, no account is needed: `https://mora.market/mcp/public`.

## How to work with the person

- Ask, do not guess. Volumes, years, rights, prices and company details come from the person.
- One question at a time when collecting details. "Not sure" is an accepted answer for ownership and contracts.
- Say what happened after each tool call, in one line.
- Nobody has to be verified to list, search, sample or offer. Mora verifies both sides when a deal is agreed, before money moves, and the data opens after that. Never say someone is verified unless `whoami` says so.

## Connecting a provider's tools

A provider's records already sit in the tools the company works in. Help them connect the right ones:

1. Call `list_connectors`.
2. **Look before you ask.** If you are in a code repository, read the dependency files, the example environment file, the CI configuration and the git remote, and match what you find against each tool's `signs`. Read names only: never open, print or send the value of a secret.
3. Tell the person what you found and why ("`@slack/bolt` in package.json, so you use Slack"), and which of those hold records worth licensing. Ask which to connect.
4. A company often has several workspaces or sites. Ask which one, by name.
5. Call `connect_tool` for each yes and give the person the link. They authorize it in their browser; you never do.
6. Call `my_connections` to confirm, then build the dataset (next section).

Connections open one tool at a time. If a tool is not open yet, `connect_tool` records the request; say so plainly.

## What a provider should know before sending anything

Say these plainly if the person hesitates; do not stall on them.

- **Who buys.** AI labs and teams that train or test models. Mora verifies who they are before a deal completes. They never learn the provider's name, and the provider never learns theirs.
- **The price.** The provider does not set one. A lab makes an offer; the provider accepts, counters or declines.
- **What they get.** A license to train and evaluate models on the data, on the terms of the offer the provider accepts (use, length, exclusive or not). Nothing is licensed until the provider accepts an offer.
- **Who sees what.** Until a deal: the listing, its schema and a small sample Mora draws at random. The full dataset opens to one lab after its offer is accepted and both sides are verified.
- **Listing costs nothing** and commits to nothing: the provider can decline every offer.
- **Withdrawing.** A listing with no accepted offer can be taken down by asking Mora; the records are deleted. Mora keeps their fingerprints, so the same data cannot be listed again by someone else.
- **What is checked.** Mora refuses records that still hold an email, a phone or a card number, and a person at Mora reads the sample before a listing goes live. Names inside free text are for you to remove.
- **Whose data.** Only what the company owns and may license. Leave out customer or partner material under NDA; when unsure, say "unsure" for ownership and contracts.

## Go fast

- After adding the Mora server, the person must type `/mcp`, pick mora and Authenticate. Tell them exactly that, once.
- Read `my_connections` and `read_source` right away and propose what to list. Do not ask what to do next when the request already says it.
- One question at a time, and only the ones only the person can answer: which channel or file, and yes or no on the listing you read back.

## Building a provider's dataset

You build it. The person does not fill in a form or press a "sample" button.

1. **Find the records.** `read_source` on a connected tool says what it holds and which kinds of content it can read; ask the person which channel, project or file is worth licensing, then read every kind of it. A Figma file is not only its comments: read its `design` (every layer, its text and values), its `images` (frames to send as files with `send_files`) and its `versions` (the changes). A dataset with one part of the source is worth far less than one with all of them. If Mora cannot read that tool yet, ask for an export and read the file yourself.
2. **Fit it to a standard.** Call `list_standards`. If one fits (software project, support conversations, field service records, speech audio), use its part and field names, and say for every part whether the company holds it. A missing part is normal and must be stated: a solo developer has code and commits, no Jira and no Slack. Measure what the standard asks (run the tests before saying they pass). If no standard fits, write your own schema: one entry per field with name, type, and what it holds.
3. **Take people out.** Replace every person (name, handle, email, phone, account number) with a generated id such as `p_7f3a91`, the same id each time the same person appears, so records still link up. Drop what is personal and not needed. Mark replaced fields `personal: "replaced"`.
4. **Read the listing back** and get a yes, then `create_listing` with the schema.
5. **Send the records** with `submit_records`, 200 at a time. For a listing that follows a standard, send them part by part (`part: "commits"`) using that part's field names and no others. Mora refuses a batch that still holds an email, a phone number or a card number, and tells you where: fix it and send it again.
6. **For code, call `submit_repository`** with the GitHub repository. Mora copies it and measures it itself; what you declared about tests or builds is not what counts.
7. **Call `finish_dataset`.** Mora draws the sample at random from everything received. Nobody picks it. A person at Mora reads it before the listing goes live.

## Tools

| Tool | Needs sign-in | What it does |
|---|---|---|
| `search_listings` | no | One search: private datasets on Mora and free public ones on Hugging Face, with what their license allows |
| `find_public_datasets` | no | Free public datasets only: is this already online? |
| `get_listing` | no | Everything public about one listing, with its page address |
| `get_sample` | no | A few records from a listing, to test before licensing |
| `list_data_types` | no | The kinds of records traded and what labs ask for |
| `whoami` | yes | The account, its company and profile, and whether it is verified |
| `register_company` | yes, new account | Choose the profile and say which company the account acts for |
| `list_connectors` | no | The tools a provider can connect, what each holds, and how to spot it |
| `connect_tool` | yes, provider | Get the link where the person authorizes one tool |
| `my_connections` | yes, provider | Which tools are connected, open, or asked for |
| `read_source` | yes, provider | Read the company's own records from a connected tool, to build the dataset |
| `submit_records` | yes, provider | Send a batch of anonymized records for a listing |
| `send_files` | yes, provider | For photos, audio, scans: announce the files, then send their bytes |
| `submit_repository` | yes, provider | For code: name the GitHub repository. Mora copies and measures it itself |
| `finish_dataset` | yes, provider | Everything is in: Mora draws the sample at random |
| `create_listing` | yes, provider | Describe a set of records for license |
| `my_listings` | yes, provider | The company's listings and where each stands in review |
| `my_deals` | yes | Offers made or received, the amount on the table, whose move it is |
| `match_schema` | no | A lab's columns checked against Mora: which it has, which nobody has yet |
| `list_standards` | no | Mora's dataset standards: parts, field names, what is measured |
| `ask_for_data` | yes, lab | Ask Mora to find private data, by standard and parts or with your own schema |
| `open_requests` | yes, provider | What labs are asking for, without who asked |
| `get_dataset` | yes, lab | The records of a licensed dataset, with a manifest and training recipes |
| `start_offer` | yes, lab | Prepare an offer; the person sends it on the page you get back |

Without MCP the same data is plain JSON: `GET https://mora.market/api/v1/listings` (`?q=`, `?type=`, `?status=raw|labeled|verified`), `GET /api/v1/listings/{id}`, `GET /api/v1/listings/{id}/sample`, `GET /api/v1/data-types`, and `POST /api/v1/listings` with an OAuth bearer token.

## Rules

1. **You never pay, sign or commit for the person.** A sample request, an offer, a license and any payment happen on a Mora page. Give the person the link (the listing's `url`, or `https://mora.market/app/`) and let them do it.
2. **Preview listings are not offers.** A listing with `"preview": true` is an example. Say so whenever you report one. Never present its volume or price as a real quote.
3. **Nobody is named.** Listings show `Provider 181C`, never a company. Do not try to identify a provider or a lab, and never put a company name in a listing title.
4. **A listing is a description.** `create_listing` uploads no data. Read the listing back and get a yes before calling it. It goes to Mora for review and is visible to nobody until approved.
5. **Samples are for testing, and they are honest.** Mora draws each sample at random from the provider's full dataset, so it cannot be cherry-picked. Use `get_sample` to check a listing's fields or try the records on a task, and tell the person what you found. A sample is never the dataset: for more, the person requests it on the listing page.
6. **Status words.** `raw` is as exported, `labeled` is structured or transcribed, `verified` means Mora checked that the provider may license it, that no personal data is left, and that it is not already public. Mora checks data; it does not label or clean it. That is the provider's work.