# Grundviden API > Danish property data per address, for integration into a customer's own systems: BBR, our price estimate with a range, land registry (Tinglysning: charges, loans, easements) and sales (EJF). One address per call; the home list is one page of homes per call. Base URL https://pro.grundviden.dk. Machine-readable contract: https://pro.grundviden.dk/api/v1/openapi.json. Human guide (Danish): https://pro.grundviden.dk/docs ## Auth - Header `X-Api-Key: gv_...` on every call. Never put the key in a URL. Keys are created by the customer at https://pro.grundviden.dk/keys once the account is active. A key is shown once. - In Claude or ChatGPT there is no key: add https://grundviden.dk/mcp as an MCP server with OAuth sign-in. Every route below is one tool (lookup_bbr = /bbr, list_homes = /homes, get_usage = /usage) with the same answer, counted and logged like a call with a key, on one counter shared by the account's connected programs. - Only active API customers (a company with a CVR number; on Data + Tingbog also a stated purpose under tinglysningsloven par. 50 c stk. 9) get an active account: https://pro.grundviden.dk/signup (the plan is picked first) ## Plans - Two plans, per company, ex VAT. Data (2.000 kr a month): every route except /land-registry; no purpose under the land-registry law is asked. Data + Tingbog (3.000 kr a month): everything including /land-registry (1.000 lookups per key per month); a purpose under tinglysningsloven par. 50 c stk. 9 is stated at sign-up and every land-registry lookup is logged. Prospecting follows the data source, not the plan: on both plans companies found through the data of any route except /land-registry may be contacted if CVR's advertising protection (`advertising_protected` on every company answer) is respected; people never (ENK, PMV and estates count as people); land-registry data never. An active Data customer upgrades at https://pro.grundviden.dk/upgrade. The plan names are working names. - What each plan holds (the same table as https://pro.grundviden.dk/#hvad): Data: BBR with the energy label, building right and plan provisions; the estimate with its interval, the trades behind it and listing history; EJF sale prices; the whole home list to the last page (`next_cursor`), also as CSV; companies with owners, management and the ownership chain up to ten levels, and the properties they own. Data + Tingbog adds `/land-registry`: owners with name and share, deeds with price, takeover date and parties, charges with every party, easements with their text, and a property by its BFE number. Not live yet: the register's documents as PDF on order (the documents route answers `not_available_yet` while ordering of documents is off). No date is promised for it. The party lists and special terms fill as properties are fetched: they are empty for most properties on the first day. - Test key: on request we issue a key that answers only fixed, invented test addresses from fixtures: never a real lookup, never counted against a cap, no rate-limit budget used. It answers every route a program that builds address suggestions uses: /api/v1/search (with the structure of every hit and `limit`), /api/v1/addresses/resolve (exact for "testvej 1", ambiguous 409 for "testvej", none for an address that does not exist), /api/v1/addresses/{address}/units, /api/v1/addresses/{address}/bbr (with `facts`) and /api/v1/addresses/{address}/estimate, in the real answers' shape, with the real routes' own refusals (a parameter name the route does not read is the same free 400) and every answer carries the header X-Fixture-Key: true; every other route answers 403 fixture_key_route. The test addresses: testvej-1-9999 (a house), testvej-3-9999 (a second house; the search text "testvej" finds both), testgade-2-9999 (a building with two units: testgade-2-9999-1-tv has a unit page, and the other, 1. th, is addressed by its unit_id); any other address answers 404 unknown_address. - Data: 2.000 kr a month ex VAT. Data + Tingbog: 3.000 kr a month ex VAT. The only route that differs is `/api/v1/addresses/{address}/land-registry`: Data + Tingbog only. Sale prices and dates (EJF) are on `/sales` in both plans. ## Address - `{address}` is the address id (uuid) or the slug, or - for one unit in a building with several units - the unit slug (`units[].unit_slug` in `/bbr`; the search's `/lejlighed/` urls). A commercial unit (office, shop) gets a price band on `/estimate` (`kind: "commercial_band"`), never a residential figure; the band exists only for office and shop units in Copenhagen municipality and needs enough trades, and where there is none the answer is `kind: "unavailable"` with `withheld_reason: "no_band"`, the same code `/comparables` gives for the unit. The band is a range, not a valuation: `commercial_band.spread_factor` is its width (the high end over the low end), the `note` says so from the band's own numbers, and the unit's `public_valuation` sits beside it as a second reference. The total is the band times the unit's BBR area; where BBR states none, the unit's registered (tinglyst) area is used and `commercial_band.area_source` says `registered` (the note says so too). Any area (BBR's or the registered one) makes a total only between 10 and 2,000 m2, the sizes the band was fitted on: outside them the answer is `kind: "unavailable"`, `withheld_reason: "area_out_of_range"`, with the per-m2 band in `commercial_band` and no total. A unit with neither area has nothing to multiply the band by: `kind: "unavailable"`, `withheld_reason: "no_area"`, no figure. A dwelling unit (a flat) gets the figure its flat page shows (`kind: "dwelling"`: `expected_dkk`, `low_dkk`, `high_dkk`, `comparables`, `radius_m`, `basis`), or `kind: "unavailable"` with `withheld_reason` and `note` exactly where that page shows none (`shared_bbr_unit`, `tied_area`, `multi_home_lot`, `listed_for_rent`, `listed_unexplained`, `no_model_figure`). Find the slug with the public search, URL-encoded: `curl -G https://grundviden.dk/api/soeg --data-urlencode "q="` (the `url` field ends in the slug), e.g. `strandby-have-22-2670`. - A building address with SEVERAL units has no single property, area or price. `/estimate` and `/land-registry` answer it with `status: "choose_unit"` and `units[]` (`unit_slug`, `floor`, `door`, `apartment_number`, `use_code`, `dwelling_type`, `area_bbr_m2`, `area_registered_m2`), with no data from any unit and without counting against the cap. Ask again with one `unit_slug` as `{address}`. `/bbr` lists the units itself. THE FLAT FOR SALE: the choose_unit answer also carries `listings[]`, the for-sale adverts at the address (`listing_no`, `asking_price_dkk`, `area_m2`, `rooms`, `floor`, `door`, `agent`, `url`, `first_seen`, `energy_label`), and per advert `unit.status`: `resolved` (the advert is one unit page: `unit_slug`, `unit_id`, and `resolved_by` says which of our matching rules found it), `candidates` (units that do not contradict the advert are listed in `candidate_unit_ids` and marked in `units[].listing_matches` with the reasons; none is chosen for you) or `none`. When exactly one home is for sale at the address and its advert is resolved, `/estimate` answers for that unit and says so in `resolved_from_listing` (counted as one lookup of that unit); with several adverts or only candidates it stays choose_unit. The `/api/v1/homes` rows carry `unit_slug` (null where the advert is not tied to a unit page). An address with one unit (a house, a single flat) answers as usual, and so does a house whose other BBR units are outbuildings (farm buildings, garage, carport, outhouse, greenhouse): that is one property, not a building to choose from. A house beside a workshop, shop, office or car park, or any address of outbuildings only, is still choose_unit. An address with a unit whose building has no entrance on record answers like an unknown address (404) on all three endpoints, never with a shorter list. - Every address lookup is one address. There is no search from a person to the properties they own personally (a sole trader counts as a person), and none will be added. The one list is `/api/v1/homes`, the home search (homes on the market, to let, at tender, or all addresses with a model price), which includes address-protected addresses, as the lookups do; no person is named. ## Endpoints (GET, JSON) - `/api/v1/addresses/{address}/bbr` - The full BBR record of the property the address stands on: buildings, units and plot, with the register's own fields, and `building_right`: what may still be built on the plot (a signed remaining floor area, negative where the home is already built past the plan; the allowed floor area; a status; whether the figure is indicative) with the calculation's caveats as codes, parameters and English sentences, and a code and sentence for why there is no figure where there is none, the same figures as the free /api/adresse byggeret block, the plan behind the percentage (`plan`: level, number, name, year adopted and the plan document's link) and its `height_limit_m`, `max_floors` (1.5 = one and a half floors) and `min_plot_m2`, a null explained in `building_right.null_reasons`; and `summary`: the figures the address page prints (home type house, flat or other; main use code; year built and rebuilt; dwelling, building, built-up and plot area; building count; homes on the property; shared-plot count) with the page's rules and the same values as the free /api/adresse bbr block, a null explained in `summary.null_reasons`, and the energy label (letter A-G, the register's class such as A2020, valid from and to, the label's id, and whether it is this building's own or a neighbouring building's with its distance) for the address and, where the register gives one per building, for each building. No extra charge. `facts` on every building, unit and plot, beside `record` (nothing is removed): the facts a customer shows, each {code, label, value, value_code, as_of}: `code` is BBR's field id (byg056), `label` BBR's own Danish field name, `value` a number for a number field or BBR's OFFICIAL text of the code for a coded field (null if the code is not in BBR's list), `value_code` the raw code for a coded field and null for a number, `as_of` the date the record was registered in BBR (registreringFra, ISO). Buildings: use (byg021), year built (byg026) and rebuilt (byg027), total, dwelling and built-up area (byg038, byg039, byg041), floors (byg054), heating (byg056), supplementary heating (byg058), water supply (byg030), drainage (byg031), outer wall (byg032) and roof (byg033); units: use (enh020), total and dwelling area (enh026, enh027), rooms (enh031); plots: water supply (gru009) and drainage (gru010). A field BBR does not hold for the record is left out. The words are BBR's official code lists (https://teknik.bbr.dk/kodelister), the same as the register's own pages; the site's own plainer words are not used here. The energy label's report link is not given: our copy of the register holds no certificate number to build it from; `energy_label.label_id` is the label number. A unit's area or rooms below 0 in BBR (-1: not registered) is null, reason in `null_reasons`. Counts against source `bbr` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/addresses/{address}/estimate` - Our estimate for the address with a low-high range, the number of comparables and the radius. A building of several flats answers `choose_unit` (free), and that answer carries `units_range`, the spread across its flats, not an estimate of its own. For an address it also carries `listing`: the address's primary advert (status, market sale or rent, the asking price, the agent's shop name (null with `agent_reason` code `agent_unknown` where the advert's name may carry an individual agent; this answer names no person), the link, area, rooms, first seen, last confirmed), our deviation from the asking price in percent or a code and sentence for why we do not give it, and the advert's own phrase where it says the price covers several homes, with the same values as the free /api/adresse til_salg block and a null explained in `listing.null_reasons`; an address with no advert answers `listing.exists` false. And `public_valuation`: the public property valuation in force, the final and the preliminary one the address page shows (year, property value, land value), whether the building is in the figure, what each figure covers (`covers`: `whole_property`, or `residence_part_only` where the register values the production land of a farm or a forest property separately, with the register's own parts in `preliminary_breakdown`, a sentence in `covers_note`, and the newest valuation that covers the whole property in `whole_property`), why land can be worth more than the property, and the source, with the same values as the free /api/adresse vurdering block and a null explained in `public_valuation.null_reasons`; no extra charge. A figure we do not stand behind is null and note says why. A unit slug (a flat) is answered by the flat page's own model: kind "dwelling" with the figure, range, comparables and radius, or kind "unavailable" with withheld_reason and note where the page shows no figure; either way it carries the same `listing` (the flat's own advert by our match: asking price, our deviation, energy label, the agent as the shop's name) and `public_valuation` (the flat's final and preliminary valuation, in the same fields as for an address) blocks; a unit with no unit page (asked by unit_id) is kind "unavailable" with withheld_reason no_unit_page and the whole property's `public_valuation` (not the unit's). No figure (`estimate.withheld_reason` set): free, not counted. Notes are English sentences in the API's own words; the codes are what to branch on. Counts against source `estimate` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/addresses/{address}/comparables` - The trades our estimate for the address rests on, so the number can be checked: per trade address, month (YYYY-MM), price, area, price per m2, distance, same_building, same_street, same_unit_traded_again and the url of the traded home's public page; nearest first, at most 50, with total_trades_behind_estimate (what the number rests on), listed_trades_available (what we can list, before the 50 cap) and the selection window. Trades at address-protected addresses are listed like any other, as in the address lookups; no person is named. Only trades the estimate really uses; where the page shows no figure the answer is the same withheld_reason and no trades. subject_own_trades are the property's own EJF sales, not part of the estimate unless counted_in_estimate is true. All fields are EJF and already public. Counts against source `estimate` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/addresses/{address}/plan-rules` - The plan provisions that apply to the address, verbatim in the plans' own Danish, grouped by plan (number, name, document link, year), each with paragraph, heading, topics, status (in_force, maybe_repealed, repealed) and page; at most 200, truncated says when the cap bit. Counts together with /bbr (source bbr). Counts against source `bbr` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/areas/{area}/buyer-origin` - Where the people who bought in a postcode or municipality came from, by year: area statistics only, never per address. `area` is a four-digit postcode or municipality code. Per year `buyers` and the percent from the same municipality, elsewhere in the region or another region; a year with under 10 buyers is `withheld`. One `bbr` lookup per area per 24 h; no year shown is free. Counts against source `bbr` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/addresses/{address}/listing-history` - The advert history of the address, or of one unit: every time the home was advertised (`listings`, oldest first) with the agent's shop name (null with `agent_reason` where the advert's name may carry an individual agent), the advert's link, first and last night we saw it, the date it came on the market and the days on market (`days_on_market`; null with a reason where no start is known), and EVERY asking price it stood at (`prices`: the price, the day we first saw it, the day it was replaced, the change in kroner and percent). From our own listing history, which starts on 14 July 2026: `history_starts` and `history_note` say so in every answer, and `seen_from_first_day` is false for a home that was already on the market when we first saw it (its earlier prices are not known). A rent advert's price is the monthly rent (`price_period`). Counted on the estimate cap, together with /estimate: the same property read again within 24 hours is one count. A building address with several units answers `choose_unit` like /estimate; pass a unit slug for that unit's adverts. Counts against source `estimate` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/addresses/{address}/sales` - The sale prices and dates of the property the address stands on, from EJF's sale register (EJF, not Tinglysning): per sale the takeover date, the agreement date, the price, the transfer type, how many addresses the deal covers and whether the price covers several properties. Never a buyer or a seller. It is the `sales` block of `/land-registry` as its own route, so the Data plan keeps it. Counted against the estimate cap; the same property read again within 24 hours counts once. A building address with several units answers `status: "choose_unit"`. Counts against source `estimate` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/addresses/{address}/travel` - Travel between two addresses: `{address}` is the start and `to` (required) the other end. Returns `car`, `bike` and `walk` (`minutes`, `km`; the car time is without traffic), `straight_line_km`, `from` and `to` with latitude and longitude, and `car.tolls`: each toll crossing on the car route with the van list price per vehicle class (the operator's own list, `source_url`, `read_on`). One toll is known, Storebæltsbroen, read from the route's own path. No ferries yet: a pair that needs one is `available: false`, `no_route`. One `bbr` lookup per pair; no route in any mode, the same address twice and a 202 are free. A slow route answers 202 `route_computing`: ask again with the same request. Counts against source `bbr` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/addresses/{address}/land-registry` - Charges (type, amount and currency, interest rate where the type has one and how the rate is set, loan type, special terms, priority, date, document id, every lender, notified party, pledgee and attorney of the charge, the owners and each charge's debtors with their share), the transfers (deed records with the amounts the deed states and their owners), easements (with the register's wording) and a copy date from Tinglysning; sales (price and date) from EJF. Names of owners, debtors and private lenders as the register states them, from a copy at most 24 hours old, for your internal use and the stated purpose; no birth date and no address of a person. Counts against source `land_registry` (cap 1,000 per key per calendar month). Plan: Data + Tingbog only. A Data key gets 403 plan_does_not_include_route on this route, free and not counted. - `/api/v1/properties/{bfe}/land-registry` - The same land-registry answer as /addresses/{address}/land-registry, for a property named by its BFE number alone: charges, easements, the owners and each charge's debtors with their names as the address route gives them, and a copy date from Tinglysning, and the EJF sales, with the same plan, the same monthly cap, the same once-per-property-per-24-hours counting and the same ordering of a copy we do not hold yet. It is where `land_registry_path` of every row of /companies/{cvr}/properties points, so a company's properties with their charges need no address: a property with none, a building owned as a whole and a flat all work the same. The answer has no `address` block (there is no address) and no choose_unit: a BFE is one property. `property.how_resolved` is `bfe`. A BFE that is not digits is a 400 invalid_request, a BFE nothing of ours knows a 404 unknown_property (both free). A property we hold no copy of is ordered by its BFE alone (no address needed): the answer says ordered, and the same call later returns the record. Counts against source `land_registry` (cap 1,000 per key per calendar month). Plan: Data + Tingbog only. A Data key gets 403 plan_does_not_include_route on this route, free and not counted. - `/api/v1/addresses/{address}/land-registry/documents/{document_id}` - The register's own document behind one charge, easement or transfer of the property: the PDF exactly as the land registry gives it (older documents may be scans). Take `document_id` from the `/land-registry` answer of the same address. A copy held and under 24 hours old answers the PDF at once (Content-Type application/pdf); otherwise the call orders it and waits up to 8 seconds, so most calls answer the PDF; else 202 and the same call after `retry_after_seconds` answers it. An order that ends without the document answers 200 JSON `order_failed` with a `reason` and the unit is given back by itself. One document counts one land_registry lookup per key per 24 hours. Counts against source `land_registry` (cap 1,000 per key per calendar month). Plan: Data + Tingbog only. A Data key gets 403 plan_does_not_include_route on this route, free and not counted. - `/api/v1/addresses/{address}/units` - Every unit under the entrance of the address (a flat building's flats, a house's one unit), so a suggestion box can ask which flat. The SAME units the search lists for an entrance (DAR's door addresses of it, plus the BBR units of the entrance that no door address names), so every `dar_id` a search hit carries is here: per unit `dar_id` (DAR's address id of the door; one row per door), `unit_id` (the BBR unit id, null where the door has no BBR unit), `unit_slug` (the unit page's slug, null where the unit has no page), `slug` (the key to pass as {address} to the other routes: the unit page slug, else the BBR unit id; null only where the door has neither), `floor` and `door` (DAR's own for the door, else the unit page's, else BBR's; null where none holds one), `apartment_number`, `use_code`, `dwelling_type`, `area_bbr_m2`, `area_registered_m2` and `rooms`. In order st, 1, 2 ...; at most 500 (`truncated` says whether more were found). `units_found` is what we found, not a register total: `found_capped` is true when our reads hit their caps (2.000 doors, 500 BBR units). An address with none of its own lists its parcel's units, as `/bbr`. Counted on the search source, one request one count, never once per property, and free of the BBR, estimate and land-registry caps. {address} is an address id or slug, or a unit slug or unit id (then the units of that unit's entrance). An unknown address is a free 404. Counts against source `search` (cap 200,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/homes` - The full home search, the paid level of https://grundviden.dk/api/boliger: the same filters, sorts and markets (m = salg, leje, udbud or adr), with EVERY filter including our own calculated ones (climate, noise, flood, price against our estimate, building rights ...), every page up to `pages` (at most 5.000 pages of 30 with `side`; every page of any search with the cursor `next_cursor` / `after`, one counted lookup per page, at a cost that does not grow with depth), and the full card of each home. `homes[]` is the search card's own record under English field names (`price_dkk`, `area_m2`, `rooms`, `built_year`, `energy_label`, `deviation_pct` ...; every field is in the home schema of openapi.json and in the glossary in /docs). `id` is the advert's id, unique per advert (with m=adr a row is an address and every id is 0: use `address_slug`); `address_slug` is the address slug for the /addresses/{address} lookups (the flats of one building share it); `unit_slug` is the flat's own page slug, or null where the advert is not tied to a unit page. `agent` is the advert's shop name, null where it carries the name of the listing's own agent. Protected addresses are included, as in the address lookups; no person is named. `side` is the page of 30 homes. A value we cannot read, and a parameter NAME we do not read (a typo, `postnr=2000` for `omr=postnr:2000`), are each a 400 invalid_request, never a guess, and cost nothing. One page with homes on it is one counted lookup; a page with no homes (past the last, or a search nothing matches) costs nothing. `format=csv` answers the same page as a CSV table (UTF-8 with a byte order mark, comma separated, or semicolon separated with `delimiter=semicolon` for Danish Excel, a header row, the same rows under English column names; the page, total and unknown parameters in the headers X-Page, X-Pages, X-Page-Size, X-Total and X-Unknown-Parameters) for the same one count; `format=json` is the default. At most 2 requests at the same time and 60 a minute per key; over it the answer is 429 rate_limited with Retry-After. Counts against source `homes` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/search` - The free search box's answer (addresses, streets, areas, schools, companies ...) for q (and u): items with url, tekst, type, note, lat and lon, the register's own Danish names, plus `slug` and `address_slug` on every item. A query with a house number, a floor and a door that exist ("aaboulevard 12 2 tv 2200") returns that home FIRST (type bolig, `floor`, `door`, `unit_id`), its `slug` being the one to pass as {address}: its unit page slug, else its BBR unit id. EVERY ADDRESS HIT (a building, type adresse, or a home, type bolig) also carries its structure: `kind` (access = a building or house, unit = one home), `dar_id` (the DAR address id: a unit's own; an access with homes: the access address id; a house: its one address id), `entrance_dar_id` (the building's, on every hit), `street`, `house_number` ("10A"), `floor` and `door` (null on an access), `postcode`, `city`, `has_units`. EVERY HOME HIT (kind unit) is also named the way a row of /addresses/{address}/units is: `unit_id` (the BBR unit standing at the door, null where it has none), `unit_slug` (the unit page, null without one) and `slug` (the key to pass as {address}: the unit page slug, else the BBR unit id; null only where the door has neither): join a hit to a /units row on `dar_id` or `unit_id`. Streets, areas, companies and the "see all homes" row carry none of these. `limit` (a whole number 1 to 10; anything else is a free 400) cuts the number of address hits, best first; leave it out for the full list. A key's calls are not rate-limited per minute by the free site's allowance; one request counts one lookup. Counts against source `search` (cap 200,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/addresses/resolve` - Free text to ONE address: `text` (1 to 200 characters, the address as a person writes it, e.g. "testvej 10a 1620" or "testvej 10 1620 3 th") answers `match` exact, ambiguous or none. exact (200): `address` is the hit, the same shape as an address hit of /search with a `score` of 1, `candidates` empty. ambiguous (409 `ambiguous`): the text names more than one address (the same street and number in two towns, a typo, a floor the building does not have), or only part of one (a house number with a range, "10-12", is not one house number: it matches the buildings 10 and 12 only in part, so it is ambiguous, never a guess); `candidates` (at most 10, best first, each a /search address hit with its `score` from 0 to 1: the weighted share of what you typed that the hit has) is in the body beside the error envelope, `address` null. none (200): the search found no address. Without a floor and door in the text only buildings are candidates; with them the home is a candidate beside its building. Counts on the SAME source and cap as /search (one lookup for a 200 and for a 409; a 400 is free), never on /bbr. The text is never logged as typed. Counts against source `search` (cap 200,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/companies` - Companies and persons of the CVR register, with the free list's own filters, sorts and page: result.antal, side, sider and virksomheder (the rows). A search result page: at most 400 pages of 30 (5.000 for a key whose owner holds the data service) with `side`, and EVERY page of the register with the cursor: `result.next_cursor` on every page, sent back as `after` (see the parameter) one counted lookup a page. A person scope or a name search sorted by relevance has the cursor too, except relevance WITH a text query (then `next_cursor` is null: page it with `side`). Protected persons are never listed. Person rows list companies[] (person_id). advertising_protected is the CVR register's own mark: true = the company has asked not to be used for direct marketing, false = it has not, null = the register gives no value. It binds anyone who contacts companies found through our data. Counts against source `companies` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/companies/{cvr}` - Everything we hold on one company by its eight-digit CVR number: the record is the free answer (register fields, accounts, owners, ultimate owners, management, auditors, our own estimates), with the names of address-protected persons served as the register gives them (the free site and the free API never name them). Counts together with /companies. advertising_protected is the CVR register's own mark: true = the company has asked not to be used for direct marketing, false = it has not, null = the register gives no value. It binds anyone who contacts companies found through our data. Counts against source `companies` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/companies/{cvr}/properties` - The properties a company owns directly, from the EJF ownership register: per property the BFE number, `land_registry_path` (the path of that property's land-registry lookup, for EVERY row: /api/v1/properties/{bfe}/land-registry), `lookup_key` (the value to pass as {address} to the address routes for this property: a flat's own unit slug, else the address slug, null where we cannot place the property on an address), `address_slug` (the building's address, for the /addresses/{address} lookups; null where we cannot place the property on an address), the address (a flat's own), `unit_slug` (a flat's page slug: pass it as {address} for that flat), `share` (the sum of the fractions the register states for this company on the property: 1 is sole ownership, a part owner is below 1, and it is never above 1; `ownership_records` is the number of live registrations for the company on the property: 1 since 16.11.2026, kept as a stable field) and `last_transfer_date` (the takeover date of the property's latest registered transfer). `scope` is `direct` (the default: what the company owns itself, nothing its subsidiaries own) or `chain` (the company and every company below it in the ownership tree, the free portfolio page's walk, deeper: at most ten levels; a ceased company is listed and flagged `ceased`; companies whose legal form is a natural person's are left out and counted in `excluded_holders`): each property then carries `held_by` (the owning company, its `legal_form`, `legal_form_unknown` and depth) and `held_via` (the path of companies from this one down to the holder). 100 properties a page ordered by BFE, `side` is the page. Address-protected addresses are included, as in the address lookups; no person is named. A sole proprietorship, a personally owned small business and an estate are owned by a natural person, and the list is empty for them with `withheld_reason` person_owned_form: this API lists no natural person's properties; an unknown legal form is LISTED (`legal_form` null, `legal_form_unknown` true). Counts together with /companies as one lookup per page; an answer with no property in it (including a page past the last) is free. advertising_protected is the CVR register's own mark: true = the company has asked not to be used for direct marketing, false = it has not, null = the register gives no value. It binds anyone who contacts companies found through our data. Counts against source `companies` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/properties/{bfe}/ownership-history` - The owners of one property over time, from EJF, by its BFE number: `ownership_history[]`, oldest first: `owner` (`kind` company: cvr, name, legal_form; person: name), `share`, `registered_share` (the land register's share: a buyer is registered from the deed, the actual owner from the takeover), `owned_from`, `owned_to`, `current`. Data + Tingbog lists people and one-person businesses by name; on Data they are not shown: `withheld_periods` counts them and `persons_note` says so. `source` is the credit line (Geodatastyrelsen, Ejerfortegnelsen, date). Counts with /companies; an answer with no listed period is free. Counts against source `companies` (cap 100,000 per key per calendar month). Plan: included in both plans (Data and Data + Tingbog). - `/api/v1/usage` - this key's use this month per source. Does not count. ## Example ``` curl -H "X-Api-Key: $GV_KEY" \ https://pro.grundviden.dk/api/v1/addresses/strandby-have-22-2670/estimate ``` Response (real, trimmed to the fields shown): ```json { "address": { "id": "bcd4669f-0f02-44db-ae76-2db26c63bdb3", "slug": "strandby-have-22-2670", "street": "Strandby Have", "number": "22", "postcode": 2670, "city": "Greve", "municipality_code": "0253", "municipality_name": "Greve", "latitude": 55.59517, "longitude": 12.33795, "parcel_number": "3dø", "cadastral_district_code": "40652", "null_reasons": {} }, "estimate": { "expected_dkk": 5175000, "low_dkk": 4925000, "high_dkk": 5450000, "comparables": 120, "radius_m": 452, "withheld_reason": null, "note": null }, "listing": { "exists": false, "null_reason": "No active or recent listing is registered for this address." }, "public_valuation": { "in_force": null, "final": null, "preliminary": null, "whole_property": null, "land_only": null, "homes_in_valuation": null, "note": null, "covers_note": null, "preliminary_breakdown": null, "land_above_property_note": null, "land_above_property_source": null, "null_reasons": { "in_force": "We have no public valuation for this property.", "final": "We have no public valuation for this property.", "preliminary": "We have no public valuation for this property.", "whole_property": "We have no public valuation for this property.", "land_only": "We have no public valuation for this property.", "homes_in_valuation": "We have no public valuation for this property.", "note": "We have no public valuation for this property.", "covers_note": "We have no public valuation for this property.", "preliminary_breakdown": "We have no public valuation for this property.", "land_above_property_note": "We have no public valuation for this property.", "land_above_property_source": "We have no public valuation for this property." }, "source": "Vurderingsstyrelsen's public property valuation, our copy, through the address page's own model: the same figures as the free /api/adresse vurdering block (docs https://grundviden.dk/om/kilder)" }, "source": "grundviden.dk model; docs https://grundviden.dk/om/kilder" } ``` ## Cookbook: the three common tasks (real-shaped examples: the field names are the live ones, every slug, id, CVR number and figure is made up) ### 1. A flat for sale: what is it asked at, and what do we think it is worth List the flats for sale (one page of 30 homes is one counted `homes` lookup): ``` curl -G -H "X-Api-Key: $GV_KEY" https://pro.grundviden.dk/api/v1/homes \ --data-urlencode "m=salg" --data-urlencode "omr=postnr:2000" --data-urlencode "type=lejlighed" ``` A row of `homes[]`, trimmed. The asking price (`price_dkk`) and our deviation from our estimate (`deviation_pct`, percent) are on the row. `id` is the advert, `address_slug` is the BUILDING's address slug (the flats of one building share it: never de-duplicate by it), `unit_slug` is the flat's own page or null: ```json { "id": 11234567, "address_slug": "eksempelvej-12-2000", "address": "Eksempelvej 12, 3. th, 2000 Frederiksberg", "status": "for_sale", "price_dkk": 4995000, "deviation_pct": -3, "area_m2": 87, "rooms": 3, "energy_label": "C", "agent": "Eksempel Bolig", "unit_slug": "eksempelvej-12-2000-3-th" } ``` If `unit_slug` is a string, ask for that flat (the unit's answer has `estimate` with `kind: "dwelling"`, or `kind: "unavailable"` with `withheld_reason` where the flat page shows no figure): ``` curl -G -H "X-Api-Key: $GV_KEY" https://pro.grundviden.dk/api/v1/addresses/eksempelvej-12-2000-3-th/estimate ``` ```json { "address": { "slug": "eksempelvej-12-2000", "street": "Eksempelvej", "number": "12", "postcode": 2000 }, "unit": { "unit_id": "...", "slug": "eksempelvej-12-2000-3-th", "floor": "3", "door": "th", "bfe": 0 }, "estimate": { "kind": "dwelling", "expected_dkk": 5075000, "low_dkk": 4575000, "high_dkk": 5600000, "comparables": 40, "radius_m": 107 }, "source": "grundviden.dk ..." } ``` If `unit_slug` is null, ask for the BUILDING with `address_slug` as `{address}`: ``` curl -G -H "X-Api-Key: $GV_KEY" https://pro.grundviden.dk/api/v1/addresses/eksempelvej-12-2000/estimate ``` The answer is either already for the one unit the advert is tied to (`resolved_from_listing` with `listing`, `note` and `resolved_by`; counted as one lookup of that unit), or `status: "choose_unit"` as below. Then match the advert's `floor` and `door` to `units[].floor` and `units[].door`; `units[].listing_matches` names the rules that fit and `candidate_unit_ids` the units that do not contradict the advert. None is chosen for you. Ask again with the chosen unit's `unit_slug` (the answer for it names the unit as `unit.slug`). `choose_unit` is free. ```json { "status": "choose_unit", "units": [ { "unit_slug": "eksempelvej-12-2000-3-th", "floor": "3", "door": "th", "area_bbr_m2": 87, "listing_matches": ["floor", "door"] }, { "unit_slug": "eksempelvej-12-2000-3-tv", "floor": "3", "door": "tv", "area_bbr_m2": 64 } ], "listings": [ { "listing_no": 11234567, "asking_price_dkk": 4995000, "floor": "3", "door": "th", "unit": { "status": "candidates", "candidate_unit_ids": ["..."] } } ], "units_range": { "priced_units": 8, "registered_units": 9, "low_dkk": 2150000, "high_dkk": 4300000, "per_m2_low": 31000, "per_m2_high": 49000 }, "units_range_reason": null } ``` `units_range` on a choose_unit answer is what the free page prints for the building: the lowest and highest of the estimates of its flats (`low_dkk`, `high_dkk`, `per_m2_low`, `per_m2_high`), with `priced_units` out of `registered_units` residential flats. A spread across flats, not an estimate of the building. With fewer than two priced flats it is null and `units_range_reason` is `no_flat_priced` or `one_flat_priced`, with `units_range_note`. ### 2. The homes for sale in a postcode that are asked under our estimate ``` curl -G -H "X-Api-Key: $GV_KEY" https://pro.grundviden.dk/api/v1/homes \ --data-urlencode "m=salg" --data-urlencode "omr=postnr:2000" \ --data-urlencode "afvmax=-1" --data-urlencode "sort=afv" --data-urlencode "side=1" ``` `afvmax=-1` is INCLUSIVE and in whole percent: it keeps homes asked 1 % or more under our estimate (so -1 is in, 0 is out). `sort=afv` puts the lowest first (`afvmax` and `sort=afv` are parameter names; the field on the row is `deviation_pct`). The area is `omr=postnr:2000` (or just `omr=2000`); `postnr=2000` is a 400 that names `omr=postnr:2000`. Page with `side=1,2,...` until `page` equals `pages` (a page past the last answers 200 with an empty `homes` and costs nothing). Every page with homes on it is one counted lookup. Check on every page that `total` stays the same, and de-duplicate by `id` (with m=adr, by `address_slug`): ```json { "total": 82, "page": 1, "pages": 3, "page_size": 30, "homes": [ { "id": 11234567, "deviation_pct": -19, "price_dkk": 3995000, "unit_slug": null }, "... 29 more rows, deviation_pct rising from -19 towards -1" ], "unknown_parameters": [], "interpreted": {}, "language_note": "...", "source": "..." } ``` ### 3. What a company owns Find the CVR number with the paid search; a company item has no `cvr` field, the number is in `url` (`/firma/-`): the digits before the first hyphen. ``` curl -G -H "X-Api-Key: $GV_KEY" https://pro.grundviden.dk/api/v1/search --data-urlencode "q=Eksempel Ejendomme" ``` ```json { "items": [ { "url": "/firma/12345678-eksempel-ejendomme-aps", "tekst": "EKSEMPEL EJENDOMME APS", "type": "firma", "note": "2000" } ] } ``` A person's companies: a person row of `/api/v1/companies?m=person&q=...` lists `companies[]` (`cvr`, `name`, `status`, `ceased`, `url`, `ownership` with `share`, `share_low`, `share_high` as fractions of 1 where the register gives one, and the person's own `roles[]`: `group`, `organ`, `function`, `from`, `to`, `current`), `companies_total` and `companies_truncated` (at most 100 companies a person, current first); no other person is named in it. They are listed only when the call names ONE person: a name that matches at most 10 persons (first page only, never a page with `after`), or `person_id` (the number on every person row) for exactly that person. Otherwise `companies` is null with `companies_withheld_reason` name_not_specific_enough and a `companies_withheld_note`: narrow the name or ask by `person_id`. `/api/v1/companies/{cvr}` gives the company's record (the register's Danish field names). `/properties` lists what it owns DIRECTLY, 100 a page ordered by BFE: page with `side` until `page` equals `pages`; the totals are `total` and `without_address`. Each property's `address_slug` (the building) or, for a flat, `unit_slug` is an `{address}` for the address endpoints. `share` is the fraction the register states for the company on the property: 1 is the sole owner, below 1 a part owner, never above 1 (`ownership_records` is the number of live registrations, 1 since 16.11.2026): do not read it as a percentage owned. ``` curl -G -H "X-Api-Key: $GV_KEY" https://pro.grundviden.dk/api/v1/companies/12345678/properties --data-urlencode "side=1" ``` ```json { "company": { "cvr": 12345678, "name": "Eksempel Ejendomme ApS", "legal_form": "APS", "ceased": false }, "scope": "direct", "total": 324, "pages": 4, "page": 1, "page_size": 100, "without_address": 0, "properties": [ { "bfe": 1234567, "land_registry_path": "/api/v1/properties/1234567/land-registry", "lookup_key": "eksempelvej-12-2000-3-th", "address_slug": "eksempelvej-12-2000", "address": "Eksempelvej 12", "floor": "3", "door": "th", "unit_slug": "eksempelvej-12-2000-3-th", "share": 1.0, "ownership_records": 1, "last_transfer_date": "2023-02-01" } ], "withheld_reason": null } ``` `scope=chain` also lists what the companies BELOW it in the ownership tree own (at most ten levels; a ceased company is listed and flagged `ceased`; companies whose legal form is a natural person's are left out and counted in `excluded_holders`; a company whose form no register states is listed with `legal_form` null and `legal_form_unknown` true). Same answer, `scope: "chain"`, `holders` (the number of owning companies), `ceased_holders` (how many of them are ceased), and two fields more on every property (each company in them carries `ceased`): ``` curl -G -H "X-Api-Key: $GV_KEY" https://pro.grundviden.dk/api/v1/companies/12345678/properties --data-urlencode "scope=chain" ``` ```json { "held_by": { "cvr": 87654321, "name": "Eksempel Datter ApS", "legal_form": "APS", "legal_form_unknown": false, "depth": 1, "ceased": false }, "held_via": [ { "cvr": 12345678, "name": "Eksempel Ejendomme ApS", "ceased": false }, { "cvr": 87654321, "name": "Eksempel Datter ApS", "ceased": false } ] } ``` A company's properties with their charges, in two steps (Data + Tingbog). Step 1 is the call above; every row has `land_registry_path`. Step 2 calls it: ``` curl -G -H "X-Api-Key: $GV_KEY" https://pro.grundviden.dk/api/v1/properties/1234567/land-registry ``` ```json { "status": "held", "property": { "bfe": 1234567, "how_resolved": "bfe" }, "copy_date": "2026-10-27T02:31:24Z", "charges": [ { "type": "realkreditpantebrev", "amount_dkk": 1696000, "priority": 2, "lender": { "name": "Eksempel Kredit A/S", "cvr": "12345679" } } ], "...": "easements, sales, notes" } ``` Repeat step 2 per property: every row has a path, also a row with no address. Check that `property.bfe` equals the row's `bfe` only if you use `lookup_key` on an address route instead (about 0,4 % of address keys resolve to another property). Counting: `/search` is one lookup of source `search`; `/companies/{cvr}` and every `/properties` page count as source `companies`; an answer with no property in it is free. A sole proprietorship, a personally owned small business and an estate answer with an empty list and `withheld_reason: person_owned_form`: this API lists no natural person's properties. ## The home list: the filters most used (all 111 are in openapi.json, each described in English) - `m` - The market (default salg). salg: homes for sale. leje: homes to let. udbud: homes sold by tender or auction. adr: ALL addresses with our model price and no advert (millions of rows: narrow it with a filter). Filters that only make sense on an advert, such as afvmax, answer 400 in adr. - `omr` - The area, one of: kommune: | postnr: (or just the four digits) | by: | bydel: | landsdel: | bbox: (WGS84). The slug is the one in grundviden.dk's own links. NOT `postnr=2000` as a parameter of its own: an unknown parameter name is a 400 invalid_request (detail.code unknown_parameter, detail.did_you_mean names `omr=postnr:2000`). - `type` - The home category; several separated by a comma. hus: detached house, two-family house, home with business. landejendom: farm or smallholding. raekkehus: terraced house. lejlighed: owner-occupied flat. fritid: holiday home, allotment cabin. andel: co-operative flat. grund: plot, holiday plot. almen: social housing (family, youth, elderly). - `prismax` - Highest asking price, in DKK (on m=adr: the highest model price). - `afvmax` - The highest deviation of the asking price from OUR estimate, in whole percent, INCLUSIVE: (asking price - our estimate) / our estimate. Negative: priced below what we expect; positive: above. afvmax=-1 keeps homes asked at 1 % under our estimate or lower (so -1 is in, and 0 is out); afvmax=0 also keeps those at our estimate. The home row's `afv` is the same number; sort=afv lists the lowest first. Homes with no estimate have no afv and are not returned when this is set. - `arealmin` - Smallest living area, in m2. - `vaermin` - Fewest rooms. - `energifra` - The best energy label accepted, A to G (A is best). Use with energitil for a range. - `nedsat` - 1: only homes whose asking price has been reduced since we first saw them. - `sort` - The sort order; the valid ids depend on the market (m). salg: ny (newest first, the default), aabent (open house first), prisop (cheapest first), prisned (dearest first), kvm (lowest price per m2), liggetid (longest on the market), afv (lowest against our estimate first: the most under our estimate), reno (most to gain from renovating per m2). leje and udbud: ny, prisop, prisned, kvm, liggetid. adr: prisnedadr (highest model price, the default), prisopadr, areal (largest home), grund (largest plot), byggeret (largest unused building right), nyest (newest built), aeldst (oldest built). An id the market cannot answer is a 400. - `side` - The page, a whole number from 1. A page is 30 homes and is one request, which is one counted lookup. `pages` in the answer is the last page that exists (at most 5.000; past it continue with `after`, the cursor `next_cursor` gives); a page past it answers 200 with an empty `homes` list and counts like any other request. - `after` - The cursor of the next page: the `next_cursor` of the page before it, sent back with the same search parameters and without `side`. It reaches every page of every search, one counted lookup per page, at a cost that does not grow with depth; it is opaque, belongs to its own search and sort and lasts seven days. ## The home row: every field of `homes[]` (all can be null: a value the advert, the register or our model does not give is null, never an empty text or 0) - `id` (integer) - Our id of the home row: the advert's own id, unique per advert. With m=adr the row is an address, not an advert, and every row has id 0: tell address rows apart by address_slug. - `address_slug` (string) - The ADDRESS slug: pass it as {address} to /addresses/{address}/... A building's flats share it; use unit_slug for one flat. - `unit_slug` (string) - The slug of the flat's own page (also valid as {address}). Null where the advert is not tied to a unit page of its address; then ask /addresses/{address_slug}/estimate: it answers choose_unit with the building's units and adverts. - `address` (string) - Street, number, postcode and town as one line (a flat's floor and door are not part of it). - `status` (string) - The advert's state as we store it: for_sale, or rented for a rent advert that is up; adresse with m=adr. - `dwelling_type` (string) - BBR's dwelling type as the advert states it (Villa, Ejerlejlighed, Rækkehus ...), in the register's Danish words. - `villa_flat` (integer) - 1 where the home is a villa flat (a flat in a house), else 0. - `price_dkk` (integer) - The asking price in kroner (a rent advert: the monthly rent). With m=adr: our own estimate for the address. Null with price_withheld true. - `price_per_m2_dkk` (integer) - The asking price per square metre of dwelling area. - `price_withheld` (boolean) - True where we withhold the price by the address page's own rule (a price that covers several homes, a share); then price_dkk is null. - `price_change_pct` (integer) - The latest change of the asking price in percent, signed (a cut is negative); null where it has not changed. - `days_on_market` (integer) - Days the home has been on the market (the same number the site shows); null where the start is not known. - `area_m2` (integer) - Dwelling area in square metres (BBR, or the advert's where it states one). - `rooms` (integer) - Number of rooms (BBR, or the advert's where it states one). - `plot_m2` (integer) - Plot area in square metres. - `built_year` (integer) - Year the building was built (BBR). - `energy_label` (string) - Energy label A to G (the advert's, else the register's for the property). - `deviation_pct` (integer) - The asking price against our estimate in percent, signed: (asking price - estimate) / estimate, so NEGATIVE where the asking price is BELOW our estimate and positive where it is above. Null where we decline to call it (a price that covers several homes, a deviation over 45 percent ...). - `outside_estimate_range` (boolean) - True where the asking price lies outside our estimate's interval, not just away from its midpoint. - `estimate_note` (string) - Where the asking price lies outside our estimate's interval: our estimate and its interval as one English sentence ("Our estimate: DKK 4,950,000 (DKK 4,700,000 - 5,200,000)"); null otherwise. - `agent` (string) - The agent's shop name; null where the advert's name may carry the listing's own individual agent (no person is named). - `url` (string) - The advert on the agent's own site. - `sale_form` (string) - How the home is sold where the advert says (for example a bidding round), as the advert states it. - `bid_deadline` (string) - The deadline for bids, DD.MM.YYYY. - `open_house` (string) - The next open house as DD.MM. at HH.MM-HH.MM (Copenhagen time); null where none is announced. - `sold_mark` (string) - Where the register or the agent says the home is sold: "Sold - registered" with the registration date, "Purchase agreement signed", or the agent's own status word as written; null otherwise. - `last_confirmed_note` (string) - The day we last saw the advert, DD.MM.YYYY, shown only when that is 2 or more days ago; null where it was seen today or yesterday. - `balcony` (boolean) - The advert says there is a balcony (true), or nothing is said (null). Never false. - `lift` (boolean) - The advert says there is a lift (true), or nothing is said (null). Never false. - `pets_allowed` (boolean) - The advert says pets are allowed (true), or nothing is said (null). Never false. - `deposit_dkk` (integer) - A rent advert's deposit in kroner. - `prepaid_rent_dkk` (integer) - A rent advert's prepaid rent in kroner. - `aconto_dkk` (integer) - A rent advert's monthly on-account payment for heating and water, in kroner. - `available_from` (string) - A rent advert's available-from date as the site prints it. - `available_now` (boolean) - A rent advert: the home is available now. - `dwellings_on_property` (integer) - Dwellings on the property (BBR); 0 where unknown. - `sea_view` (integer) - Sea view class (our terrain model): 1 to 3, null for none. - `lake_view` (integer) - Lake view class (our terrain model), null for none. - `noise_band` (integer) - Traffic-noise band 1 to 3 (the Environmental Protection Agency's map), null for none. - `livestock_nearby` (integer) - A livestock farm lies near the home (our distance calculation); null for none. - `preservation` (integer) - Preservation (fredning) status of the building, 1 to 2; null where none. - `soil_contamination_v1` (integer) - The plot is mapped as soil contamination V1 (the register); null where not. - `soil_contamination_v2` (integer) - The plot is mapped as soil contamination V2 (the register); null where not. - `vulnerable_area` (integer) - The home lies in or near an area on the government's list of vulnerable residential areas; null where not. - `oil_tank_grade` (integer) - Oil tank grade 1 to 8 by how much it should worry a buyer (our grading of BBR's tank fields; 7 = in use, the home is not oil-heated; 8 = in use, oil-heated and past its legal deadline); null for none. - `oil_tank_note` (string) - The one sentence about the worst oil tank on the property, in English (our grading of BBR's tank fields); null where there is none. - `oil_tank_level` (string) - The tank's level of worry as a word: neutral, attention or warning (the sentence's severity). - `renovated_value_dkk` (integer) - Our estimate of the home's value after renovation to normal standard, from the home's condition (the renovation case). - `as_is_value_dkk` (integer) - Our estimate of the home as it is (the same estimate renovated_value_dkk is derived from). - `renovation_building_weight` (number) - The building's share of the public valuation, used by the renovation case. - `sales_text_condition` (integer) - How worn the advert's text says the home is, -2 (needs much) to +2 (renovated). - `text_themes` (string) - Themes the sales text mentions, as a comma-joined list of our theme ids. - `condition_words` (string) - The agent's own condition words found in the text, comma-joined. - `agent_advert` (string) - The advert's own shop string, exactly as the agent's advert states it (never edited); where `agent` is null because the name may carry the listing's own individual agent, this is still the advert's own text. Null where the advert has none. - `agent_words_advert` (string) - The advert's own phrase about several homes (for example "opdelt i to lejligheder"), whatever words it holds; null where the advert's text has none. - `deviation_pct_unfiltered` (integer) - Our estimate against the asking price in percent, signed like `deviation_pct`, whenever both numbers exist: also where `deviation_pct` is null because we decline to call the price high or low (over 45 %, an advert that covers several homes, scattered comparables). Equal to `deviation_pct` where that is given. Null for a rental and for an asking price under 200.000 kr or no estimate. - `deviation_flag` (string) - The case that made `deviation_pct` null while `deviation_pct_unfiltered` is given: `deviation_over_50_percent`, `deviation_over_45_percent`, `advert_covers_several_homes`, `scattered_comparables` or `not_computed` (none of the other cases applies: our figure and the asking price exist, but the stored deviation is missing; the codes of `listing.deviation_reason` on the address answer). `deviation_over_45_percent` means a deviation of more than 45 % in either direction (the sign is in `deviation_pct_unfiltered`); `deviation_over_50_percent` is used only for an asking price more than 50 % ABOVE our estimate, the one case with its own rule (FarAbove: an ask over 1,5 x the estimate, which the site explains with the sold homes of that kind); a price far below has no such rule and stays `deviation_over_45_percent`. Null where `deviation_pct` is given or there is nothing to compare. ## Method: what our estimate and `deviation_pct` are, and how good the estimate is (our own measurements) - What `deviation_pct` is (the field `afv` of the home search card; `afv` is still the name of the `afvmax`/`afvmin` filters and of `sort=afv`): the ASKING price against OUR ESTIMATE, in whole percent, (asking price - our estimate) / our estimate. Negative: asked below what we expect; positive: above. Our own pages call a home within 2 percent either way "level with our estimate". It exists only where there is an advert (m=salg) and an estimate; a home with no estimate has no `deviation_pct`. It is a distance to a model figure, not a judgement of the home or of the price. - What the estimate is: a comparables estimate. It starts from registered FREE sales (EJF, not asking prices) near the home in about the last three years, weights the nearer and more alike sales higher, and adjusts for size, plot, year built, energy label and noise. A home that itself sold within the last three years is anchored to its own sale; for houses and holiday homes the public valuation is blended in; a last layer adjusts for known factors such as sea view, noise, heating and what the registers and the advert's text say about renovation. It has no direct knowledge of the inside of the home. `low_dkk` and `high_dkk` are the interval around `expected_dkk`; where we do not stand behind a figure (for example because its interval is too wide) it is withheld and the reason is given (`note`, `withheld_reason`). The estimate is a figure with a range, not a valuation. - How good it is, measured by us 15.11.2026: the estimate as it stood before the contract, against the REGISTERED price of arm's-length sales registered 05.10.2026 - 08.11.2026 (five weeks; one address, a price, not a share of a bundle, that passed our own plausibility test (the price against the home's own earlier sale within ten years, else against the local price per m2; it never looks at our estimate)). Only sales for which we held an estimate before the contract are counted (the matched number below); the rest are left out, because the register learns of a sale a median 45 days after the contract (free home sales registered 01.07.2026 - 05.10.2026, 24,749 sales; a short window shows a shorter lag, since sales not yet registered are missing) and our history of estimates is short. - flat: 753 of 1,448 registered sales matched; median absolute error 10.1 %; within 10 % of the price on 49.9 % of them and within 20 % on 76.4 %; median signed error +1.6 % (negative: the estimate is below the price paid). - terraced house: 381 of 594 registered sales matched; median absolute error 10.2 %; within 10 % of the price on 49.6 % of them and within 20 % on 76.9 %; median signed error -1.9 % (negative: the estimate is below the price paid). - detached house: 2,296 of 3,657 registered sales matched; median absolute error 18.0 %; within 10 % of the price on 28.9 % of them and within 20 % on 55.1 %; median signed error -3.9 % (negative: the estimate is below the price paid). - holiday home: 761 of 854 registered sales matched; median absolute error 15.8 %; within 10 % of the price on 33.5 % of them and within 20 % on 61.1 %; median signed error -6.5 % (negative: the estimate is below the price paid). - What "the estimate as it stood" is: the figure a reader was shown on that day, and where nothing was stored as shown (the first weeks of the history) the model's BASE figure. So none of the flats, 27 % of the matched terraced house sales (100 of 376), 25 % of the matched detached house sales (565 of 2,268), 7 % of the matched holiday home sales (53 of 755) are scored against the base figure (counted 15.11.2026 on a rebuild a day later, so the totals differ by up to about 1 % from the table above). For detached houses the signed median error is -1.4 % on the figure a reader was shown and -9.1 % on the base figure, and the typical miss 18.4 % and 16.4 %: the signed figure above blends the two, and "below the price" is truer of the base figure than of what a reader saw. The estimate used is the newest snapshot at or before the contract and at most 45 days older, so it can be up to 45 days old. - How to read that: for a flat, half the estimates are within 10 % of the price paid and three quarters within 20 %; for a detached house the typical miss is about 18 %. A `deviation_pct` of -5 on a house is therefore inside the noise of the estimate, not a finding; a large one is a reason to look at the home, not a verdict that it is cheap. On average the estimate sits below the price paid for houses and holiday homes (the signed figures) and slightly above it for flats. - NOT measured by us: whether a home asked below our estimate sells for less than other homes, how far asking prices sit above the prices paid, and the accuracy per postcode or per price band. Do not read the figures above as any of those. ## Coverage, counting, codes, browsers and request rate - Coverage today (computed): Today we hold charges and easements ready for 7,727 properties, newest copy 2026-11-19. A property we do not hold is fetched from the land registry when you order it; the answer is ready within a few minutes. - Coverage today (computed): BBR and estimate answer for all 2,620,044 addresses in the register that have an entrance on record, address-protected ones included (as of 2026-11-19). Where we cannot stand behind a figure it is empty and says why. - Counting rule: A land-registry answer with status not_available_yet that carries EJF sales counts as one land_registry lookup; one without sales is free. The same key repeating the same lookup within 24 hours is counted once: on /land-registry per property, on /bbr, /estimate, /listing-history, /comparables and /plan-rules per address (or unit). The first read, or the order, is the counted one. An /estimate answer without a figure (`estimate.withheld_reason` is set, for example no_model_figure) is free and does not start the 24 hours: the next answer that has a figure counts once; a building whose flats are priced one by one (`several_flats`) carries the spread of their figures and counts. Everything else counts every time, a repeat too: a page of /homes, a call to /search, /companies or /companies/{cvr}, and each page of /companies/{cvr}/properties. Free and never counted: a refused request (400), an unknown company or address (404), a page past the last of /homes or /companies/{cvr}/properties and a /homes search nothing matches (an empty list), and HEAD. - A company's properties with their charges, in two steps (Data + Tingbog): (1) `GET /api/v1/companies/{cvr}/properties` lists what the company owns, and every row carries `land_registry_path`; (2) call that path, `GET /api/v1/properties/{bfe}/land-registry`, one call per property, counted against the land-registry cap as any lookup (the same property again within 24 hours is free, also when it is read by address) and ordered when we hold no copy yet. The path names the row's own BFE, so it is exact for every row: a flat, a house, a building owned as a whole and a property with no address (`without_address` counts them) alike; there is nothing to check. `lookup_key` (a flat's own unit slug, else the address slug, null without an address) is for the address routes (/bbr, /estimate, /sales ...); if you pass it to /addresses/{address}/land-registry anyway, check that `property.bfe` in the answer equals the row's `bfe` (about 0,4 % of address keys resolve to another property: if it differs, do not use the answer), and a building owned as a whole answers `choose_unit`. There is no list of a company's loans in one call. - Codes: use_code, status, dwelling_type, water_supply_code and the other codes in the answers are BBR's own; the official code lists are at https://teknik.bbr.dk/kodelister. - v1 is server-to-server only: it sends no CORS headers, so a browser cannot call it from a web page. Call it from your own backend and keep the key there. - Test key: on request we issue a key that answers only fixed, invented test addresses from fixtures: never a real lookup, never counted against a cap, no rate-limit budget used. It answers every route a program that builds address suggestions uses: /api/v1/search (with the structure of every hit and `limit`), /api/v1/addresses/resolve (exact for "testvej 1", ambiguous 409 for "testvej", none for an address that does not exist), /api/v1/addresses/{address}/units, /api/v1/addresses/{address}/bbr (with `facts`) and /api/v1/addresses/{address}/estimate, in the real answers' shape, with the real routes' own refusals (a parameter name the route does not read is the same free 400) and every answer carries the header X-Fixture-Key: true; every other route answers 403 fixture_key_route. The test addresses: testvej-1-9999 (a house), testvej-3-9999 (a second house; the search text "testvej" finds both), testgade-2-9999 (a building with two units: testgade-2-9999-1-tv has a unit page, and the other, 1. th, is addressed by its unit_id); any other address answers 404 unknown_address. - Request rate: 1,000 requests per minute per calling IP address (an IPv6 /64), for /usage and the lookups alike, counted in one-minute windows. Over it the answer is 429 rate_limited, the same JSON error shape as the others (detail.limit, detail.window_seconds, detail.scope "ip"), with a Retry-After header in seconds. This is separate from the monthly caps, and a HEAD request is never counted against a cap. - Home list (/api/v1/homes): at most 2 requests being answered at the same moment and 60 a minute per key; over either the answer is 429 rate_limited (detail.scope "key_concurrency" or "key") with Retry-After, and it costs nothing. A page is 30 homes and is one request, which is one counted lookup of source homes. ## Quotas - Per key, per source, per calendar month (UTC). Every answer of a valid key on an endpoint that has a source (counted or not: a free 404 or a choose_unit answer too) carries `X-Quota-Source`, `X-Quota-Limit`, `X-Quota-Used`, `X-Quota-Remaining` (limit minus used, never below 0) and `X-Quota-Resets` (ISO time of the reset); a 401, a 403 and a 5xx carry none, and neither do `/usage` (one source's headers would be an arbitrary pick: its body gives the limit and use of every source of the plan) and a path under /api/v1 that does not exist (a 404 with no source). At the cap the answer is `429 monthly_cap_reached` until the reset. Unknown and 401/403 answers do not count, and neither does an `/estimate` answer without a figure (`estimate.withheld_reason` set). ## Errors (JSON: error, message, detail) - 400 `invalid_request` - The request was refused and nothing was counted. `detail.code` says why: `unknown_parameter` (a parameter NAME the route does not read; `detail.unknown_parameters` names it and `detail.did_you_mean` gives the nearest name we do read, e.g. postnr -> omr=postnr:2000), `invalid_value` (a parameter has a value we cannot read; `detail.parameter`, `received`, `expected`, and `invalid` lists up to ten), `invalid_combination` (a parameter the chosen market cannot answer, e.g. afvmax with m=leje; `detail.answerable_in`), or an unreadable `format`, `delimiter`, `side` or `scope`. Every message is English. A name or a value is never guessed. - 400 `invalid_cvr` - The CVR number in the path is not eight digits (companies and companies/{cvr}/properties). - 401 `invalid_key` - Missing or invalid X-Api-Key. - 403 `account_not_active` - The account behind the key is not an active API customer. - 403 `plan_does_not_include_route` - The key's plan does not include the route: today only /land-registry, which needs Data + Tingbog (`detail.required_plan`, `detail.plan`). Free and not counted; upgrade at https://pro.grundviden.dk/upgrade. - 404 `unknown_address` - No such address (the id or slug is not one we have), or a unit whose building has no entrance on record. - 404 `no_property_for_address` - The address cannot be tied to one registered property (land-registry only). - 404 `unknown_property` - No property with this BFE number is known to us (/properties/{bfe}/land-registry and /properties/{bfe}/ownership-history only; free). - 404 `unknown_company` - No company with that CVR number (/companies/{cvr}). Not counted. - 400 `invalid_area` - The area in /areas/{area}/buyer-origin is not a four-digit postcode or municipality code. Not counted. - 404 `unknown_area` - No such postcode or municipality (/areas/{area}/buyer-origin). Not counted. - 404 `unknown_endpoint` - No such endpoint under /api/v1/ (the endpoints are in the guide and in openapi.json). - 405 `method_not_allowed` - The endpoint exists but answers GET only. - 409 `ambiguous` - /addresses/resolve: the text names more than one address, or only part of one. The body carries `match` "ambiguous" and `candidates` (at most 10, best first, each with a `score`) beside error and message. Counted as a lookup on the search source. - 429 `monthly_cap_reached` - The key has used its monthly cap for that source; see the X-Quota-* headers and detail.resets. - 429 `rate_limited` - More than the request-rate ceiling from the calling IP address in one minute (detail.limit, detail.window_seconds, detail.scope "ip"); or, on /api/v1/homes only, more than 2 of its requests at once from one key (detail.scope "key_concurrency") or more than 60 a minute from one key (detail.scope "key"); wait the seconds in Retry-After and retry. Not counted against any cap. - 503 `unavailable` - The service cannot answer right now (the database or a dependency is out, a query timed out). `Retry-After` says in seconds when to ask again (`detail.retry_after_seconds`). Retry with the same request; do not treat it as a wrong request. ## Semantics an integrator must handle - A flat's `estimate.unvouched_figure` (in `kind: "unavailable"`): where we do not stand behind a figure for the flat (`withheld_reason`) but the model computed one, it is here and not in `expected_dkk`: `expected_dkk`, `low_dkk`, `high_dkk`, `comparables`, `radius_m`, `range_text`, `vouched` (always false), `reason` (the same code as `withheld_reason`) and `note`. Null where the model holds none (a shared BBR unit or a tied area usually has none). It is for your own judgement and is not our estimate; the fields that already meant our estimate stay null. - `listing.deviation_pct_unfiltered` is our estimate against the asking price in percent whenever both numbers exist, also where `deviation_pct` is withheld; `listing.deviation_flag` names the case that withheld it (the code of `deviation_reason`: `deviation_over_50_percent`, `deviation_over_45_percent`, `advert_covers_several_homes`, `scattered_comparables`, `not_computed`) and is null where `deviation_pct` is given. `deviation_over_45_percent` means a deviation of more than 45 % in either direction (the sign is in `deviation_pct_unfiltered`); `deviation_over_50_percent` is used only for an asking price more than 50 % ABOVE our estimate, the one case with its own rule (FarAbove: an ask over 1,5 x the estimate, which the site explains with the sold homes of that kind); a price far below has no such rule and stays `deviation_over_45_percent`. A sale advert of 200,000 kr or more only. Every home of `/homes` carries the same two fields (`deviation_pct_unfiltered`, `deviation_flag`, always present, null where there is nothing to compare), beside `deviation_pct`, which is unchanged. - a building of several flats has no estimate of its own and answers `choose_unit`; that answer's `units_range` gives the lowest and highest of its flats' own figures, as the page prints them, with `priced_units` and `registered_units`; it is a spread across flats, not an estimate of the building, and null (with `units_range_reason`) where fewer than two flats are priced. - /companies/{cvr}/properties: a company whose legal form no register states is LISTED, not left out: `company.legal_form` is null and `legal_form_unknown` true (the same on every row's `held_by`), the answer's `unknown_legal_form_holders` counts such owners and `unknown_legal_form_note` says that we cannot rule out that one is a natural person's own business. - `listing.agent_advert` (also `agent_advert` on a unit advert in `listings[]`, on a `/listing-history` period and on every home of `/homes`) is the advert's own shop string, as the free answer has it, whatever it holds; `agent` keeps its rule and stays null where the string may carry the advert's individual agent. `listing.agent_words_advert` (and `agent_words_advert` on every home of `/homes`) is the advert's own phrase about several homes, whatever words it holds; `agent_words` still repeats only a phrase whose every word we know. - `/listing-history` `price_levels`: every asking-price level of a period in time order, each with `quotable`. `prices` is the quotable ones and `levels_left_out` counts the others, as before; a level with `quotable: false` was a typo corrected the same night, a one-night spike, a placeholder or the price of another offer, and we do not say which. `change_dkk` and `change_pct` are given for quotable levels only. - A null figure never stands alone: `note` (estimate; with `withheld_reason` for a flat) or `status`/`message` (land-registry) says why it is absent. Do not treat null as zero. - comparables: `date` is the trade's month (`YYYY-MM`), never a day. The trades are the ones the estimate really uses, nearest first, at most 50 (`truncated` says whether more were available). Where `/estimate` withholds a figure, `/comparables` gives the same `withheld_reason` and no trades. It counts as one `estimate` lookup, and the same address read again within 24 hours on the same source is free, so `/comparables` after `/estimate` on one address costs nothing extra. Trades at address-protected addresses are included. - areas/{area}/buyer-origin: AREA STATISTICS ONLY, never per address. `area` is a four-digit postcode or municipality code. Per year the people named as buyers on the deeds we hold for the area (`buyers`; companies are not counted, we read no address for a company) and the percent who lived before in the same municipality, elsewhere in the same region or in another region (the five official regions, Bornholm in Hovedstaden). A year with fewer than 10 buyers is `withheld` (`reason`, no count); there is no all-years total. It is a part of the area's sales, not all of them. One `bbr` lookup per area per 24 hours; an answer with no year shown is free. - plan-rules: the plans' own words (Danish) for the address, grouped by plan, at most 200 provisions (`truncated` says when the cap bit). It counts as one `bbr` lookup, and `/plan-rules` after `/bbr` on the same address within 24 hours is free. A plan belongs to the plot: a building address answers (no unit choice). The text is the plans' own words, which can name officials and the people a place is named after. - units: every unit under the entrance of the address (a house answers with its one unit), in the order st, 1, 2 ...; `unit_id` is the key the other routes take, `slug` is null for a unit with no unit page, `dar_id` is the DAR address id BBR holds for the unit (null where it holds none). One request is one `search` count (never once per property); it is not counted on `bbr`, `estimate` or `land_registry`. An unknown address is a free 404. - bbr: a negative number in a unit's area or room count is no figure (BBR writes -1 for "not registered"; units that no longer stand carry them): the unit's `total_area_m2`, `residential_area_m2` and `rooms` are then null with the sentence in the unit's `null_reasons`, a number fact in `facts` is null with `null_reason`, and `record` keeps the register's own value. - estimate: an answer without a figure (`estimate.withheld_reason` set: no_model_figure, multi_home_lot, shared_bbr_unit, tied_area, listed_for_rent, listed_unexplained, no_band, no_area, area_out_of_range, no_unit_page) is free: it is not counted and does not start the 24-hour same-read window, so the next answer with a figure counts once. A building whose flats are priced one by one (`several_flats`) carries `units_range` and counts. A key at its cap gets the 429 before the answer is built. - land-registry: `status` is `held` (data present, `copy_date` is the date of OUR copy for that property) or `not_available_yet` (we do not hold the record; `sales` may still be present). We never call the registry inside your request. The copy is refreshed only when the registry connection allows it, so check `copy_date`. Where ordering is on, a property we do not hold is ordered once and the call waits up to 8 seconds for the record, so most orders answer `held` at once. A copy older than 24 hours is not served as current while ordering is on: the call orders a fresh one exactly like a property we do not hold (so a property you have read before can answer `ordered` first, counted once), and the example answer is a recorded `held` answer whose `copy_date` is older than that. Otherwise `ordered` (202, `new_order` true) or, when one is already in the queue, `ordered_still_waiting` (202): a `reason` (`queued`, `being_fetched`, `retrying`, `court_rate_limited`, `court_maintenance`, `court_unavailable`), `attempt`, `max_attempts`, `next_attempt_at` and `retry_after_seconds` say what happens next; the queue retries by itself (5 s, 15 s, 45 s, 2 min, 5 min), so you only ask again, and asking again is free. If the order ends without a record (`order_failed`, 200, with a `reason`, `refunded` and `retry_after_seconds`) the unit it cost is given back by itself within seconds; a new call places a new order. Reading the same property again within 24 hours is counted once, so reading a property you ordered costs nothing more. - land-registry names (Data + Tingbog): `owners[]` (every owner of the copy), each charge's `debtors[]` and a `lender` that is a person are parties: `kind` (`person`, `company` or `unknown`: a party the register names as a legal unit with no CVR number, such as a bank branch; no `cvr`, and its name is at most 24 hours old like a person's), `name`, `cvr` (a company only), `share` (`numerator`, `denominator`) and `name_status`: `given`, `withheld_by_register` (the register gives no name, as for a protected person), `not_read` (an owner we could not read from the copy: our gap, not the register's), or `withheld_copy_older_than_24_hours`. `names.status` is `included`, `none_held` (a copy from before names, until its next fetch), `unavailable` (the names could not be read this time: charges and easements are served as usual) or `withheld_copy_older_than_24_hours` (people are then left out and companies served with the copy date); `names.as_of` is the copy date. A sole proprietorship, a personally owned small business and an estate are persons here. There is no birth date, no address and no search by name; use the names only for the purpose you stated and never to approach anyone. The same parties are listed by role on each charge: `lenders[]` (every lender; `lender` stays the first company or a person lender), `notified_parties[]`, `pledgees[]` (each with `pledge_amount`) and `attorneys[]`; `transfers[]` carries each deed's own `owners[]` with `type`, `registered`, `document_id`, `document_digital`, `takeover_date`, `cash_price_dkk`, `total_price_dkk`, `inheritance_or_gift_dkk` and `assumed_arrears_dkk` (null where the deed states none). A charge also has `amount` and `currency` (the register's amount in its own currency; `amount_dkk` is the amount in kroner and null for a charge in another currency, a few are in EUR), `document_id`, `special_terms[]`, `respected_rights_count`, `first_pledge` (`amount`, `holder_cvr`) and `rate_details` (`type` fixed or variable, `provisional`, and for a loan tied to a reference rate `reference`: `name`, `rate_pct`, `margin_pct`, `margin_direction` over or under); `rate_details` never changes `interest_rate`, and a loan tied to a reference rate still has none. `special_terms`, `rate_details` and the lists of notified parties, pledgees and attorneys are filled for a property once we have fetched it with the widened reader, and are null or empty before. An easement has `text` (the register's wording, which can name a person: the same use as the names), `document_id` and `document_alias` besides its `title`. - land-registry charges: `interest_rate` is the rate of a real-rate loan (`realkreditpantebrev`) and nothing else. For `ejerpantebrev` and `privatPantebrev` the deed registers a MAXIMUM rate, served as `max_interest_rate_pct` and never as `interest_rate`; `anden`, `udlaeg` and `skadesloesbrev` state a zero. `interest_rate_status` says which: `stated`, `maximum_only`, `none_stated` (the register states a zero, or a zero maximum), `not_held` (we do not hold this value for this loan, whatever its type: not read from the register for this copy; it never means that the register states none) or `not_classified` (a loan type we do not interpret). - Charges are as registered: a refinanced loan stays until it is cancelled, so charges are not drawn debt; never sum across types. `shared_across_properties` not null means one document covers that many properties and the amount belongs to the group. - `lender` has two shapes: a company lender is `{name, cvr}`; a person lender (`lender_is_person` true) is a party `{kind: "person", name, cvr: null, share, name_status}` on Data + Tingbog, with `name` null when it is withheld (see `name_status`), and `lender` is null for a person only when we hold no parties for the charge's document (a copy from before names). Bond series / vintage (Danish: aargang) is not part of the data. - `sales` is from EJF (Ejerfortegnelsen), not Tinglysning; `price_covers_several_properties` true means the price is for a bundle. - BBR `record` objects are the register's own Danish field names, as stored, with the register's own date strings. - Types: codes and registry identifiers are strings (`municipality_code` "0851", `cadastral_district_code`, `parcel_number`, `use_code`, a lender's `cvr`, `parcel`); counts, prices, areas, `postcode`, `latitude`, `longitude` and `bfe` are numbers. - `address` is the same in every answer: id, slug, street, number, postcode, city, `municipality_code` and `municipality_name`, `latitude` and `longitude` (WGS84, 5 decimals), `parcel_number` (the matrikel number as the address page prints it) and `cadastral_district_code` (the land-registry district, ejerlav). A field we do not hold is null and `address.null_reasons` says why; it is `{}` when nothing is null. The address page is `https://grundviden.dk/adresse/{slug}`. - Dates: a calendar date is `YYYY-MM-DD`; an instant (`copy_date`, `resets`, the `X-Quota-Resets` header) is ISO 8601 in UTC, ending in Z. - Caching: every `/api/v1` answer except `openapi.json` carries `Cache-Control: private, no-store`. Answers are per key and counted, so do not cache them or replay them with a conditional request. ## Use - Land-registry lookups (Data + Tingbog) may only be made for the purpose the customer stated (tinglysningsloven par. 50 c stk. 9); Data asks for no purpose. Data from lookups and the home list is for the customer's own internal use, within the caps; showing it to others, using it in a product or service for others, passing it on or reselling it needs a written agreement with us (contact jonas@enwire.dk). No lists of owners or loans. Prospecting follows the data source, not the plan: on both plans a customer may approach COMPANIES found through the data of any route except /land-registry, if CVR's advertising protection is respected (`advertising_protected` is true: no marketing, no sales approach); people (homeowners, sellers) are never approached, and a sole proprietorship (ENK), a personally owned small business (PMV) and an estate count as a person, as the API itself treats them; land-registry data is never used to approach anyone, on any plan. The home list returns homes and their figures, never a person's name. Every lookup is logged with account, CVR, address and time (and, on Data + Tingbog, the purpose). Terms: https://pro.grundviden.dk/terms (draft).