# GBIF species occurrences in Romania > Species-occurrence records for Romania, published by GBIF — the Global Biodiversity Information Facility, the international reference infrastructure for biodiversity data. Each row is one observation, museum specimen, sample or sensor reading for one species, at one place and time, exactly as published by whichever of GBIF’s thousands of contributing institutions and citizen-science projects submitted it — museums, universities, NGOs, monitoring programmes, platforms like iNaturalist and eBird. REFERENCED LIVE, NOT COPIED: both tables are published as views over GBIF’s own monthly Parquet snapshot on its public AWS Open Data bucket, so no row is stored in this directory’s lake and every query reads GBIF directly. That means the data is always exactly what GBIF currently publishes for the pinned snapshot — and it means there is no history here beyond that one snapshot, no row counts or column statistics of our own, and a query needs network access to s3://gbif-open-data-eu-central-1 (public, no credentials). GBIF assigns EACH RECORD, individually, one of three Creative Commons licences — never the dataset as a whole — and that per-record licence is carried straight through into the `license` column rather than flattened into one label; see `license.notes` for the measured breakdown and what each value requires of a reuser. - Dataset id: `gbif-ro` - Update cadence: monthly - Upstream source: https://registry.opendata.aws/gbif/ - Tags: biodiversity, species, occurrences, gbif, romania, ecology - Current version: ingest `01M1NPTT68G3ABRFT664S6HV9Z`, snapshot 2026-09-04, generated 2026-09-04T07:58:52.534Z ## Licence and attribution - Licence: Mixed Creative Commons licences, assigned per record by GBIF (CC0-1.0, CC-BY-4.0, CC-BY-NC-4.0) (`multiple`) - Licence text: https://www.gbif.org/terms - Required attribution: GBIF.org, GBIF Occurrence Snapshot — every monthly snapshot is issued its own DOI (listed at https://www.gbif.org/occurrence-snapshots); cite the DOI for the snapshotDate this run used, or mint a GBIF "Derived Dataset" citation for your specific query, as GBIF itself recommends for a filtered subset of a cloud snapshot. - Notes: GBIF’s Governing Board has required every occurrence record to carry one of exactly three Creative Commons licences since 2014, assigned RECORD BY RECORD rather than for a whole dataset: CC0-1.0 ("for any use without restriction or particular requirements on the part of users"), CC-BY-4.0 ("for any use provided that attribution is appropriately given for the sources of data used"), and CC-BY-NC-4.0 ("for any use provided that attribution is appropriately given and provided the use is not for commercial purposes") — quoted from gbif.org/terms. Measured directly against the 2026-09-01 snapshot’s Romanian records (1,794,998 rows total): CC-BY-4.0 892,005 (49.7%), CC-BY-NC-4.0 697,635 (38.9%), CC0-1.0 205,358 (11.4%). THE DECISION THIS CONNECTOR MAKES: publish every row, of every licence, with the per-record `license` value carried through unchanged and declared NOT NULL — rather than excluding CC-BY-NC-4.0 rows to make the dataset look single-licensed. Dropping them would silently remove 38.9% of Romania’s occurrence records, which is exactly the "curated handful instead of the whole source" failure this platform’s house rules forbid, and it is not what GBIF’s own bulk downloads or cloud mirrors do either. A REUSER MUST FILTER BY `license` BEFORE ANY REUSE: `license = 'CC0_1_0'` carries no conditions at all; `license IN ('CC0_1_0','CC_BY_4_0')` may be used for any purpose, commercial included, with attribution; `license = 'CC_BY_NC_4_0'` additionally forbids commercial use. GBIF’s own guidance on CC-BY-NC: "Users who make use of data that carries the CC BY-NC license should do so in good faith. We strongly encourage them to communicate with publishers if a broad but reasonable interpretation of non-commercial use might construe the benefits they receive as commercial in nature" — GBIF does not itself enforce CC-BY-NC by legal means; that responsibility sits with the individual data publisher and, downstream, with the reuser. AWS’s own Open Data registry entry for this bucket labels the mirror as a whole "CC-BY-NC" as a blanket, most-restrictive stand-in for the mix; that is not wrong as an umbrella, but it is not a substitute for the per-row `license` column this connector publishes. GBIF aggregates data from thousands of independent publishers (see `datasetkey`/`publishingorgkey`), each of which retains rights over its own contribution and its own separate attribution page on gbif.org; CC-BY and CC-BY-NC rows require crediting GBIF, and a reuser going beyond casual analysis should also credit the specific publishing dataset/organisation those columns name. Only the tabular Darwin Core fields GBIF’s Parquet export itself carries are republished here — no binary media (images, sounds, video) is copied; `mediatype` lists only what kinds exist. Reproduce the attribution line verbatim anywhere you republish this data. ## Manifest - Start here for how this directory works: https://data.bunnytech.app/llms.txt - This dataset: https://data-directory.fsn1.your-objectstorage.com/public/gbif-ro/manifest.json - All datasets: https://data-directory.fsn1.your-objectstorage.com/public/index.json - Human page: https://data.bunnytech.app/datasets/gbif-ro The manifest is the contract: file URLs, row counts, column types, min/max statistics and example queries all live there. Re-read it to discover a new version. ## Fastest path — Parquet exports Immutable, physically sorted snapshot exports. No catalog fetch, best row-group pruning, safe to cache forever. Register one view per table: ```sql INSTALL httpfs; LOAD httpfs; -- occurrences: queried live at the source, never copied here — no parquet export. -- taxa: queried live at the source, never copied here — no parquet export. ``` Example queries: -- Records of one species, most recent snapshot: These tables are views over GBIF’s bucket, so snapshot_date is a constant — the one snapshot the view points at — and the max() below simply names it. The filter that costs anything is taxonkey, and GBIF’s snapshot has no partitioning to prune it with, so expect this to read across the snapshot rather than a contiguous slice. ```sql CREATE OR REPLACE SECRET "gbif_open_data_eu_central_1" (TYPE s3, SCOPE 's3://gbif-open-data-eu-central-1', PROVIDER 'config', REGION 'eu-central-1'); ATTACH IF NOT EXISTS ':memory:' AS "gbif_ro"; CREATE SCHEMA IF NOT EXISTS "gbif_ro"."main"; CREATE OR REPLACE VIEW "gbif_ro"."main"."occurrences" AS SELECT gbifid, '2026-09-01'::DATE AS snapshot_date, countrycode, datasetkey, occurrenceid, taxonkey, specieskey, verbatimscientificname, verbatimscientificnameauthorship, occurrencestatus, individualcount, publishingorgkey, decimallatitude, decimallongitude, coordinateuncertaintyinmeters, coordinateprecision, elevation, elevationaccuracy, depth, depthaccuracy, eventdate, day, month, year, basisofrecord, institutioncode, collectioncode, catalognumber, recordnumber, identifiedby, dateidentified, license, rightsholder, recordedby, typestatus, establishmentmeans, lastinterpreted, mediatype, issue, locality, stateprovince, TIMESTAMPTZ '2026-09-04T07:58:47.496Z' AS ingested_at FROM read_parquet('s3://gbif-open-data-eu-central-1/occurrence/2026-09-01/occurrence.parquet/*', union_by_name = true) WHERE countrycode = 'RO'; CREATE OR REPLACE VIEW "gbif_ro"."main"."taxa" AS SELECT taxonkey, max(specieskey) AS specieskey, max(kingdom) AS kingdom, max(phylum) AS phylum, max("class") AS "class", max("order") AS "order", max(family) AS family, max(genus) AS genus, max(species) AS species, max(taxonrank) AS taxonrank, max(scientificname) AS scientificname, lower(strip_accents(max(scientificname))) AS scientificname_lc, DATE '2026-09-04' AS first_seen_date, DATE '2026-09-04' AS last_seen_date, TIMESTAMPTZ '2026-09-04T07:58:47.496Z' AS ingested_at FROM read_parquet('s3://gbif-open-data-eu-central-1/occurrence/2026-09-01/occurrence.parquet/*', union_by_name = true) WHERE countrycode = 'RO' AND taxonkey IS NOT NULL GROUP BY taxonkey; SELECT o.eventdate, o.locality, o.decimallatitude, o.decimallongitude, o.license FROM gbif_ro.main.occurrences o WHERE o.snapshot_date = (SELECT max(snapshot_date) FROM gbif_ro.main.occurrences) AND o.taxonkey = (SELECT taxonkey FROM gbif_ro.main.taxa WHERE scientificname_lc LIKE 'ursus arctos%' LIMIT 1) ORDER BY o.eventdate DESC; ``` -- Only freely reusable rows (no non-commercial restriction): The licensing filter every downstream use should start from — see dataset.license.notes for what each value means. ```sql CREATE OR REPLACE SECRET "gbif_open_data_eu_central_1" (TYPE s3, SCOPE 's3://gbif-open-data-eu-central-1', PROVIDER 'config', REGION 'eu-central-1'); ATTACH IF NOT EXISTS ':memory:' AS "gbif_ro"; CREATE SCHEMA IF NOT EXISTS "gbif_ro"."main"; CREATE OR REPLACE VIEW "gbif_ro"."main"."occurrences" AS SELECT gbifid, '2026-09-01'::DATE AS snapshot_date, countrycode, datasetkey, occurrenceid, taxonkey, specieskey, verbatimscientificname, verbatimscientificnameauthorship, occurrencestatus, individualcount, publishingorgkey, decimallatitude, decimallongitude, coordinateuncertaintyinmeters, coordinateprecision, elevation, elevationaccuracy, depth, depthaccuracy, eventdate, day, month, year, basisofrecord, institutioncode, collectioncode, catalognumber, recordnumber, identifiedby, dateidentified, license, rightsholder, recordedby, typestatus, establishmentmeans, lastinterpreted, mediatype, issue, locality, stateprovince, TIMESTAMPTZ '2026-09-04T07:58:47.496Z' AS ingested_at FROM read_parquet('s3://gbif-open-data-eu-central-1/occurrence/2026-09-01/occurrence.parquet/*', union_by_name = true) WHERE countrycode = 'RO'; SELECT count(*) AS freely_reusable_rows FROM gbif_ro.main.occurrences WHERE license IN ('CC0_1_0', 'CC_BY_4_0'); ``` ## Live lake — DuckLake catalog with time travel Every table in this dataset is queried live at its source, so nothing was copied into a DuckLake and the catalog published beside it holds no tables. Use the setup printed with the example queries above, or the `view.sql` of the table you want from `manifest.json` — that is the query, in full, against the upstream source. ## Wholesale — S3 access For bulk downloads, read the bucket prefix directly over S3 with httpfs: ```sql INSTALL httpfs; LOAD httpfs; CREATE SECRET hetzner ( TYPE s3, ENDPOINT 'fsn1.your-objectstorage.com', URL_STYLE 'path', KEY_ID '', SECRET '' ); SELECT * FROM read_parquet('s3://data-directory/public/gbif-ro/v/01M1NPTT68G3ABRFT664S6HV9Z/**/*.parquet'); ``` ## Schema ### occurrences One row per GBIF species-occurrence record published for Romania, from a pinned monthly GBIF snapshot (the run’s `snapshotDate` parameter — see `snapshot_date`). GBIF assigns one of three Creative Commons licences to EACH record individually — CC0-1.0, CC-BY-4.0 or CC-BY-NC-4.0 — and they are genuinely mixed here: filter on `license` before any reuse, and never assume the whole table carries one licence. `taxonkey` joins to `taxa` for the resolved scientific name and full classification. - 0 rows · 0 B · write mode `snapshot_history` - Physically sorted by: `snapshot_date`, `taxonkey`, `eventdate`, `gbifid` - Primary key: `gbifid`, `snapshot_date` - Files: 0 Columns: - `gbifid` BIGINT NOT NULL — GBIF’s own numeric identifier for this occurrence record, stable across GBIF snapshots for the same physical record. Together with snapshot_date this is the row’s primary key — the same gbifid can legitimately reappear in a later snapshot. - `snapshot_date` DATE NOT NULL — Which GBIF monthly snapshot this row was read from — the connector’s `snapshotDate` run parameter (e.g. "2026-09-01"), NOT the day this ingest actually ran. It is an arbitrary calendar-day label naming which monthly corpus to read, with no time zone attached — it is not a UTC day, a Europe/Bucharest day, or any other zoned instant, so do not read a zone into it. GBIF republishes its entire corpus every month, so pinning this is what makes a run reproducible: the same snapshot_date always reads the same 9,898 source files. This table is federated, so this is a constant baked into the published view definition — every row carries the one snapshot the view points at. See ingested_at for when that view definition was published. - `countrycode` VARCHAR NOT NULL — ISO-ish country code GBIF interpreted for this record; always "RO" in this table because the ingest filters WHERE countrycode = 'RO' at the source. Kept as an explicit column (rather than assumed) so the table is self-describing on its own. - `datasetkey` VARCHAR — UUID of the GBIF-registered dataset that published this record — one of the many individual collections, citizen-science projects or monitoring programmes GBIF aggregates. Look it up at gbif.org/dataset/ for the publisher’s own name and its own terms; a reuser going beyond casual analysis should credit that publisher specifically, not only GBIF. - `occurrenceid` VARCHAR — The record’s own identifier as assigned by the institution that originally published it — often a URI, a specimen barcode or a project-specific code. Not guaranteed unique across datasets; use gbifid for that. - `taxonkey` VARCHAR — GBIF backbone taxonomy identifier for the taxon this record was matched to — an opaque alphanumeric token in this export (not the classic integer taxon key GBIF’s website uses), verified directly against the source. Joins to taxa.taxonkey for the resolved name and full classification. - `specieskey` VARCHAR — GBIF backbone identifier of the species-level ancestor of taxonkey — the same value as taxonkey when the record was itself matched at species rank, and the enclosing species when it was matched more precisely (a subspecies) or, GBIF permitting, less precisely. NULL when no species-rank match exists (e.g. a genus-only identification). - `verbatimscientificname` VARCHAR — The scientific name exactly as the original recorder or publisher wrote it, BEFORE GBIF matched it against its taxonomic backbone — spelling variants, outdated names and typos included. Compare against taxa.scientificname (the resolved name) to see what GBIF’s matching actually did. - `verbatimscientificnameauthorship` VARCHAR — The taxonomic authorship string (who first described the name, and when) exactly as the original record carried it, when published separately from verbatimscientificname. - `occurrencestatus` VARCHAR — Whether the organism was recorded as PRESENT (the normal case) or ABSENT — a deliberate record that a survey looked for the taxon at this place and time and did NOT find it. Absence records matter for distribution modelling and are easy to mistake for missing data if this column is ignored. - `individualcount` INTEGER — Number of individuals the record covers, when the source reported a count rather than a bare presence. - `publishingorgkey` VARCHAR — UUID of the GBIF-registered organisation that operates the publishing dataset — typically a museum, university, agency or NGO. Look it up at gbif.org/publisher/. - `decimallatitude` DOUBLE [degrees] — Latitude GBIF interpreted for this record, WGS84. - `decimallongitude` DOUBLE [degrees] — Longitude GBIF interpreted for this record, WGS84. - `coordinateuncertaintyinmeters` DOUBLE [m] — Radius of the circle around (decimallatitude, decimallongitude) that GBIF is confident the true location falls within. Large values (kilometres) are common for older or coarsely georeferenced records — always sense-check before mapping at fine scale. - `coordinateprecision` DOUBLE [degrees] — Decimal precision of the reported coordinates, as a fraction of a degree — a measurement of how the coordinates were rounded, distinct from coordinateuncertaintyinmeters (which measures real-world positional error). Rare in practice; most records leave it unset. - `elevation` DOUBLE [m] — Elevation above sea level GBIF interpreted for the record. - `elevationaccuracy` DOUBLE [m] — Reported precision of elevation, when given. - `depth` DOUBLE [m] — Depth below the surface (of water or soil) at which the organism was recorded — relevant for aquatic and soil-dwelling taxa. - `depthaccuracy` DOUBLE [m] — Reported precision of depth, when given. - `eventdate` TIMESTAMP — GBIF’s interpreted date (and, when the source gave one, time) the organism was observed or collected — stated as whatever local clock reading the source gave, not a UTC instant: GBIF’s own temporal-interpretation pipeline keeps an offset only when the source stated UTC itself, and otherwise strips it rather than converting it (a +01:00 record and a +14:00 record with the same digits both land on the same zone-less value here), verified against a live GBIF API record on 2026-09-04. Most records report only a calendar day: expect eventdate to sit at midnight far more often than a genuine clock time. day/month/year below repeat the calendar fields directly and are the safer columns to filter or group by when time-of-day does not matter. - `day` INTEGER — Day of the month of eventdate, when GBIF could parse one. - `month` INTEGER — Month of eventdate, when GBIF could parse one. - `year` INTEGER — Year of eventdate, when GBIF could parse one. The safest column for "how many records per year" — some records span many centuries (museum specimens collected as early as the 1500s appear in this snapshot). - `basisofrecord` VARCHAR — What kind of evidence this record is: HUMAN_OBSERVATION (a person saw it and logged it, no specimen kept — most citizen-science records), PRESERVED_SPECIMEN (a museum or herbarium specimen), MATERIAL_SAMPLE (a physical sample such as a soil or water sample), MACHINE_OBSERVATION (an automated sensor, e.g. a camera trap or acoustic logger), OCCURRENCE (unspecified evidence) or MATERIAL_CITATION (cited in a publication without a retained specimen). - `institutioncode` VARCHAR — Code of the institution that holds or manages the record, as the original publisher wrote it. - `collectioncode` VARCHAR — Code of the collection within the institution. - `catalognumber` VARCHAR — Catalogue or specimen number within the collection — together with institutioncode and collectioncode, how the source institution itself would look this record up. - `recordnumber` VARCHAR — The original collector’s or observer’s own field/record number, distinct from the institution’s catalogue number. - `identifiedby` JSON — Name(s) of the person or people who identified the taxon, as a JSON array of strings (GBIF’s own field is a list — a record can carry more than one identifier, or none). - `dateidentified` TIMESTAMP — When the taxonomic identification was made, if recorded — like eventdate, GBIF strips any offset that is not already UTC rather than converting it, so a stated time here is the identifier’s own local clock reading with no zone attached, not a UTC instant (confirmed against a live GBIF API record on 2026-09-04, which returned "2026-08-01T05:07:56" with no offset at all). - `license` VARCHAR NOT NULL — THE PER-RECORD LICENCE — the single most important column in this table before reusing any row. One of "CC0_1_0" (no rights reserved), "CC_BY_4_0" (attribution required) or "CC_BY_NC_4_0" (attribution required, NON-COMMERCIAL USE ONLY), assigned by GBIF per record — never assume the dataset-level licence describes every row. See the connector’s dataset.license notes for the measured breakdown and what each value obligates a reuser to do. Declared NOT NULL on purpose: a row this connector cannot attach a licence to must fail the ingest rather than publish with an unknown licence. - `rightsholder` VARCHAR — Name of the person or organisation holding rights over the record, when GBIF recorded one separately from the publishing organisation. - `recordedby` JSON — Name(s) of the person or people who recorded/collected the occurrence, as a JSON array of strings. - `typestatus` JSON — Nomenclatural type status of the specimen (e.g. "Holotype", "Paratype"), as a JSON array of strings. NULL or empty for the overwhelming majority of records — this applies only to specimens formally designated as the reference for a species name. - `establishmentmeans` VARCHAR — Whether the organism is considered native, introduced, naturalised, invasive, managed or uncertain at this location, when the source recorded a judgement. - `lastinterpreted` TIMESTAMP — When GBIF’s own interpretation pipeline (matching the taxon, parsing the date, validating coordinates, assigning issue flags) last processed this record, in UTC — a live GBIF API record checked on 2026-09-04 stated it as "2026-09-02T08:42:23.730+00:00", unlike eventdate/dateidentified above, because this is GBIF’s own server clock rather than a value read off someone else’s data. Unrelated to when this connector ingested it (see ingested_at). - `mediatype` JSON — Which kinds of media (e.g. "StillImage", "Sound", "MovingImage") GBIF associates with this record, as a JSON array of strings. This connector does NOT republish the media itself — no images, no audio, no video are copied — only this list of what exists; follow occurrenceid or the GBIF occurrence page for the files themselves. - `issue` JSON — GBIF interpretation issue codes flagged for this record (e.g. coordinate rounding, a taxon match ambiguity, a date out of range), as a JSON array of strings. An empty or NULL array means GBIF’s pipeline flagged nothing; a non-empty one is a hint to check the flagged field before trusting it blindly. See gbif.org/data-quality-requirements for what each code means. - `locality` VARCHAR — Free-text place description as the original recorder wrote it — a place name, a protected-area name, a description relative to a landmark. Not standardised: use decimallatitude/decimallongitude for anything that needs to be compared or mapped. - `stateprovince` VARCHAR — Romanian county (județ) or other first-level administrative division, as GBIF interpreted it from the source record. Not populated for every record — many sources give only coordinates or a free-text locality. - `ingested_at` TIMESTAMP NOT NULL — When the run that PUBLISHED THIS VIEW started (UTC). This table is federated — no row was ever copied — so this is one constant for every row, and it dates the view definition rather than the data: the rows themselves are read from GBIF live, at the moment you query them. It is not when GBIF published the snapshot or last interpreted the record (see lastinterpreted). ### taxa One row per distinct taxon (taxonkey) that has appeared in this connector’s Romanian occurrence records, with the full classification and the GBIF-resolved scientific name — the columns that are identical for every occurrence of the same taxon, pulled out of occurrences so they are stored once per taxon rather than once per record. Updated by upsert: a taxon already known keeps its row and widens its seen window; a taxon this run did not encounter keeps its existing row rather than being deleted, so older occurrence rows never lose their dimension match. - 0 rows · 0 B · write mode `upsert` - Physically sorted by: `scientificname_lc` - Primary key: `taxonkey` - Text search columns: `scientificname` - Files: 0 Columns: - `taxonkey` VARCHAR NOT NULL — GBIF backbone taxonomy identifier — an opaque alphanumeric token in this export. Joins to occurrences.taxonkey. - `specieskey` VARCHAR — GBIF backbone identifier of the species-level ancestor of this taxon; equals taxonkey itself when this taxon IS a species. NULL when no species-rank ancestor is known. - `kingdom` VARCHAR — Taxonomic kingdom, e.g. Animalia, Plantae, Fungi. - `phylum` VARCHAR — Taxonomic phylum. - `class` VARCHAR — Taxonomic class. - `order` VARCHAR — Taxonomic order. - `family` VARCHAR — Taxonomic family. - `genus` VARCHAR — Taxonomic genus. - `species` VARCHAR — Species epithet as GBIF’s backbone resolves it — present only when taxonkey resolved to species rank or more precisely; NULL for a record only matched to genus or higher. - `taxonrank` VARCHAR — The taxonomic rank taxonkey was actually matched at — SPECIES, GENUS, FAMILY, SUBSPECIES and so on. Explains why species/genus/family above can be NULL: a record matched only to genus rank has no species value to give. - `scientificname` VARCHAR — The GBIF-backbone-resolved scientific name for this taxon, WITH authorship — the standardised name, as opposed to occurrences.verbatimscientificname (what each record’s original source actually wrote, before matching). - `scientificname_lc` VARCHAR — scientificname lower-cased and accent-folded, for case- and accent-insensitive prefix search. Searching this column instead of lower(scientificname) is what lets a prefix match use parquet statistics: scientificname_lc >= 'urs' AND scientificname_lc < 'urt' is a range: lower(scientificname) = '…' is a function the statistics cannot see through. - `first_seen_date` DATE NOT NULL — The day (UTC) the published view definition was built. This table is federated, so it is NOT a seen-window: a view has no memory of previous runs, so first_seen_date and last_seen_date carry the same constant on every row. While the table was copied into the lake these two columns really did widen across runs; they are kept, with this description, rather than dropped, so a query written against the copied table still resolves. To ask when a taxon was actually recorded, use occurrences.eventdate. - `last_seen_date` DATE NOT NULL — The same UTC constant as first_seen_date, for the same reason: this table is federated and a view cannot remember a previous run. A taxon missing from the snapshot the view points at is simply absent from the view — it is not retained under a stale last-seen value the way the copied, upserted version of this table retained it. - `ingested_at` TIMESTAMP NOT NULL — When the run that published this view definition started (UTC). One constant for every row: nothing was written, so nothing has its own write time. ## Performance notes - There are no indexes in a lakehouse. The physical sort order plus Parquet row-group min/max statistics ARE the index. Predicates on the leading sort columns prune whole row groups; everything else is a full column scan. - `occurrences` prunes on `snapshot_date` → `taxonkey` → `eventdate` → `gbifid`. - `taxa` prunes on `scientificname_lc`. - `ILIKE '%needle%'` cannot prune: it decompresses that whole column. Prefer prefix predicates on the lowercased search companion columns where they exist. - Every file URL under `/v//` is immutable. Cache it as aggressively as you like. - Files are never rewritten in place — a new ingest writes a new version path. Re-read the manifest to pick up updates rather than polling the file URLs. - Pull only the columns you need. Parquet is columnar and the reader range-GETs what it reads. ## Do not - Do not scrape https://data.bunnytech.app HTML. Every number on those pages comes from the manifest above. - Do not hit the upstream source (https://registry.opendata.aws/gbif/) in bulk. This mirror exists so you do not have to. - Do not read DuckLake internal data files with a plain Parquet reader. They come with positional delete files, and ignoring those silently returns deleted rows. Use the ducklake extension, or use the published exports above. - Do not republish without the attribution line, and do not imply endorsement.