An indication that the actor accepts the object — typically a Follow request or invitation.

Subclass of `urn:solid:Activity`. The classic ActivityPub use is responding to a `Follow` to confirm the relationship. The `as:object` is what's being accepted (often another Activity). Pair with `Reject` for the negative response.

Bob accepts Alice's follow request


A Solid pod account — the user account on a Solid server, distinct from the WebID it issues.

Solid-specific account class — represents the user record held by a Solid server (login credentials, owned pod, billing). Distinct from `urn:solid:OnlineAccount` (the FOAF generic account-on-a-service class) and from `urn:solid:account` (the FOAF property pointing at any online account). One Solid `Account` typically owns one pod and issues one WebID.

Pod account on a Solid server

Initial term — Class form completing the Account/account case-pair, mapped to solid:Account (distinct from foaf:OnlineAccount, already covered by urn:solid:OnlineAccount).


An action performed by a direct agent on a direct object — schema.org's analogue of an activity.

Schema.org's action vocabulary — used heavily for `schema:potentialAction` declarations on websites ("this site supports SearchAction with these parameters"). For ActivityPub-style social actions, `urn:solid:Activity` is the right base; for PROV processes, `prov:Activity`. Pick by domain.

SearchAction declaration on a website


An action taken by an actor — the base for Create, Like, Follow, Announce, etc.

Subclass of `urn:solid:Object`. Pair with `as:actor` (the agent performing it), `as:object` (what it's done to), `as:target`, `as:published`. Rarely typed directly — pick a subclass like `urn:solid:Like`, `urn:solid:Follow`, `urn:solid:Create`. For PROV-grade activity tracking with start/end times, use `prov:Activity`.

A generic activity


An activity in which the actor is adding the object to the target.

Subclass of `urn:solid:Activity`. The `as:object` is the thing being added; `as:target` is the collection or container it's being added to. Distinct from `Create` (which brings a new object into existence) — `Add` references an existing object and places it somewhere.

Add a note to a favorites collection


A postal address — the value class for `urn:solid:hasAddress` (street, locality, region, postal code, country).

Class form for postal addresses. Used as the value of `urn:solid:hasAddress`. The address parts (street-address, locality, region, postal-code, country-name) are vCard-style flat literals on the Address instance, not nested.

Person with a postal address

Initial term — Class form pairing with the existing hasAddress property.


A collection of contacts — a personal or shared address book.

The vcard AddressBook class — used by SolidOS and inrupt apps as the canonical type for an address book resource. Pair with `urn:solid:hasMember` for the entries. Each member is typically a `urn:solid:Person`.

An address book with two members


A thing that acts — person, organization, group, or software.

Use when the actor could be non-human (a bot, a group, a service). Prefer `urn:solid:Person` when you know the actor is specifically a human.

Software agent


An OWL property used purely for human-readable metadata — labels, comments, version notes — with no formal semantic implications.

urn:solid:Property urn:solid:ObjectProperty urn:solid:DatatypeProperty urn:solid:label urn:solid:comment

Examples: `rdfs:label`, `rdfs:comment`, `rdfs:seeAlso`, `dcterms:creator`. Reasoners explicitly *don't* use AnnotationProperty triples for inference — they're metadata for humans and tooling, not part of the formal model. Distinct from `ObjectProperty`/`DatatypeProperty` which carry semantic weight.

Declaring rdfs:label as an AnnotationProperty


An activity in which the actor is calling the audience's attention to the object — a boost or repost.

Subclass of `urn:solid:Activity`. The ActivityPub primitive for boost / repost / share — distinct from `Like` (favorite without redistribution) and `Create` (publishing a new object). The `as:object` is the resource being amplified to the actor's audience.

Alice boosts Bob's note


An answer to a Question — typically posted on Q&A sites or forums.

Subclass of `urn:solid:Comment`. Pair with `schema:parentItem` pointing at the `urn:solid:Question`. Distinct from a generic `Comment` (which can be on anything) and from AS `Note` (microblog post). Use schema's Q&A pair (`Question` + `Answer`) for SEO-rich Q&A markup.

An answer to a question

Yes, ActivityPub supports it via Like activities.


The WAC Append access mode — permission to add new content to a resource without modifying existing content.

urn:solid:Read urn:solid:Write urn:solid:Control urn:solid:mode

Weaker than `urn:solid:Write`: lets the agent add (POST a new member to a Container, append a triple to an RDF resource) but not modify or delete existing content. Standard pattern for inboxes — anyone can drop in a notification, only the owner can read or remove them.

Inbox accepting public Append


An ActivityStreams actor representing a software application — a bot, service, or automated client.

One of the AS actor types alongside `as:Person`, `as:Group`, `as:Organization`, `as:Service`. Use for non-human actors that are software (clients, bots, automation). For PROV-grade software-agent attribution, see `prov:SoftwareAgent`.

A bot as an Application


An article — a written work, typically published as part of a larger publication.

Subclass of `urn:solid:Document` (and schema:CreativeWork). Use for blog posts, news articles, papers. Pair with `urn:solid:headline`, `urn:solid:articleBody`, `urn:solid:author` for full schema.org-style modelling. For ActivityPub-style social posts, see `as:Article` or `as:Note`.

A blog post as an Article


A qualified PROV association — the role-aware participation of an Agent in an Activity.

urn:solid:wasAssociatedWith urn:solid:Attribution urn:solid:hadPlan urn:solid:hadRole

Distinct from `urn:solid:Attribution`: Association links Agent → Activity (who did the work), Attribution links Agent → Entity (who's responsible for the result). Carries `prov:agent`, `urn:solid:hadRole`, and `urn:solid:hadPlan`. Linked from an Activity via `prov:qualifiedAssociation`.

Build run with a software-agent association


A qualified PROV attribution — the role-aware relation between an Entity and the Agent it is attributed to.

Use to qualify `prov:wasAttributedTo` with a role and timing. Linked from an Entity via `prov:qualifiedAttribution`. Carries `prov:agent` (the responsible Agent) and `urn:solid:hadRole` (the role they took — author, photographer, contributor).

Photo attributed to a photographer


An audio resource — used in ActivityPub for audio attachments and stand-alone audio posts.

ActivityStreams audio type — use for fediverse audio posts and attachments. Distinct from `urn:solid:AudioObject` (schema.org) which carries richer media metadata. Pick by data flavor: AS for ActivityPub-style social data, schema for SEO/structured-data web pages.

Note with an audio attachment


An audio file with structured metadata — duration, encoding, transcript.

Schema.org's audio type — podcasts, voice memos, sound effects. Carries `schema:contentUrl`, `schema:duration`, `schema:encodingFormat`, `schema:transcript`. For music tracks specifically, `schema:MusicRecording` adds artist/album fields.

A podcast episode


A Web Access Control (WAC) authorization — grants one or more access modes on a resource to one or more agents.

urn:solid:mode urn:solid:Read urn:solid:Write urn:solid:Append urn:solid:Control

The atom of Solid pod access control. Each Authorization carries `acl:agent` / `acl:agentClass` / `acl:agentGroup` (who), `acl:accessTo` / `acl:default` (what), and one or more `acl:mode` (what kind of access). Authorizations live in `.acl` resources on a Solid pod.

An ACL Authorization granting Read


An LDP Container whose membership is defined entirely by `ldp:contains` triples.

Subclass of `urn:solid:Container`. The default container shape used by Solid pods — every directory-like resource is typically a `BasicContainer` whose members are listed via `ldp:contains`. Use `ldp:DirectContainer` or `ldp:IndirectContainer` only when you need server-managed membership semantics.

A pod root as a BasicContainer


A book, article, or other documentary resource — typically with structured citation metadata.

Library/archive-flavored class for the things a bibliography indexes — books, journal articles, conference papers, datasets. Pair with `urn:solid:bibliographicCitation`, `urn:solid:isPartOf` (linking article→issue→journal), and `urn:solid:identifier` (DOI, ISBN). For schema.org-flavored data, prefer specific subclasses like `urn:solid:Book` or `urn:solid:Article`.

A bibliographic resource

Liddell, A. (2026). On Wonderlands. Solid Journal, 1(1), 1-10.


An indication that the actor is blocking the object — typically another actor.

Subclass of `urn:solid:Activity`. The `as:object` is the actor being blocked. By ActivityPub convention, Block activities should NOT be delivered to the blocked actor — receivers process them locally to filter out interactions. To unblock, send an `as:Undo` of the Block.

Alice blocks a spammer


A single blog post — an entry in a weblog, typically with a date and an author.

Subclass of `urn:solid:Article`. Use specifically for blog entries when you want SEO/syndication semantics that distinguish them from news or scholarly articles. Pair with `schema:isPartOf` pointing at the parent `schema:Blog`.

A blog post


A book — a long-form written work, typically published as a single physical or digital volume.

Subclass of `urn:solid:CreativeWork`. Pair with `schema:isbn`, `schema:numberOfPages`, `schema:bookEdition`, `schema:author`. For audiobook or e-book editions specifically, schema.org provides `schema:Audiobook` and `schema:EBook` subclasses.

A book with metadata


A saved reference to a web resource — title, URL, optional tags and notes.

The W3C bookmark vocabulary class used by Tabulator/SolidOS. A Bookmark uses `urn:solid:recalls` for the URL it points at and `urn:solid:hasTopic` for tags. Pair with `urn:solid:title` for the headline and `urn:solid:created` for the save date.

A bookmark with tags


A brand — a distinctive identity associated with a product, service, or organization.

A Brand is a marketing identity, not the legal Organization that owns it — Pepsi (the brand) ≠ PepsiCo (the company). One Organization may own many Brands. Use `schema:brand` on a `urn:solid:Product` to link to its brand.

A product with a brand


A named bundle of PROV provenance descriptions — a way to attribute provenance to provenance.

Subclass of `urn:solid:Entity`. A Bundle wraps a collection of PROV statements so they themselves can be the subject of further PROV — "who said this, when, why". Useful for distinguishing claims from different sources or for versioning provenance assertions.

A bundle of provenance attributed to an agent


A DCAT Catalog — a curated collection of metadata about Datasets and DataServices.

The container for an open-data portal or research-data repository. Members listed via `dcat:dataset` (datasets) and `dcat:service` (services). Pair with `dcterms:publisher`, `urn:solid:license`. The W3C DCAT 3 spec is the current normative reference.

A simple catalog


A reorganisation event in which one set of Organizations was transformed into another — a merger, split, rename, or restructuring.

urn:solid:Organization urn:solid:resultedFrom urn:solid:resultingOrganization urn:solid:originalOrganization

Captures organisational discontinuities cleanly: link the *before* state with `org:originalOrganization` and the *after* with `org:resultingOrganization`. Use this rather than mutating an Organization in place when downstream agreements need to know whether a partner is a continuation or a successor of an earlier entity.

A merger as a ChangeEvent


A chat message — a single message exchanged in a chat conversation.

Schema.org's general `schema:Message` type — covers chat, IM, and similar real-time communication. Distinct from AS `urn:solid:Note` (microblog post) and `urn:solid:EmailMessage` (asynchronous email). Pair with `schema:sender`, `schema:recipient`, `schema:dateSent`.

A chat message


A city — a permanent settlement of significant size.

Subclass of `urn:solid:Place` (via `schema:AdministrativeArea`). Pair with `schema:containedInPlace` pointing at the containing `urn:solid:Country` to anchor it in the geographic hierarchy. For coordinates, attach `urn:solid:hasGeo`.

London as a City


The class of RDF classes — the meta-class whose instances are themselves classes (Person, Note, Activity, etc.).

Foundational RDFS term. Every class definition in this registry is `@type: rdfs:Class`. Use as the value of `@type` when declaring a new class; pair with `rdfs:subClassOf` to position it in the class hierarchy.

Declaring a custom class


Subclass of `urn:solid:Object`. Use `as:items` (or paginate via `as:first`/`as:next`) to enumerate members. For ordered membership (timelines, replies, outboxes), use `as:OrderedCollection`. For Linked Data Platform containers with HTTP-level membership semantics, use `ldp:Container`.

A collection with two items


A single page of an ActivityStreams Collection — a slice of the members, plus pagination links back to the parent and to neighbouring pages.

urn:solid:Collection urn:solid:OrderedCollectionPage urn:solid:partOf urn:solid:items urn:solid:next urn:solid:prev

Used to chunk large unordered Collections (followers, likes, members). Each CollectionPage carries `as:partOf` (the parent Collection), `as:items` (this slice), and `as:next`/`as:prev` for navigation. For ordered collections, use `OrderedCollectionPage` instead so `orderedItems` carries semantically-meaningful order.

A CollectionPage in a pagination chain


A college, university, or other institution of higher education.

Subclass of `urn:solid:EducationalOrganization`. Use specifically for tertiary/higher-ed institutions; for schools at other levels schema.org provides `schema:School`, `schema:HighSchool`, `schema:MiddleSchool`. Pair with `urn:solid:alumniOf` for graduate listings.

A university


A comment on the parent CreativeWork — a reader's response or annotation.

Subclass of `urn:solid:CreativeWork`. Schema.org's comment type is for blog/article comments; pair with `schema:parentItem` (or `urn:solid:inReplyTo` for AS-style threading). For ActivityPub microblog responses, prefer `urn:solid:Note` with `inReplyTo`.

Comment on an article


A qualified PROV communication — the role-aware form of `wasInformedBy` between two Activities.

Use to qualify a `prov:wasInformedBy` with role and timing. Linked from an Activity via `prov:qualifiedCommunication`. Carries `prov:activity` (the prior Activity) and optional `urn:solid:hadActivity`/`urn:solid:hadRole`. Rare in casual data — most uses of "this followed that" stay at the `wasInformedBy` level.

Communication between two activities


A SKOS concept — a unit of thought (topic, category, term) suitable for use in a controlled vocabulary or thesaurus.

The atom of SKOS — every entry in a thesaurus, taxonomy, or controlled vocabulary is a Concept. Pair with `urn:solid:prefLabel` (canonical name), `urn:solid:altLabel` (synonyms), `urn:solid:broader`/`urn:solid:narrower` (hierarchy), and `urn:solid:inScheme` (membership in a `ConceptScheme`).

A concept in a tagging vocabulary


A SKOS concept scheme — an aggregation of related Concepts, typically a thesaurus, taxonomy, or controlled vocabulary.

The container for a controlled vocabulary. Concepts join via `urn:solid:inScheme`; the entry-point Concepts (no broader concept in this scheme) are listed via `urn:solid:hasTopConcept`. The IRI of the ConceptScheme itself is the canonical reference for the vocabulary as a whole.

A topic taxonomy


A contact point for a person or organization — an aggregation of reachable contact channels for a specific purpose or department.

Use to bundle multiple contact channels (email + phone + hours + language) under a single descriptive label like "customer support" or "press inquiries". For a vCard-style structured contact, the equivalent base is `vcard:VCard`.

Customer support contact point


A Linked Data Platform Container — an LDP resource that contains other resources, the LDP analogue of a directory.

The base LDP container type. Solid pods organise data into Containers (typically `ldp:BasicContainer`); members are listed via `urn:solid:contains`. Distinct from `as:Collection`, which is a logical grouping at the data layer rather than an HTTP-level resource container.

An LDP container with two members


The WAC Control access mode — meta-permission to read and modify the Authorization (`.acl`) file itself.

urn:solid:Read urn:solid:Write urn:solid:Append urn:solid:mode urn:solid:Authorization

Distinct from Read/Write/Append on the resource itself: Control governs *who can change the access rules*. Pod owners always have Control on their root; granting it to others delegates permission management. Treat as the most sensitive ACL mode.

Owner Authorization with Control


A country — a sovereign nation-state or territory.

Subclass of `urn:solid:Place` (via `schema:AdministrativeArea`). Pair with an ISO 3166-1 country code via `schema:identifier` for machine-readability. For US states, EU countries, and other administrative regions, use `schema:City`, `schema:State`, or `schema:AdministrativeArea` accordingly.

A country with an ISO code


An activity in which the actor has created the object.

Subclass of `urn:solid:Activity`. The canonical ActivityPub side-effect for publishing a new object — when an actor posts a Note, the wire-level activity is `Create` whose `as:object` is that Note. For PROV-grade generation events with timing, prefer `prov:wasGeneratedBy`.

Alice creates a note


The most generic kind of creative work — written, photographic, artistic, or otherwise.

Schema.org's catch-all for authored content — books, movies, articles, photos, software, datasets. Subclasses include `urn:solid:Article`, `schema:Book`, `schema:Movie`. Pair with `urn:solid:creator`, `urn:solid:license`, `urn:solid:datePublished` for typical attribution metadata.

A generic creative work


The descriptor for a Decentralized Identifier — carries the DID's verification keys, service endpoints, and controller relationships.

urn:solid:controller urn:solid:verificationMethod urn:solid:authentication urn:solid:serviceEndpoint

What you get when you resolve a DID. Contains everything needed to verify proofs signed by that DID and discover services it offers. The DID itself is the document's `@id`. Most decentralised-identity flows start by resolving a DID to its Document and pulling a `verificationMethod` out.

A minimal DID Document


A DCAT DataService — a service that gives access to one or more Datasets via an API or query interface.

DCAT 2's class for SPARQL endpoints, REST APIs, OGC services, and other data-access services. Distinct from `urn:solid:Service` (the AS actor type for ActivityPub services). Pair with `dcat:endpointURL` and `dcat:servesDataset` to link the service to the Datasets it exposes.

A SPARQL endpoint as a DataService


A DCAT Dataset — a collection of data, published or curated by a single agent and available in one or more representations.

DCAT's central class for data publication. Represents the abstract dataset; concrete files/APIs serving its content are `urn:solid:Distribution`s. Pair with `dcterms:title`, `dcterms:description`, `dcterms:publisher`, `urn:solid:keywords`, `dcat:theme`. Schema.org's `schema:Dataset` is the SEO-flavored equivalent.

A simple dataset


The class of RDF datatypes — XSD types (`xsd:string`, `xsd:dateTime`, `xsd:integer`) and any custom datatypes defined for an RDF graph.

A subclass of `rdfs:Class` whose instances are themselves datatypes. Most apps never declare new ones — the XSD set covers nearly every literal need. Use as the value of `@type` when minting a custom literal datatype (e.g. a regulated identifier format).

Declaring a custom datatype


An OWL property whose values are literals — strings, numbers, dates, booleans — never IRIs or blank nodes.

Examples: `foaf:name`, `as:totalItems`, `dcterms:created`. Distinct from `owl:ObjectProperty` (whose values are individuals). The split lets reasoners and serialisers handle literals (no dereferencing needed) differently from object references.

Declaring foaf:name as a DatatypeProperty


A qualified PROV delegation — the role-aware form of `actedOnBehalfOf` between two Agents.

Use to qualify a `prov:actedOnBehalfOf` with role and the activity it occurred during. Linked from a delegate Agent via `prov:qualifiedDelegation`. Useful for bots-on-behalf-of-users, services-acting-for-organizations.

Bot delegated by a human


An activity in which the actor has deleted the object.

Subclass of `urn:solid:Activity`. The wire-level signal that an object has been removed. Receivers typically replace their cached object with an `as:Tombstone` rather than dropping the record entirely, preserving links from elsewhere.

Alice deletes a note


A typed PROV derivation event — a relation between a derived entity and the entity it was derived from.

Use to qualify a `prov:wasDerivedFrom` with role, generation, usage, or activity context (via `prov:qualifiedDerivation`). Specialized subclasses include `urn:solid:Revision` (substantive change), `urn:solid:Quotation` (excerpt), and `prov:PrimarySource` (first-hand origin).

A qualified derivation


An electronic document — typically a file (PDF, spreadsheet, presentation, text file).

Subclass of `urn:solid:CreativeWork`. Distinct from FOAF `urn:solid:Document` (any document, including web pages): DigitalDocument is specifically a file-as-document with subclasses for spreadsheets, presentations, text. Pair with `urn:solid:format` for the MIME type.

A PDF document


An LDP Container that adds membership triples on a separate `membershipResource` rather than carrying them itself.

Subclass of `urn:solid:Container`. Use when membership of new resources should be reflected on a *different* resource — e.g. a comments container whose POSTs add triples to the parent article. Carries `ldp:membershipResource` and `ldp:hasMemberRelation` to define the relation. Most Solid pods use `urn:solid:BasicContainer` instead.

A direct container reflecting members on its parent


A DCAT Distribution — a specific representation of a Dataset (a downloadable file or accessible API).

One Dataset typically has multiple Distributions — CSV, JSON, RDF, API endpoint, archive. Pair with `urn:solid:downloadURL` (direct file URL), `urn:solid:accessURL` (general access page or API), `urn:solid:format`, `urn:solid:byteSize`. Linked from a Dataset via `dcat:distribution`.

CSV distribution of a dataset


A document of any kind — typically a web resource.

Use as the type of any document-like resource (web page, file, blog post home). For richer creative-work modeling with authorship, dates, and licensing, `schema:CreativeWork` carries more fields. Note that `urn:solid:Image` is a subclass of Document.

A document


An educational organization — a school, college, university, or training institute.

Subclass of `urn:solid:Organization`. Use as the value type of `urn:solid:alumniOf` for richer educational-history data than a bare `foaf:schoolHomepage` URL. Schema.org has narrower subclasses (`School`, `CollegeOrUniversity`, `HighSchool`, `MiddleSchool`) for specific levels.

An educational organization


An email address — the value class for `urn:solid:hasEmail` when the email is described as a typed resource rather than a bare `mailto:` IRI.

Class form pairing with the existing `hasEmail` property. vCard's two encodings: (1) `hasEmail` directly to a `mailto:` IRI for simple cases, or (2) `hasEmail` to an `Email`-typed resource with `vcard:value` (mailto IRI) plus role classes like `Home`/`Work` for typed addresses. Use this class for the typed-resource form.

Person with a typed work email

Initial term — Class form pairing with the existing hasEmail property.


An email message — represents a single sent or received email as RDF.

Subclass of `schema:Message` and `urn:solid:CreativeWork`. Pair with `schema:sender`, `schema:recipient`, `schema:about`, `schema:dateSent`, `schema:dateReceived`. Useful for archival/threading systems that index email as RDF rather than treating each message as opaque text.

An email message


A PROV Collection with no members — the explicit empty case.

Useful when you need to assert "this collection is definitively empty" rather than "the membership is unknown". Often the first state of a collection in a build pipeline before items are added; subsequent versions then `prov:wasDerivedFrom` the EmptyCollection.

Initial empty bundle


Anything in PROV that has provenance — a thing whose existence and history can be tracked.

PROV's most general thing class — documents, datasets, software releases, physical objects can all be Entities. Used as the subject of `prov:wasGeneratedBy`, `prov:wasDerivedFrom`, `prov:wasAttributedTo`. Distinct from `as:Object` which is the ActivityStreams base class for social-graph objects.

A versioned document as a PROV Entity


An event happening at a certain time and (often) location.

Use for scheduled occurrences — meetings, conferences, releases, performances. Pair with `schema:startDate`, `schema:endDate`, `schema:location`. For ActivityStreams-style social events (with attendees as actors), `as:Event` carries actor-friendly semantics.

A simple event


A web page that answers commonly-asked questions on a particular topic.

Subclass of `urn:solid:WebPage`. Pair with `schema:mainEntity` listing `urn:solid:Question` resources, each carrying its own `Answer`. Heavily used by Google for FAQ rich results. The page itself models multiple Q&As, distinct from a forum where each Question is a separate page.

An FAQ page

A canonical RDF term registry for Solid.


A digital file format — typically referenced as the type of a `dcterms:format` value.

Use as @type for FileFormat resources referenced from `urn:solid:format`. The IANA media type registry serves as the canonical FileFormat namespace; values typically come from there. For the broader "this is a media type" class, see `dcterms:MediaType`.

PDF as a FileFormat resource


An ActivityStreams Activity indicating that the actor is reporting the object as objectionable — the standard fediverse content-moderation primitive.

How users report posts/accounts to moderators. Distinct from `Block` (the actor cuts off the target for themselves) and `Ignore` (the actor mutes content without action) — `Flag` is escalation, asking someone with authority to act. Most fediverse servers route Flag activities to the moderation queue.

Reporting a Note for moderation


An indication that the actor wants to follow the object — typically another Actor.

Subclass of `urn:solid:Activity`. The ActivityPub follow request — typically responded to with `as:Accept` or `as:Reject` by the followee. Use `urn:solid:knows` for non-directed acquaintance (FOAF tradition). To unfollow, send an `as:Undo` of the original Follow.

Alice follows Bob


An ORG FormalOrganization — an organization with legal recognition (company, government body, registered nonprofit).

Subclass of `urn:solid:Organization`. Distinguishes legally-recognized entities from informal collectives (which stay at the `Organization` level). Use when legal status matters — contracts, regulatory filings, official records. Pair with `org:identifier` for the registration number.

A registered company


A rate at which something recurs — daily, weekly, monthly, etc.

Used to type Frequency values referenced by `dcterms:accrualPeriodicity` (the frequency at which a dataset is updated). Common controlled-vocabulary values come from the EU Publications Office Frequency vocabulary. For ad-hoc use, free-form strings are acceptable.

A frequency value


An OWL property that takes at most one value per subject — if `A p B` and `A p C`, then `B owl:sameAs C`.

Examples: `foaf:gender`, `dcterms:created`, `as:totalItems`. Different from a non-functional property like `foaf:knows` (an Actor can know many people). Reasoners use functionality to detect data errors ("two different birth dates for one person — they must be the same date") or to merge identifiers.

Declaring as:totalItems as functional


A qualified PROV generation event — the moment an Activity produced an Entity.

Use to qualify `prov:wasGeneratedBy` with timing, role, or location. Linked from an Entity via `prov:qualifiedGeneration`. Carries `prov:activity`, `urn:solid:atTime`, and `urn:solid:hadRole`.

Qualified generation of an artifact


The geographic coordinates of a place — a latitude/longitude pair, optionally with elevation.

Carries `schema:latitude` and `schema:longitude` (decimal degrees, WGS-84) and optional `schema:elevation`. Use as the value of `schema:geo` on a Place. For a `geo:` URI shortcut, see `urn:solid:hasGeo`. For shapes (polygons), use `schema:GeoShape`.

Coordinates for a place


A collection of agents — informal or ad-hoc, not necessarily a formal organization.

Subclass of `urn:solid:Agent`. Use for any collection of agents — friends, mailing-list subscribers, project contributors. Use `urn:solid:Organization` when the collective has formal/legal structure. Members are listed with `urn:solid:member`.

A simple Group


An ActivityStreams Link representing a hashtag — a topical keyword, conventionally prefixed with `#`, attached to an Object as a tag.

urn:solid:Mention urn:solid:tag urn:solid:Link urn:solid:Object

The fediverse-canonical way to attach topic tags to a Note or Article. Use as a value of `as:tag`; the `name` carries the displayed string (with the `#`), and `href` is a URL clients can dereference for the topic feed. Mastodon and most ActivityPub servers treat this as the de facto standard.

A Note tagged with a Hashtag


Instructions for performing a task — a tutorial or how-to guide.

Subclass of `urn:solid:CreativeWork`. Use for any step-by-step tutorial. `urn:solid:Recipe` is the cooking-specific subclass. Pair with `schema:step` (an `ItemList` of `schema:HowToStep`s), `schema:totalTime`, `schema:estimatedCost`, `schema:tool`. Heavily used by Google for SEO rich results.

A how-to guide


An ActivityStreams Activity indicating that the actor is silently disregarding the object — a soft mute, distinct from Block.

Lighter-touch than `Block`: typically not federated to the target (the target shouldn't know they were ignored), and the relationship persists. Distinct from `Reject` (which actively declines a request) — `Ignore` is one-sided, internal to the actor.

Ignoring a notification


An image — a document that is a still picture (PNG, JPEG, SVG, etc.).

Subclass of `urn:solid:Document`. Use as the value type of `urn:solid:depiction` / `urn:solid:img`. For rich image metadata (dimensions, encoding, captions), `schema:ImageObject` carries more fields.

An image


A rich image object — an image with structured metadata like dimensions, encoding, and caption.

Schema.org's metadata-rich image type. Use when you need fields like `schema:width`, `schema:height`, `schema:contentUrl`, `schema:caption`, `schema:encodingFormat`. For a bare image resource without those fields, `urn:solid:Image` (FOAF) is enough.

A photo with rich metadata


An LDP Container whose membership triples reference an indirected member resource via `insertedContentRelation`.

Subclass of `urn:solid:Container`. The most flexible LDP container type — when a new resource is POSTed, the server uses `ldp:insertedContentRelation` to extract the value to use as the actual membership target. Useful for federated data where the resource POSTed isn't itself the subject of the membership triple. Rarely needed; most Solid pods use `urn:solid:BasicContainer`.

An indirect container


PROV's most general qualified-relation superclass — any role-aware connection between an Activity, Entity, or Agent.

urn:solid:Generation urn:solid:Usage urn:solid:Attribution urn:solid:Association urn:solid:Derivation urn:solid:Communication urn:solid:Delegation

Superclass of all PROV qualified relations (`Generation`, `Usage`, `Attribution`, `Association`, `Derivation`, `Communication`, `Delegation`, `Invalidation`, `End`, `Start`). Rarely typed directly — pick a specific subclass for clarity. Useful when reasoning generically over PROV qualifications.

An influence relation


An ActivityStreams Activity that has no direct object — the actor performs the verb without acting upon a specific thing (Travel, Move, Arrive).

urn:solid:Activity urn:solid:Travel urn:solid:Move urn:solid:Arrive

The grammatical analogue of intransitive verbs in language: "Alice walked" doesn't take an object the way "Alice liked X" does. AS supplies subclasses (`Travel`, `Move`, `Arrive`); custom intransitive activities subclass this directly. `as:object` is omitted; `as:origin` and `as:target` typically substitute.

A simple Travel activity (no @object)


A qualified PROV invalidation event — the moment an Entity ceased to exist.

End-of-life counterpart to `urn:solid:Generation`. Use to qualify `prov:wasInvalidatedBy` with `urn:solid:atTime` and other context. Linked from an Entity via `prov:qualifiedInvalidation`. ActivityStreams' lighter equivalent for social data is `as:Tombstone`.

Qualified invalidation of a deleted post


An OWL property whose value uniquely identifies the subject — if `A p X` and `B p X`, then `A owl:sameAs B`.

Classic example: `foaf:mbox` — two agents sharing an email address are the same agent. Used heavily in entity resolution: declare the identity-bearing properties as `InverseFunctionalProperty` and reasoners merge accounts that match. Mirror of `FunctionalProperty` (which constrains the value side, not the subject).

foaf:mbox as inverse-functional


An ordered list of items — schema.org's lightweight ordered collection for SEO-rich markup.

Schema.org's order-aware list type. Pair with `schema:itemListElement` (each item, optionally wrapped in `schema:ListItem` carrying `schema:position`). For ActivityStreams ordered collections, prefer `urn:solid:OrderedCollection`. Heavily used by SEO for top-N lists, breadcrumbs, FAQ pages.

Top-3 list


A listing for a job — an opportunity to be employed in a specific role.

Pair with `schema:hiringOrganization`, `schema:jobLocation`, `schema:datePosted`, `schema:baseSalary`, `schema:employmentType`. Heavily used by job boards for SEO rich results — Google specifically rewards correct JobPosting markup.

A job posting


A legal, political, or administrative jurisdiction — a country, state, or governing region.

Distinct from `urn:solid:Country`: a Jurisdiction can be sub-national (US state, EU directive area), supra-national (UN, EU), or non-geographic (corporate by-laws). Used in legal/regulatory metadata to scope which laws or rules apply.

A jurisdiction


A legal document giving permission to do something with a resource — typically referenced by the `license` predicate.

The class for license documents themselves — Creative Commons license pages, SPDX license texts, custom EULAs. Use as the `@type` of the resource pointed to by `urn:solid:license`. Existing well-known licenses (Creative Commons, SPDX) usually don't carry this type explicitly, but it's the formal class.

A custom license document


An indication that the actor likes, recommends, or favorites the object.

Subclass of `urn:solid:Activity`. The classic ActivityPub favourite/like. The `as:object` is the thing being liked; `as:actor` is the liker; `as:published` records when. To unlike, send an `as:Undo` of the original Like.

Alice likes a note


A system of communication including written, spoken, signed, or symbolic languages.

Use as @type for resources representing languages — typically referenced from `urn:solid:language` when you need a structured Language resource rather than a bare BCP 47 tag. The IANA language subtag registry serves as the canonical LinguisticSystem namespace.

A LinguisticSystem resource


An ActivityStreams Link — a typed, qualified pointer to a resource. Distinct from a plain URL string in that a Link can carry rel, hreflang, mediaType, dimensions, and a name.

urn:solid:Object urn:solid:href urn:solid:rel urn:solid:hreflang urn:solid:Mention urn:solid:Hashtag

Sibling of `as:Object`, not a subclass — the AS data model has Objects (things) and Links (references to things). Use Link when you need to attach metadata to the *reference* (e.g. "this is the canonical alternate, in French, video/mp4") rather than to the target. `Mention` and `Hashtag` are specialised Link subclasses.

A typed Link with metadata


An entry in a schema.org ItemList — wraps the item with positional metadata.

Used inside `urn:solid:ItemList` to declare each item with its position. Carries `schema:position` (integer) and `schema:item` (the wrapped resource). For breadcrumbs and ranked lists, `schema:position` is what consumers (Google, etc.) use for ordering.

List item with position


An ActivityStreams Activity indicating that the actor listened to the object — typically audio content (a song, podcast episode, broadcast).

Records consumption of audio content as a first-class event — useful for scrobbling, recommendations, listening history, and reading-progress analogues. Pair with `as:instrument` to record the client/device used.

Listened to a podcast episode


A vCard Logo resource — the logo image associated with a vCard (typically for an Organization).

Distinct from `urn:solid:Photo` (typically a person's portrait) and generic `urn:solid:Image`: a Logo specifically represents a brand or organizational mark. Used as the value of `urn:solid:hasLogo`.

Organization vCard with a logo


A union class for `dcterms:MediaType` and `dcterms:SizeOrDuration` — the range of `dcterms:format`.

Type of values for `dcterms:format`: either a media type (IANA registry, file format) or a size/duration. Rarely typed directly — usually you pick a more specific subclass (`FileFormat`, `MediaType`, `SizeOrDuration`).

A MediaTypeOrExtent value


An LDP marker class for the special predicate value used by IndirectContainers when membership is computed from the inserted resource itself.

Used as the value of `ldp:insertedContentRelation` to indicate "use the new resource itself as the membership target, not a property inside it". Niche LDP escape hatch — most use cases are better served by ldp:BasicContainer or by naming a specific predicate.

IndirectContainer using MemberSubject


An ORG Membership — a role-and-time-aware participation of an Agent in an Organization.

Use when membership has structure — start/end dates, role, or compensation — that doesn't fit into a flat `urn:solid:memberOf` triple. Carries `org:member` (the Agent), `org:organization` (the Organization), and `org:role`. For simple membership, the flat `urn:solid:memberOf` predicate is enough.

A role-aware membership


An ActivityStreams Link representing a mention of an Actor — typically authored as `@user@host` and attached to an Object so the mentioned party is notified.

urn:solid:Hashtag urn:solid:tag urn:solid:Link urn:solid:Actor

Use as a value of `as:tag` alongside the actor's URI in `href`. ActivityPub servers use Mentions to drive notification delivery — including a Mention is *the* mechanism by which a remote user learns they were addressed in a post. Distinct from `as:to`/`as:cc` (delivery audience) and from a Hashtag (topical, not addressed).

A Note mentioning another actor


An activity in which the actor moves the object from one location (origin) to another (target).

Subclass of `urn:solid:Activity`. Combines `Add` + `Remove` semantics: `as:object` is what's being moved, `as:origin` names the source location, `as:target` names the destination. Common use in ActivityPub is account migration (moving an actor from one server to another).

Account migration


A movie — a feature-length motion picture released as a single work.

Subclass of `urn:solid:CreativeWork`. Distinct from `urn:solid:VideoObject` — `Movie` is the work (the film as art), `VideoObject` is the file (a particular encoding). One Movie can have many VideoObject encodings. Pair with `schema:director`, `schema:actor`, `urn:solid:duration`.

A movie with director and runtime


A music recording — a song or instrumental track in its recorded form.

Distinct from `urn:solid:AudioObject` (the file as bytes) and `schema:MusicComposition` (the abstract work). A MusicRecording is a specific recorded performance. Pair with `schema:byArtist`, `schema:inAlbum`, `schema:duration`, `schema:isrcCode`.

A music recording


A news article — a journalistic article published as part of news media coverage.

Subclass of `urn:solid:Article`. Use specifically for journalism — distinguishes from `BlogPosting` (personal/informal) and generic `Article`. Heavily used by Google News and AMP for SEO rich results. Pair with `schema:dateline`, `schema:printPage`, `schema:articleSection`.

A news article


An LDP Resource whose state is NOT RDF — typically a binary file like an image, audio, or PDF.

Subclass of `urn:solid:Resource`. Use for binary files stored in a Solid pod (photos, audio, PDF, video, plaintext, source code). The server returns the file content directly under its declared media type, not RDF. Pair with describing-resources (RDF) that reference the binary.

A binary image stored in a pod


A short written work — typically a microblog post, comment, or reply.

ActivityStreams short-form post: a tweet, toot, comment, status update. Use `urn:solid:Article` for longer-form essays. Pair with `urn:solid:content` (the body) and `urn:solid:attributedTo` (the author).

A microblog post


A Linked Data Notification — a message POSTed to an inbox to inform the receiver about something.

From Linked Data Notifications (LDN) and Solid notifications. POSTed to a `urn:solid:inbox` container. The payload is RDF; common shapes use ActivityStreams `as:Activity` so the same primitive carries both "a thing happened" and "please notify someone".

A simple notification


The base class for all ActivityStreams objects — anything that can be the subject or target of an Activity.

Almost everything in ActivityStreams ultimately specializes Object — Note, Article, Image, Activity, etc. Rarely typed directly; you'll usually pick a subclass. Pair with `urn:solid:content`, `urn:solid:name`, `urn:solid:attributedTo`, and the various AS predicates.

A bare AS Object


An OWL property whose values are individuals (other resources, identified by IRI or blank node) — never literal strings, numbers, or dates.

Examples: `foaf:knows`, `as:actor`, `dcterms:creator`. Distinct from `owl:DatatypeProperty` (whose values are literals like "Alice" or 42). The split helps reasoners and tooling — an ObjectProperty value is dereferenceable, a DatatypeProperty value is not.

Declaring as:actor as an ObjectProperty


An offer to transfer some rights to an item or to provide a service — typically a price for a Product.

Distinct from `urn:solid:Product`: an Offer is the *availability and terms* of obtaining the Product (price, currency, seller, validity window). One Product can have many Offers (different sellers, different prices, sales). Pair via `schema:itemOffered`.

Offer for a product


An account held by an Agent on some online service.

Use as the value type of `urn:solid:account`. Typically described with `foaf:accountName` (the username) and `foaf:accountServiceHomepage` (the service's homepage). For a Solid pod account specifically, see `solid:Account`.

An OnlineAccount on a service


An ordered collection of objects — most-recent-first by convention in ActivityPub.

Subclass of `urn:solid:Collection`. The shape used by ActivityPub inboxes and outboxes. Members are enumerated via `as:orderedItems` (or paginated via `as:first`/`as:next`); items are typically sorted reverse-chronologically.

An outbox as an OrderedCollection


A single page of an ActivityStreams OrderedCollection — the ordered analogue of CollectionPage, with members in `as:orderedItems` rather than `as:items`.

urn:solid:OrderedCollection urn:solid:CollectionPage urn:solid:partOf urn:solid:orderedItems urn:solid:next urn:solid:prev

The standard wire format for ActivityPub outboxes, inboxes, and any Collection where chronological order matters. JSON array order is canonical; servers SHOULD preserve it across clients. Pagination follows the same `partOf`/`next`/`prev` pattern as `CollectionPage`.

An outbox page with three Activities


A formal organization — a company, society, institution, or other collective with structure.

Subclass of `urn:solid:Agent`: every Organization is an Agent, but not every Agent is an Organization (people, software). Use `Organization` when the actor has formal/legal structure; use `Agent` when the actor's nature is unspecified or could be a person.

A simple organization


An ORG OrganizationalUnit — a part of a larger Organization (department, team, division) without independent legal status.

Subclass of `urn:solid:Organization`. Distinguishes internal divisions from legally-recognized entities (which use `urn:solid:FormalOrganization`). Pair with `urn:solid:subOrganizationOf` to point at the parent.

An engineering team within a company


A named or bounded interval of time — a year, an era, a meeting window, a coverage period.

Use as the value type of `urn:solid:temporal` for richer time-coverage metadata than a plain ISO 8601 interval string. For full temporal logic with intervals, instants, and Allen relations, use the OWL-Time vocabulary instead.

A named period of time


Use for any human individual. Prefer this over `vcard:Individual` unless vCard-specific properties are needed, and over `schema:Person` when interoperating with FOAF-based Solid data.

Minimal JSON-LD


A document that describes a person — typically a FOAF or WebID profile.

Subclass of `urn:solid:Document`. The document's `foaf:primaryTopic` is the Person it describes. WebID profile documents are typically of this type. The relationship between the document and its subject Person is asymmetric: one document, one primary topic.

A WebID profile document


A vCard Photo resource — a photographic image associated with a vCard.

Use as @type for the value of `urn:solid:hasPhoto` when modelling the photo as a structured resource (with format, source, etc.) rather than a bare URL. For non-vCard image resources, prefer `urn:solid:Image` (FOAF) or `urn:solid:ImageObject` (schema.org).

vCard with a Photo resource


A material or physical carrier of a resource — paper, vinyl, magnetic tape, stone tablet.

Use as @type for resources representing physical media — typically referenced from `dcterms:medium`. Library and archive contexts use this to record the carrier separately from the digital format. For digital file formats, use `urn:solid:FileFormat` instead.

Vinyl record as a PhysicalMedium


An entity that has a somewhat fixed physical extension — a city, building, landmark, room.

Use for any geographic feature with a roughly stable footprint. Pair with `urn:solid:hasGeo` (or `schema:geo`) for coordinates and `urn:solid:hasAddress` for postal info. For dynamic event locations, use ActivityStreams `as:Place`.

A landmark


An entity describing a plan — a set of intended actions to achieve some goal.

PROV subclass of `urn:solid:Entity`. A Plan is the design or recipe an Activity follows — distinct from the Activity itself (the execution). Linked to an Activity via `prov:hadPlan`, typically inside a `prov:Association`.

A build plan


A statement of policy applicable to the resource — terms of use, retention rules, access guidelines.

Broader than `urn:solid:LicenseDocument` (which is specifically a legal grant of permissions): a Policy can be any normative document — privacy policy, retention policy, code of conduct. For machine-actionable access control on Solid pods, use the WAC vocabulary instead.

A privacy policy


A position within an organization that may be filled by an Agent — independent of who currently holds it.

urn:solid:Organization urn:solid:Membership urn:solid:role urn:solid:holds

A Post is a *seat* (e.g. "CTO of ACME"); the Agent who fills it changes over time. Compare with `org:Membership` (a time-bound link between Agent, Organization, and Role) and `org:Role` (the abstract role itself). Use Post when the position has an identity independent of its current holder.

A named position in an organization


A structured postal address — street, locality, region, postal code, country.

Use for snail-mail addresses with structured fields (`schema:streetAddress`, `schema:addressLocality`, `schema:postalCode`, `schema:addressCountry`). For vCard-flavored data, the equivalent is `vcard:Address`.

A postal address


A qualified PROV derivation typing the relation as a primary-source attribution — first-hand origin.

Subclass of `prov:Derivation` typing it as primary-source attribution — eyewitness account, raw measurement, canonical document. Use the `urn:solid:hadPrimarySource` shortcut when you don't need the qualified form.

Article based on a primary source


A document registered in the user's private TypeIndex — discoverable only by the pod owner.

Marker type for documents that should appear in (or be reachable from) a `solid:privateTypeIndex`. Pairs with `urn:solid:PublicDocument`. Concrete instance documents typically also carry a domain-specific class.

Private journal registered in the private TypeIndex


Anything that is made available for sale — a physical good, a service, or a digital item.

Schema.org's commerce-anchor class. Pair with `urn:solid:Offer` (the price/availability) and `urn:solid:Review` / `urn:solid:Rating`. For non-commercial creative works, `urn:solid:CreativeWork` is the better base; Product specifically implies a market context.

A simple product


An ActivityStreams Object that describes another Object — typically supplemental information about an Actor (a richer biography, alternate display data) layered on top of the actor's primary record.

urn:solid:Object urn:solid:Actor urn:solid:describes urn:solid:Person

A Profile uses `as:describes` to point at the Object it documents. Useful when the descriptive payload is large or evolves independently of the actor's identity record (e.g. a long bio with media attachments) — the Profile is fetched separately and may be cached, signed, or replicated apart from the Actor.

A Profile that describes an Actor

Software engineer interested in decentralised systems.


A project — a collaborative undertaking with a goal.

Use for any deliberate, goal-oriented effort — software project, research project, organizing initiative. For software projects specifically, the DOAP vocabulary (`doap:Project`) carries richer fields like repository, release, and license.

A project with a current participant


The class of RDF properties — predicates that connect a subject to a value (`name`, `knows`, `published`, etc.).

urn:solid:Class urn:solid:subPropertyOf urn:solid:domain urn:solid:range

Foundational RDF term. Every property definition in this registry is `@type: rdf:Property`. Pair with `rdfs:domain` (subject types) and `rdfs:range` (value types) to constrain usage.

Declaring a custom property


A statement about the provenance of a resource — its origin, custody history, transformations.

Use as @type for free-form provenance documents — narrative descriptions of where a resource came from. For machine-actionable provenance graphs, prefer the PROV vocabulary (`urn:solid:Entity`, `urn:solid:Bundle`, etc.).

A provenance statement

Compiled from sensor readings collected by Wonderland Climate, validated against the 2026 baseline.


The ActivityPub special-purpose IRI denoting the public audience — addressing an Activity to it makes the Activity visible to anyone, anywhere on the network.

The single most-referenced IRI on the fediverse. Used as a value of `as:to` or `as:cc` to mark a post as public; absence of it means the post is non-public regardless of other audience settings. Mastodon and most ActivityPub servers also accept the synonyms `as:Public` and `Public` in compact form.

A public Note


A document registered in the user's public TypeIndex — discoverable by anyone who can read the TypeIndex.

Marker type for documents that should appear in (or be reachable from) a `solid:publicTypeIndex`. Pairs with `urn:solid:PrivateDocument`. Concrete instance documents typically also carry a domain-specific class (`schema:Article`, `wf:Tracker`, etc.).

Public profile page registered in the TypeIndex


A question being asked — typically with one or more proposed answers (a poll).

AS Question is both an `as:IntransitiveActivity` and an Object — it represents a poll or survey. Pair with `as:oneOf` (single-choice options) or `as:anyOf` (multi-choice). For straight Q&A without polling semantics, schema:Question + schema:Answer is more general.

A simple poll


A PROV Derivation that represents a quoted excerpt from another entity, with attribution.

Subclass of `prov:Derivation`. Use when the new entity contains content directly lifted from another (excerpts, citations, screenshots). Distinct from `urn:solid:Revision` (substantive change to the same identity) and `prov:PrimarySource` (first-hand origin attribution).

A quote in a review


An LDP Resource whose state is represented as RDF — a Turtle, JSON-LD, or other RDF document.

Subclass of `urn:solid:Resource`. Use for any resource an LDP server returns as RDF — profile cards, Type Indexes, RDF data files. Containers are also `RDFSource`s (their state-as-RDF lists members). For binary files (images, videos), use `urn:solid:NonRDFSource` instead.

A profile document


A numeric or symbolic value expressing assessment quality — typically a star rating.

Bare assessment with `schema:ratingValue` (the score), `schema:bestRating` and `schema:worstRating` (the scale). For an aggregate ("4.3 stars from 217 reviews") use `schema:AggregateRating`. Embed inside a `urn:solid:Review` via `schema:reviewRating`.

A 5-star rating


The WAC Read access mode — permission to fetch the contents of a resource.

urn:solid:Write urn:solid:Append urn:solid:Control urn:solid:mode urn:solid:Authorization

Used as the value of `urn:solid:mode` on an `urn:solid:Authorization`. Granting Read on a Container also grants ability to list its members. Does NOT grant access to children individually unless `acl:default` propagation is also set.

Public-read Authorization


A recipe — instructions for preparing a dish, with ingredients, steps, and yield.

Subclass of `schema:HowTo` (and indirectly of `urn:solid:CreativeWork`). Pair with `schema:recipeIngredient`, `schema:recipeInstructions`, `schema:recipeYield`, `schema:cookTime`, `schema:nutrition`. Heavily used by recipe sites for SEO rich results.

A simple recipe


An indication that the actor rejects the object — typically a Follow request or invitation.

Subclass of `urn:solid:Activity`. The negative counterpart of `Accept` — typically used to decline a `Follow` or invitation. The `as:object` is what's being rejected. After a Reject, the original request should not be considered active.

Bob rejects a follow request


An ActivityStreams Object representing a typed relationship between two other Objects — typically two Actors connected by a relationship type (friend, colleague, follower).

urn:solid:Actor urn:solid:subject urn:solid:object urn:solid:relationship

Carries `as:subject`, `as:object`, and `as:relationship` (the kind of link). Reify a connection as a first-class entity when you need to attach metadata to it (when it started, who asserted it, whether it's reciprocated) — otherwise a direct property like `foaf:knows` is simpler.

A reified friendship between two actors


An activity in which the actor is removing the object from the target.

Subclass of `urn:solid:Activity`. Inverse of `urn:solid:Add` — `as:object` is the thing being removed, `as:target` is the collection or container it's being removed from. The object continues to exist; only its membership in the target ends. Distinct from `Delete`, which retires the object itself.

Remove a note from a collection


An LDP Resource — any HTTP-addressable resource managed by an LDP server.

The root LDP class — every Solid pod resource (file, container, RDF document) is an `ldp:Resource`. Use the more specific subclasses `urn:solid:RDFSource` (RDF documents), `urn:solid:NonRDFSource` (binary files like images), and `urn:solid:Container` (directories) when you can.

An LDP resource


An anonymous OWL class defined by a constraint on one property — e.g. "things whose `foaf:age` is at least 18".

A `Restriction` is a class — anything that satisfies the restriction is an instance of it. Combine with `owl:onProperty` (which property to constrain) and one of `someValuesFrom`/`allValuesFrom`/`hasValue`/`cardinality` (the actual constraint). Building block for OWL class expressions.

A class of objects with at least one knows relation


A review of an item — typically a Product or CreativeWork — by an author.

Subclass of `urn:solid:CreativeWork`. A Review carries an opinion (`schema:reviewBody`), a `urn:solid:Rating`, and a pointer to the reviewed item via `schema:itemReviewed`. Distinct from `Rating`, which is the bare numeric/star value without prose.

A product review


A PROV Derivation that represents a revised version of an entity — a substantive change without breaking identity continuity.

Subclass of `prov:Derivation`. Use to type a derivation specifically as a revision — a v2 of a spec, a corrected dataset, an edited document. Distinct from `prov:Quotation` (excerpting) and `prov:PrimarySource` (original-source attribution).

Revised spec


A statement about the intellectual property rights held in or over a resource.

Use as @type for documents stating rights — copyright notices, restriction declarations, public-domain dedications. Distinct from `urn:solid:LicenseDocument` (specifically a permission grant) and `urn:solid:Policy` (broader normative documents). The Rights Statements consortium (rightsstatements.org) provides a standardized set.

A rights statement


An ActivityStreams actor representing a service — an automated, headless software offering.

AS actor type for non-interactive automated services (relays, search engines, archive bots) — distinct from `urn:solid:Application` which implies a user-facing client. Both subclass `as:Object` indirectly. The choice is descriptive, not enforced.

An archive relay as a Service


A physical location at which an Organization operates — an office, factory, branch, or campus.

Sites are *where* the Organization is, distinct from the Organization itself (which is the legal/social entity) or its OrganizationalUnits (the structural divisions). One Organization may have many Sites; one Site may host parts of several Organizations.

An office site of a company


A measured size or duration of a resource — pages, bytes, runtime, dimensions.

Use as @type when modelling extent/duration as a structured resource rather than a free-form string. Typically referenced from `dcterms:extent`. For simple cases, the string form on `urn:solid:extent` or `urn:solid:duration` is sufficient.

A SizeOrDuration resource


A post to a social-media platform — tweet, toot, status update, microblog entry.

Subclass of `urn:solid:Article`. Schema.org's social-post type — the SEO-flavored counterpart of ActivityStreams `urn:solid:Note`. For ActivityPub-flavored data, prefer `Note`; for SEO/microdata on web pages, `SocialMediaPosting`.

A schema.org social media post


A piece of software acting as an agent — a script, build tool, bot, or service.

PROV subclass of `urn:solid:Agent` for software actors — the right type for build pipelines, CI runs, automated curators (this loop), data-pipeline jobs. ActivityStreams equivalents are `urn:solid:Application` (interactive client) and `urn:solid:Service` (headless service); use those for ActivityPub-flavored social data.

A curation script as a SoftwareAgent


A software application — desktop, mobile, web, or server software.

Subclass of `urn:solid:CreativeWork`. Distinct from AS `urn:solid:Application` (the actor type) and PROV `urn:solid:SoftwareAgent` (process-attribution): SoftwareApplication is the *product* — what's published, downloaded, reviewed. Pair with `schema:applicationCategory`, `schema:operatingSystem`, `schema:downloadUrl`.

A simple software application


A reference point against which other resources can be evaluated or compared — a specification, schema, or policy.

Use as the @type for specs, schemas, normative documents — anything resources can `dcterms:conformsTo`. RFCs, W3C Recommendations, ISO standards, JSON Schemas all qualify. Pair with `urn:solid:identifier` for a stable reference (RFC number, spec ID).

JSON Schema declared as a Standard


A storage space (Solid pod root) — the class of resources that act as the root of a personal data store.

Class form paired with the `urn:solid:storage` property. The pod root container is typed `urn:solid:Storage`; the WebID profile then links to it with `urn:solid:storage`. Solid clients use the storage URI as the root for follow-your-nose discovery (TypeIndex, preferences file, registries).

WebID linking to its pod storage

The storage container itself, typed

Initial term — Class form completing the Storage/storage case-pair.


An OWL property whose inverse is itself — if `A p B`, then `B p A`.

Classic examples: `owl:sameAs`, `foaf:knows`, `prov:alternateOf`, `dcterms:relation`. Use for two-way relations the writer should only need to assert once. Distinct from a property that simply has a separately-named inverse (`hasPart` vs `isPartOf`) — symmetric properties *are* their own inverse.

Declaring foaf:knows as symmetric


A vCard Tel resource — a structured telephone-number entry with type tags and value.

Use as @type for the value of `urn:solid:hasTelephone` when you need typed numbers (work/home/cell/fax) or other vCard Tel sub-types. Carries `vcard:hasValue` (a `tel:` URI) and one or more sub-class types like `vcard:Voice` or `vcard:Cell`.

vCard with a typed cell phone


An ActivityStreams Activity indicating that the actor accepts the object provisionally — a soft "yes, probably" rather than a firm commitment.

Common in calendaring: an event invitation gets a `TentativeAccept` when the recipient is interested but not certain. Specialises `as:Accept` — a consumer that doesn't recognise the tentative variant can fall back to treating it as Accept and lose only the nuance.

Tentatively accepting an event invitation


An ActivityStreams Activity indicating that the actor declines the object provisionally — a soft "probably no" rather than a firm refusal.

Mirror of `as:TentativeAccept`; specialises `as:Reject`. Common in calendaring and RSVP flows where the actor is unlikely to attend but hasn't ruled it out. Consumers that don't recognise the tentative variant degrade gracefully to treating it as Reject.

Tentatively declining an invitation


The OWL top class — every other class is a subclass of `owl:Thing`. Schema.org also uses a class called `Thing` as its root; both are aligned in this term.

The universal class — every individual is implicitly a `Thing`. Rarely used as an explicit `@type`; mostly relevant in OWL reasoning and as the root of Schema.org's hierarchy. Two upstream vocabs land on this name (OWL and Schema.org) and the registry treats them as the same canonical term.

Schema.org Thing as a fallback type


A marker for an Object that previously existed but has been deleted.

Subclass of `urn:solid:Object`. After receiving an `as:Delete`, ActivityPub servers replace the deleted object with a Tombstone — preserving the IRI so inbound references don't break, but signalling the resource is gone. Carries `as:formerType` (what it used to be) and `as:deleted` (when).

Deleted note as a Tombstone


A container for tracking work items — typically a list of iCalendar Vtodos. The list-level counterpart to single-task Vtodo.

From the W3C Workflow vocabulary (`wf:`). A Tracker bundles many Vtodos (issues) into a single addressable resource — the right level for list views ("my tasks", "team backlog") whereas Vtodo is the right level for editing a single task. LOSOS's bespoke `todo-pane.js` is registered against Tracker, not Vtodo, for exactly this reason.

A Tracker with two tasks

Initial term — added so a Tracker resource can register a bespoke pane (LOSOS todo-pane) at the right granularity.


An OWL property whose closure is the property itself — if `A p B` and `B p C`, then `A p C`.

urn:solid:Property urn:solid:SymmetricProperty urn:solid:FunctionalProperty urn:solid:subClassOf

Classic examples: `rdfs:subClassOf`, `rdfs:subPropertyOf`, `dcterms:isPartOf`, `skos:broader`. Reasoners materialise the chain — given `Person ⊏ Agent` and `Agent ⊏ Thing`, they infer `Person ⊏ Thing`. Declare a property as `TransitiveProperty` to enable this inference.

Declaring subClassOf as transitive


An ActivityStreams Activity indicating that the actor is travelling between two locations — the origin is the `origin`, the destination is the `target`.

urn:solid:Move urn:solid:Arrive urn:solid:Place urn:solid:target urn:solid:origin

The IntransitiveActivity for ongoing journey — distinct from `as:Move` (which moves an *object*) and `as:Arrive` (which marks completion). Use Travel for in-progress trips; pair with `Arrive` once the destination is reached.

Actor travelling from London to Paris


A registry that maps RDF classes to the locations in a Solid pod where instances of those classes are stored.

The discovery mechanism Solid apps use to find where a user's data of a given type lives. A WebID typically links to one public TypeIndex (`solid:publicTypeIndex`) and one private TypeIndex (`solid:privateTypeIndex`). Each holds a set of `solid:TypeRegistration`s.

WebID pointing at type indexes


An entry in a TypeIndex declaring where instances of a particular RDF class live in a Solid pod.

Each TypeRegistration carries one `solid:forClass` (the RDF class) and either `solid:instance` (a single resource) or `solid:instanceContainer` (a container holding instances). Apps query the TypeIndex for registrations matching the class they need.

TypeRegistration for bookmarks


An indication that the actor is undoing a previous activity — typically used to retract a Like or Follow.

Subclass of `urn:solid:Activity`. The `as:object` is the prior Activity being reversed (a Like to unlike, a Follow to unfollow). Distinct from `Delete`, which retires a target Object rather than reversing an Activity. The original activity remains in the historical record; Undo signals it no longer applies.

Alice unlikes a note


An activity in which the actor has updated the object.

Subclass of `urn:solid:Activity`. The wire-level signal that an actor edited an existing object — receivers should replace their cached copy with the updated payload in `as:object`. Pair with `as:published` for when the edit happened.

Alice updates a note


A qualified PROV usage event — the moment an Activity used an Entity as input.

Inverse-direction sibling of `urn:solid:Generation`: where Generation is "Activity → Entity" (output), Usage is "Entity → Activity" (input). Use to qualify `prov:used` with `urn:solid:atTime` and `urn:solid:hadRole`. Linked from an Activity via `prov:qualifiedUsage`.

Qualified usage of a source file


A vCard — a structured contact card holding name, email, phone, address, and other contact details.

Distinct from `urn:solid:Person`: a VCard is the *contact record* (the data), while a Person is the *human*. One Person can have many VCards (work, personal). Pair with `urn:solid:fn`, `urn:solid:hasEmail`, `urn:solid:hasTelephone`, `urn:solid:hasAddress`.

A VCard


An iCalendar container — the top-level wrapper holding a collection of Vevents, Vtodos, and other calendar components.

An `.ics` file's outermost element. A pod's calendar resource is typically a `Vcalendar` containing many `Vevent` and `Vtodo` members — analogous to a Container in LDP terms. Carries calendar-wide metadata (timezone, product ID).

A calendar with one event


A W3C Verifiable Credential — a tamper-evident, cryptographically-signed claim made by an issuer about a subject.

urn:solid:VerifiablePresentation urn:solid:credentialSubject urn:solid:issuer urn:solid:proof

The standard envelope for portable, signed claims (a driver's licence, a degree, a membership). Carries `issuer`, `credentialSubject`, dates, and a cryptographic `proof`. Self-contained and verifiable offline by anyone with the issuer's public key — does not require contacting the issuer at verification time.

A minimal VerifiableCredential


A W3C Verifiable Presentation — a holder-signed bundle of one or more VerifiableCredentials, prepared for a specific verifier.

Wraps Credentials so the holder can prove they currently possess them, often binding the bundle to a specific challenge (nonce + verifier identity) for replay protection. The holder's `proof` is added on top of the issuer's `proof` on each contained Credential — both must verify.

A presentation containing one credential


An iCalendar event — a scheduled occurrence with a start and end time, defined in RFC 5545 and mapped to RDF by the W3C iCal vocabulary.

urn:solid:Event urn:solid:Vtodo urn:solid:Vcalendar urn:solid:dtstart urn:solid:dtend

RFC 5545 / iCal — the format every calendar app speaks. Distinct from `as:Event` (ActivityStreams, fediverse calendar posts) and `schema:Event` (schema.org, semantic-web event markup). Pick `Vevent` when you need iCalendar interoperability (importing/exporting `.ics`, syncing with CalDAV, native calendar UI integration).

A team meeting


A video resource — used in ActivityPub for video attachments and stand-alone video posts.

ActivityStreams video type — used by PeerTube and similar federated video platforms. Distinct from `urn:solid:VideoObject` (schema.org) which carries richer SEO-friendly metadata. Pick by data flavor.

Note with a video attachment


A video file with structured metadata — duration, resolution, encoding, thumbnail.

Schema.org's video type, sibling to `urn:solid:ImageObject`. Carries `schema:contentUrl`, `schema:duration`, `schema:width`/`schema:height`, `schema:thumbnailUrl`, `schema:embedUrl`. For ActivityPub-style social video posts, prefer `as:Video`.

A short video


An ActivityStreams Activity indicating that the actor viewed the object — typically visual content (an image, a video, a page).

urn:solid:Listen urn:solid:Read urn:solid:Image urn:solid:Video

Records consumption of visual content. Useful for read-status indicators, view-counters, recommendation signals, and analytics. Like `Listen` and `Read`, it's an *event* — repeated views generate distinct Activities, not updates to a counter.

Viewed an image


An iCalendar journal entry — a dated note, log entry, or diary item, used to record what happened (rather than what's scheduled).

Less common than `Vevent` / `Vtodo` but standard iCal. Use for time-stamped notes that don't need scheduling: meeting minutes, daily logs, diary entries. Can be associated with an event via `RELATED-TO` (after the meeting, write the journal entry that links to it).

A daily journal entry


An iCalendar to-do item — a task that can be in progress, completed, or cancelled, with optional due dates.

The iCal task primitive — every native to-do/reminder app on macOS, iOS, Windows, and Linux understands this. Pairs with CalDAV for sync. Already used by LOSOS: the default registry maps `ical:Vtodo` to the todo pane, so urn:solid:Vtodo is the cross-vocab canonical form for that pane.

A simple to-do item


A part of a Solid pod that holds credentials and related items — verifiable credentials, keys, attestations.

Conventional storage location on a pod for credential-class items. SolidOS / mashlib treat any container typed `urn:solid:Wallet` as a wallet pane target. Often appears as a sub-container at `<pod>/wallet/` registered via the public or private TypeIndex.

Pod sub-container declared as a Wallet


A web page — a single page on a website, identified by its URL.

Subclass of `urn:solid:CreativeWork` (and effectively of `urn:solid:Document`). Use when you want web-specific semantics — pair with `schema:isPartOf` pointing at the containing `WebSite`, plus `urn:solid:headline` and `urn:solid:datePublished` for SEO-friendly markup.

A simple web page


A website — a set of related web pages and resources at a common origin.

Subclass of `urn:solid:CreativeWork`. Represents the whole site as a single resource (the value of `dcterms:isPartOf` from individual pages). Pair with `schema:potentialAction` to declare site-wide actions like search.

A website hosting many pages


The WAC Write access mode — permission to modify or delete the contents of a resource.

urn:solid:Read urn:solid:Append urn:solid:Control urn:solid:mode

Implies `urn:solid:Append` — anyone with Write can add. Stronger than Append: includes overwrite and delete. On a Container, Write covers creating, modifying, and deleting members.

Authorization granting Write to the owner


The subject matter of the resource — what it is about.

Schema.org's primary subject-matter predicate, heavily used in JSON-LD on web pages for SEO. Functionally similar to `urn:solid:topic` (FOAF) and `urn:solid:subject` (dcterms); pick by namespace flavor. For the *single* primary subject, prefer `urn:solid:primaryTopic`.

Article about a topic


A summary of the resource — typically one paragraph.

A short summary — typical for academic papers, articles, or specs. Prefer over `urn:solid:description` when there's a distinct "abstract" section in the original. Repeat with language tags for translations.

Article with an abstract

We introduce urn-solid, a curated registry of urn:solid: identifiers mapped to common RDF vocabularies, designed for LLM consumption.


Information about who can access the resource — a free-text or `dcterms:RightsStatement` description of access policy.

Distinct from `urn:solid:rights` (general copyright/IP) and `urn:solid:license` (legal permissions): `accessRights` is specifically about WHO can access (members-only, embargoed, public, restricted to authenticated users). For Solid pod access control specifically, use the WAC vocabulary (`acl:`).

Document with restricted access

Restricted to members of the engineering team.


A DCAT DataService through which a particular Distribution can be accessed — e.g. a SPARQL endpoint that exposes a downloadable dataset.

urn:solid:Distribution urn:solid:DataService urn:solid:downloadURL urn:solid:accessURL

Use when a Distribution is reachable via a service (queryable, paginated, parameterised) rather than a single static file. A Distribution may carry both `dcat:downloadURL` (bulk file) and `dcat:accessService` (live query interface) — they describe two ways to obtain the same data.

Distribution accessible via a SPARQL service


The resource that an Authorization grants access to.

Names the *specific* resource the Authorization applies to. Compare with `acl:default`, which makes the Authorization inherit-by-default to children of a Container. Most Authorizations carry both: `accessTo` for the Container itself and `default` for its descendants.

Authorization scoped to a single resource


A URL where the resources of a DCAT Distribution can be accessed — a landing page, API entry point, or query interface.

Distinct from `urn:solid:downloadURL`: `accessURL` is for indirect access — a landing page that explains how to obtain the data, an API root, an OAI-PMH endpoint. A Distribution must have at least one of `accessURL` or `downloadURL` per DCAT spec.

Distribution with an API access URL


The value is an `OnlineAccount` resource describing the account (the service it lives on, the account name, etc.), not the bare account URL. For a Solid pod-specific notion of account ownership, see `solid:account`.

Person with a GitHub account


The name (username, handle) of an OnlineAccount on the service that hosts it.

The bare username on the hosting service — `"alice"`, not `"@alice"` or a full URL. Pair with `foaf:accountServiceHomepage` so the value is unambiguous across services.

GitHub account


The homepage of the online service that hosts the account.

Pair with `urn:solid:accountName` so the combination uniquely identifies the account: the value here is the service's root URL (e.g. `https://github.com/`), not the account-specific URL (`https://github.com/alice`).

GitHub account


The accuracy of an ActivityStreams Place's coordinates, expressed as a percentage (0–100).

urn:solid:Place urn:solid:latitude urn:solid:longitude urn:solid:radius

0 means the position is essentially a guess; 100 is exact. Useful when the Place comes from GPS, IP geolocation, or any source whose precision varies. Distinct from `as:radius` (the size of the area covered) — accuracy describes the *uncertainty* of the centre point.

A Place with GPS-grade accuracy


An agent acted on behalf of another — delegation between agents.

PROV's delegation relation: agent A acted with the authority of agent B. Use for bots-acting-for-users, services-on-behalf-of-orgs, ghostwriters, automated curators driven by humans. For typed delegation with role and timing, qualify via `prov:qualifiedDelegation`.

Curation bot acting on behalf of a person


An additional or middle name of the person.

vCard's middle-name field — separate from `urn:solid:givenName` and `urn:solid:familyName`. Repeat for multiple middle names. Note the hyphen in the source name is preserved. Schema.org equivalent is `schema:additionalName`.

Person with first, middle, and last names


Schema.org's address predicate. The value is typically a `urn:solid:PostalAddress` resource (or a plain string for simple cases). For vCard-flavored data, use `urn:solid:hasAddress` + `vcard:Address` instead.

Organization with a postal address


Privacy-sensitive — most modern profiles prefer `urn:solid:birthday` (which lets consumers compute current age). Value is an integer year count. For more precise temporal modelling (date of birth, life events), reach for the PROV vocabulary.

Person with an age


A class of agents (e.g. `foaf:Agent` for everyone, `acl:AuthenticatedAgent` for any logged-in user) granted access by an Authorization.

urn:solid:Authorization urn:solid:agent urn:solid:agentGroup urn:solid:mode

Two well-known values: `foaf:Agent` makes the resource public (anyone, even unauthenticated); `acl:AuthenticatedAgent` requires the requester to be logged in but accepts any WebID. Use sparingly — public Read on `foaf:Agent` is a common, intentional pattern; public Write almost never is.

Public-read Authorization via agentClass


A group of agents (a `vcard:Group` resource listing members by WebID) granted access by an Authorization.

urn:solid:Authorization urn:solid:agent urn:solid:agentClass urn:solid:mode

The value points to a Group resource — typically a `vcard:Group` with `vcard:hasMember` triples listing WebIDs. The server dereferences the group to evaluate membership at request time. Lets you manage access by editing the group rather than every .acl file.

Authorization granting access to a friends group


On an OWL Restriction, asserts that every value of the constrained property must be an instance of a given class — a universal quantifier.

Reads as "for all values on this property, the value is in this class." Common pattern: defining a class of `Person`s whose `knows` relations are *only* with other `Person`s. Pairs with `someValuesFrom` (existential — at least one value is in the class).

A class restricting knows-targets to People


An alternate identifier for an ActivityStreams Object — typically a previous identity an Actor used before migrating servers, kept as a back-reference so old followers can find them.

Standard fediverse-account-migration pattern: when an Actor moves servers, the *new* account lists the old one in `as:alsoKnownAs`, and the *old* account points at the new with `as:movedTo`. Together they make migration lossless — followers can verify the new identity is authorised by the old one.

A migrated Actor pointing back at the old identity


An alternative lexical label for a SKOS Concept — a synonym, abbreviation, or other equivalent name.

Use for synonyms, abbreviations, common misspellings users might search for. Repeat for multiple alternates. By SKOS rule, `prefLabel`, `altLabel`, and `hiddenLabel` values for the same Concept must be pairwise disjoint within a language.

Concept with synonyms


Two Entities are alternates when they are different specializations of a common general Entity (same underlying thing, different views).

Symmetric — `A alternateOf B` implies `B alternateOf A`. Typical use: HTML and PDF renderings of the same report; English and French translations; two snapshots of the same dataset taken at different times. Compare with `prov:specializationOf` (one entity narrows another) and `prov:wasRevisionOf` (one supersedes another).

PDF and HTML renderings as alternates


An alternative title or name for the resource.

For subtitles, abbreviations, working titles, translated titles. Repeat with language tags for translations. The primary title goes under `dcterms:title` (when title disambiguation is finalized) or `urn:solid:name`.

Article with an alternative title


The altitude of an ActivityStreams Place above sea level, expressed in metres unless `as:units` says otherwise.

urn:solid:Place urn:solid:latitude urn:solid:longitude urn:solid:units

Default unit is metres; override with `as:units` (`feet`, `inches`, `km`, `miles`) when the source data carries something else. Negative values are valid (Death Valley, the Dead Sea); zero is sea level by definition.

A Place with altitude in metres


An organization the person previously attended or worked for.

Use for past educational and (loosely) professional affiliations. Repeat for multiple. Distinct from `urn:solid:worksFor` which implies *current* employment. Often pointed at a `schema:EducationalOrganization` (university, school) but any past Organization works.

Person with alumni affiliation


An anniversary date associated with the subject — typically a wedding anniversary or other recurring date.

vCard's recurring-date field — distinct from `urn:solid:birthday`/`urn:solid:bday`. ISO 8601 date. Common values are wedding anniversaries, founding dates of organizations, or other yearly remembrances. May repeat for multiple anniversaries.

Person with an anniversary


On an ActivityStreams Question, the inclusive set of answer choices — voters may pick any number.

Multi-select counterpart to `oneOf`. Use exactly one of the two on a Question — never both. Each option is a Note whose `name` is the displayed choice; the per-option `replies.totalItems` gives that option's vote tally.

Multi-select Question


The actual body of the article — its full text content.

Schema.org's narrow article-text predicate, distinct from `urn:solid:headline` (the title) and `urn:solid:abstract` (the summary). For ActivityStreams Notes/Articles, `urn:solid:content` is the equivalent. May contain HTML or plain text — declare with `urn:solid:mediaType` if not HTML.

Article with body text


On a DID Document, verification methods authorised for asserting claims (issuing or signing VerifiableCredentials on behalf of the DID).

urn:solid:DIDDocument urn:solid:authentication urn:solid:verificationMethod urn:solid:VerifiableCredential

Pairs naturally with VC issuance: a credential's `proof.verificationMethod` should resolve to a key listed under the issuer's `assertionMethod`. Separating `assertionMethod` from `authentication` lets one key be valid for issuing credentials but not for logging in — minimises blast radius if a signing key is compromised.

DID Document with an assertion key


The Location at which an Activity, Entity, or Agent occurred or was situated.

PROV's location-stamp predicate. Used inside qualified PROV relations (e.g. `prov:Generation`, `prov:Usage`) or directly on Activities/Agents. The value is typically a `prov:Location` (PROV's general location class) or a `urn:solid:Place`. For schema.org-flavored data, prefer `urn:solid:location`.

Activity tagged with a location


The time at which an InstantaneousEvent occurred — for PROV Generation, Usage, Invalidation, etc.

PROV's instant-event timestamp — used inside qualified PROV relations like `prov:Generation`, `prov:Usage`, `prov:Invalidation`. For activity start/end specifically, prefer `urn:solid:startedAtTime` / `urn:solid:endedAtTime`. ISO 8601.

Qualified generation with a timestamp


An object attached to or associated with the subject — typically images, files, or media.

ActivityStreams' attachment slot — used by ActivityPub posts to carry media (images, video, polls). Repeat for multiple attachments. Each value is typically a typed object like `urn:solid:Image` or `as:Document` with a `url` and `mediaType`.

Note with an image attachment


An iCalendar participant in a Vevent or Vtodo — typically an Actor invited to attend or asked to act.

Repeat per attendee. Each value is typically a `mailto:` URI or an Actor's WebID/DID. RFC 5545 attaches participation status, role, RSVP request, etc. via parameters — in RDF those become additional properties on a reified Attendee blank node rather than URI parameters.

An event with two attendees


An entity to which the object is attributed — typically the author or creator.

ActivityStreams' general-purpose author/origin pointer — works for Notes, Articles, Activities, Images. The value is typically an Actor (Person, Application, Group, Service). For dcterms-style bibliographic authorship use `urn:solid:creator`; for PROV-grade attribution use `prov:wasAttributedTo`.

Note attributed to a Person


The intended audience of the object — who it is targeted at, regardless of who actually receives it.

Used to declare semantic targeting (e.g. "this is for friends", "this is for the engineering team") independently of `as:to`/`as:cc` (which are wire-level addressing). The value can be an Actor, Collection, or symbolic IRI like `as:Public`.

Note targeted at a group


On a DID Document, the verification methods authorised for proving control of the DID — used during login, challenge-response, and other identity-assertion flows.

urn:solid:DIDDocument urn:solid:verificationMethod urn:solid:assertionMethod urn:solid:keyAgreement

One of several *verification relationships* in DID Core (alongside `assertionMethod`, `keyAgreement`, `capabilityInvocation`, `capabilityDelegation`). Distinguishing them lets a DID controller use a hardware key for authentication while delegating signing to a software key — the same Document, different keys for different purposes.

DID Document declaring an authentication key


Schema.org's narrow authorship predicate, meant for the author of a CreativeWork. For general authorship/creation attribution use `urn:solid:creator` (dcterms); for ActivityStreams social content use `urn:solid:attributedTo`. Repeat for co-authors.

Article with an author


The date or period when the resource became (or will become) available.

Distinct from `urn:solid:issued` (formal publication): `available` is when the resource starts to be obtainable, which can differ from publication for embargoed papers, scheduled releases, or pre-orders. Can be a single date or an ISO 8601 interval.

Embargoed paper with availability date


A geographic location near where the subject is based.

Intentionally fuzzy — "near", not "at" — so people can share a city or region without revealing a precise address. Value is typically a geo:SpatialThing or `schema:Place`. For a precise postal address, prefer `vcard:hasAddress` or `schema:address`.

Person based near a city


Blind carbon-copy recipients of the object — recipients hidden from other receivers.

Email-style bcc: recipients receive the activity but their addresses MUST be stripped from the object before it's seen by other receivers. Use sparingly — `bcc` semantics are easily mishandled by misbehaving servers, leaking what was meant to be private.

Note privately delivered alongside public one


The full date of birth of the subject (year-month-day).

vCard's full birth date — `xsd:date` with year ("1990-03-14"), distinct from FOAF's `urn:solid:birthday` which is just `mm-dd` (no year). Use `bday` when you need the actual year for age calculation; use `birthday` for anniversary semantics without revealing age.

vCard with a full birth date


A bibliographic reference for the resource — a formatted citation string.

A formatted citation string as you'd see in a reference list ("Author, A. (2026). Title. Journal, vol(issue), pages."). For machine-actionable citations with structured metadata, prefer linking to a `dcterms:BibliographicResource` via `urn:solid:references` instead.

Article with a citation


The birthday of the agent — month and day, formatted as mm-dd.

FOAF format is bare `mm-dd` (no year), preserving the recurring-anniversary semantics. For a full date of birth (with year), prefer `vcard:bday` or `schema:birthDate` which take an `xsd:date`.

Person with a birthday


A SKOS mapping asserting that a Concept in another scheme is broader than this Concept.

Cross-scheme version of `urn:solid:broader`. Use across SKOS schemes when you want to say "the closest broader concept in *that* vocabulary is this one". Inverse of `urn:solid:narrowMatch`.

Cross-scheme broader mapping


A broader (parent) SKOS Concept in a hierarchy — "category-theory broader algebra".

The hierarchical-up relation in a SKOS taxonomy. Inverse of `urn:solid:narrower`. Note: SKOS treats `broader` as transitive only when used inside a single ConceptScheme — for transitive ancestor links, use `skos:broaderTransitive`. For non-hierarchical relatedness, use `urn:solid:related`.

Concept hierarchy


Private primary recipients of the object — "to" addresses hidden from other receivers.

Like `as:to` for delivery, but stripped from the object before any non-`bto` receiver sees it — use for private direct recipients you don't want exposed in the object's metadata. Same caveats as `bcc`: easily leaked by misbehaving intermediaries.

Note privately addressed


The size in bytes of a DCAT Distribution.

Use to declare the file size of a Distribution so consumers can plan downloads. Integer bytes (no "MB"/"GB" suffix — use the raw number). Schema.org's `schema:contentSize` accepts free-form strings; `dcat:byteSize` is stricter.

Distribution with byte size


On an OWL Restriction, asserts that the constrained property must have *exactly* this many values.

urn:solid:Restriction urn:solid:minCardinality urn:solid:maxCardinality urn:solid:onProperty

Equivalent to `minCardinality` and `maxCardinality` both set to the same value. Use when the count is fixed (every Triangle has exactly 3 sides). For ranges, prefer the min/max forms — they're more flexible and the same expressivity.

Class requiring exactly one issuer


iCalendar tags or categories for a Vevent/Vtodo — comma-separated keywords classifying the calendar item ("work", "personal", "travel").

urn:solid:Vevent urn:solid:Vtodo urn:solid:tag urn:solid:keyword

Free-form strings, no controlled vocabulary by default. Distinct from `as:tag` (ActivityStreams tag links) and `dcat:keyword` (dataset keyword). Use `categories` when you need iCal-format calendar interop; the other two are better for fediverse posts and dataset metadata respectively.

An event tagged with categories


Secondary public recipients of the object — visible carbon-copy addresses.

Email-style cc: secondary visible recipients. ActivityPub clients typically use `cc` to add a follower collection alongside a primary `to` of `as:Public`, so a post is publicly visible AND fans out to followers' home timelines. Use `as:bcc` to reach recipients privately (not visible in the rendered object).

Public note delivered to followers


A SKOS note recording a change made to a Concept — typical use is the curator's log of edits to the term over time.

urn:solid:Concept urn:solid:editorialNote urn:solid:historyNote urn:solid:scopeNote

Audit trail in human-readable form: "renamed from X on 2024-06-12", "narrowed scope to exclude Y". Distinct from `historyNote` (broader narrative history of the Concept) and `editorialNote` (working notes for curators). Often appended rather than overwritten.

Concept with a change note

2024-06-12: split applied mathematics into separate concept


Inverse of `urn:solid:parent`. Despite the plural label "children", schema.org defines this as one-child-per-statement — repeat for multiple children. Sensitive personal data; consider access control before publishing.

Person with two children


A SKOS mapping asserting that two Concepts in different ConceptSchemes are similar enough to be used interchangeably in some applications.

Symmetric but NOT transitive (unlike `exactMatch`) — that's the whole point: chains of close matches don't preserve enough meaning. Use when concepts overlap meaningfully but you wouldn't claim full equivalence.

Similar but distinct concepts


Indicates that an ActivityStreams Question is closed — no further responses are accepted. The value may be a date-time, a boolean, or an Object describing how it was closed.

urn:solid:Question urn:solid:oneOf urn:solid:anyOf urn:solid:endTime

Most often a `xsd:dateTime` carrying the close timestamp — clients render "poll ended at …" and stop accepting votes. The boolean form simply marks the Question closed without a time. Some servers also accept an Object value pointing at the activity that closed the poll.

A Question with an explicit close time


A comment on the subject — typically a Comment instance written by some agent in response to the subject.

Property form paired with the `urn:solid:Comment` class. Maps to `schema:comment` (a comment in response to the subject), distinct from `rdfs:comment` (a human-readable description of a vocabulary term). Use `comment` for user-generated reply content; use `rdfs:comment` (or `urn:solid:description`) for descriptive prose about a resource.

Article with two comments

Initial term — property form completing the Comment/comment case-pair.


OWL class expression: defines a class as the negation of another — instances of the new class are everything that is *not* an instance of the named class.

urn:solid:Class urn:solid:intersectionOf urn:solid:unionOf urn:solid:disjointWith

Logical NOT. Use sparingly — `complementOf X` is the entire universe minus X, which is rarely what you actually want. Often `disjointWith` (X has no instances in common with Y) expresses the intent more usefully than complement.

An anonymous class: not a Person


An established standard or specification to which the resource conforms.

Use to declare specification compliance — e.g. a JSON-LD document conforming to a profile, an HTML page conforming to a WCAG level, a dataset conforming to a schema. Value should be the IRI of the standard, not free text. For shape conformance specifically, see SHACL/ShEx vocabularies.

Term file conforming to the urn-solid schema


A resource contained by the LDP Container — i.e., a member created via HTTP POST to the container.

LDP-specific containment with HTTP semantics: POSTing to the container creates a resource that's automatically a `ldp:contains` member. Unlike `urn:solid:hasPart` (a logical part-of), `contains` reflects actual server-side parent-child storage.

Container listing its members


The textual body of the object — its content in a natural-language string (often HTML).

ActivityStreams' body field. Value is a natural-language string — by convention HTML in ActivityPub, though plain text is allowed. Accompany with `as:mediaType` if not HTML. Repeat with language tags for translations.

Note with HTML content


Language-tagged variants of an ActivityStreams Object's `content` — keys are BCP 47 language tags, values are the localised content (often HTML).

The fediverse's standard mechanism for multi-language posts. Mastodon, Misskey, and most ActivityPub servers populate this when an author tags a post's language. Clients select on locale; server-side translation features (Mastodon "translate") add machine-translated entries here.

A bilingual Note

Je viens de livrer une nouvelle fonctionnalité.


The context within which the object exists or to which it relates — typically a conversation thread.

ActivityPub uses `as:context` to group all messages in one conversation under a shared identifier — every reply in a thread carries the same `context` IRI, regardless of `inReplyTo` chains. Distinct from JSON-LD's `@context` (a syntactic keyword). The value is typically the IRI of the root post or a synthetic conversation resource.

Reply tagged with conversation context


An entity responsible for making contributions to the resource — secondary to the principal creator.

Use for editors, reviewers, translators, co-authors of secondary weight. Repeat for multiple contributors. The principal author goes under `urn:solid:creator` instead. For a richer role-aware contribution model, prefer `prov:wasAttributedTo` paired with a `prov:Role`.

Document with creator and contributor


The Actor authorised to make changes to a DID Document or verification method — the entity holding the private key behind the public material.

Often the DID itself controls its own Document (self-sovereign). Multi-party setups (custodial wallets, organisational DIDs) point `controller` at a different entity. Verifiers consult `controller` to know who's authoritative for the document, e.g. when validating updates or rotation events.

Self-controlled DID


The country name of an Address — typically as a string.

vCard's country line on an Address — typically a country name string ("United Kingdom") or an ISO 3166-1 country code ("GB"). Schema.org equivalent is `schema:addressCountry`. For a full structured country resource, use `urn:solid:Country`.

Address with country


Use ISO 8601 (`xsd:dateTime` or `xsd:date`) values. Set once at creation and never updated — for last-edit times use `urn:solid:modified`. For provenance-grade timestamps with full PROV semantics, prefer `prov:generatedAtTime`.

A document with a creation date


An entity primarily responsible for making the resource.

Use for the principal author or maker. Repeat to list multiple co-creators of equal weight; use `dcterms:contributor` for secondary contributors and `dcterms:publisher` for the entity that issued/distributed the resource.

Article with a creator


A reference to a status mechanism for a VerifiableCredential — e.g. a revocation list — that verifiers consult to check whether the credential is still active.

Distinct from expiration (a static date in the credential). Status is dynamic — the credential is signed once but can be revoked any time after. Common types: `RevocationList2020Status`, `StatusList2021Entry`. Verifiers fetch the referenced status document and check the credential's bit/index.

Credential with a revocation entry