Maui Scuba Diving Tours: Build Honest JSON-LD Structured Data

A travel website can look impressive and still provide confusing information.

Imagine visiting a page about scuba diving.

You see a detailed activity description, photographs, a duration, and a price.

Everything looks ready to book.

But the experience is no longer operating.

Now imagine that the website also contains structured data telling search engines that the service is available.

That's two layers of misinformation: one visible to visitors and another intended for machines.

For developers working on travel and activity websites, this is an important problem to solve.

Let's build a small JavaScript tool that generates more responsible JSON-LD structured data.

We'll use Maui scuba diving tours as our example, with a particular focus on why outdated tour information should never become a fictional booking offer.

This tutorial covers:

  • Choosing an appropriate Schema.org type
  • Building JSON-LD with JavaScript
  • Separating service information from availability
  • Avoiding invented prices and schedules
  • Checking data before publication
  • Testing structured data against visible page content

We'll use Node.js and plain JavaScript.

No external packages are required.

1. Why Structured Data Matters

Structured data describes information on a webpage in a format that software can interpret.

One common format is JSON-LD.

It uses JSON with properties that describe entities, relationships, and other information.

For example, a webpage might describe a business, an activity, or a service.

Without structured data, search engines primarily interpret the visible page and other signals.

JSON-LD can help express specific facts more clearly.

But adding structured data does not guarantee rich results, higher rankings, or additional search visibility.

And structured data should never contradict what visitors can read on the page.

That last point is especially important for travel services.

2. Choose the Right Schema Type

Schema.org provides several types that may be relevant to tourism websites.

For example:

  • Organization describes an organization.
  • LocalBusiness describes a local business.
  • Service describes a service.
  • TouristTrip describes a tourist trip or itinerary.

A guided experience and a complete travel itinerary are not always the same kind of entity.

For this tutorial, we'll use Service.

That gives us a relatively simple way to describe a hypothetical guided scuba activity.

If a real page describes an actual itinerary, TouristTrip might be worth evaluating.

The choice should follow the content.

Don't select a schema type just because it sounds more impressive.

3. Start With a Fictional Example

Create a file named build-schema.js.

First, define the activity data.

const tour = { name: "Example Coastal Scuba Tour", description: "A fictional guided recreational scuba experience.", provider: "Example Ocean Activities", status: "unavailable", verifiedAt: null, price: null, currency: null }; 

This example is fictional.

It does not describe a current Dive Maui service.

We deliberately avoid assigning a specific price, departure time, or dive location.

Those details would require real evidence.

Notice the status field.

Our data model distinguishes the description of a service from the question of whether that service can be booked.

That's where the next part becomes useful.

4. Define a Clear Availability Model

For this project, we'll use three statuses.

const STATUS = Object.freeze({ AVAILABLE: "available", UNAVAILABLE: "unavailable", UNVERIFIED: "unverified" }); 

These status values belong to our own application.

They are not automatically Schema.org properties.

They describe what our publishing system knows about an activity.

For example:

available means the operator has confirmed that the activity is currently offered.

unavailable means current information indicates that it is not offered.

unverified means nobody has established the present status.

The final status is particularly important.

An unverified service should not silently become an available one.

That would turn missing information into a booking claim.

5. Build a Basic JSON-LD Object

Now let's generate structured data.

Add this function:

function buildServiceSchema(tour) { return { "@context": "https://schema.org", "@type": "Service", "name": tour.name, "description": tour.description, "provider": { "@type": "Organization", "name": tour.provider } }; } 

This creates a basic service description.

It doesn't invent an active booking offer.

It also doesn't require a fabricated price.

That is useful when a website contains a legitimate historical service description but no current booking option.

The output looks like this:

{ "@context": "https://schema.org", "@type": "Service", "name": "Example Coastal Scuba Tour", "description": "A fictional guided recreational scuba experience.", "provider": { "@type": "Organization", "name": "Example Ocean Activities" } } 

The markup identifies an example service.

It does not claim that someone can reserve it.

6. Why You Should Be Careful With Offer Data

Schema.org also provides an Offer type.

An offer can describe a commercial arrangement for a product or service.

Depending on its use, it may include price and availability information.

A common mistake is adding an offer simply because an older activity page contains a price.

For example, this is a bad approach:

// Don't use this approach. const offer = { "@type": "Offer", price: 149, priceCurrency: "USD", availability: "https://schema.org/InStock" }; 

Why is it bad?

Because nothing in our example establishes that the activity costs $149 or can currently be purchased.

We would be inventing both the price and the availability.

Also, InStock is not a sensible default to apply to an unknown tour simply because it appears in examples of product markup.

Structured data should represent verified information, not assumptions.

7. Add Offers Only When the Information Is Verified

Let's make the builder more careful.

First, we need a validation function.

function hasVerifiedOffer(tour) { if (tour.status !== STATUS.AVAILABLE) { return false; } if (!tour.verifiedAt) { return false; } if ( typeof tour.price !== "number" || !Number.isFinite(tour.price) || tour.price < 0 ) { return false; } if (!/^[A-Z]{3}$/.test(tour.currency ?? "")) { return false; } return true; } 

This checks whether our system has the basic information needed before adding a priced offer.

It does not independently prove the information is correct.

The verifiedAt field must be populated only after a real verification takes place.

And a production system would also need to check whether verification is still recent enough under its own review policy.

Now update the schema builder:

function buildServiceSchema(tour) { const schema = { "@context": "https://schema.org", "@type": "Service", "name": tour.name, "description": tour.description, "provider": { "@type": "Organization", "name": tour.provider } }; if (hasVerifiedOffer(tour)) { schema.offers = { "@type": "Offer", price: tour.price, priceCurrency: tour.currency }; } return schema; } 

Notice that the function doesn't create an offer for unavailable or unverified records.

Even for a verified record, we only include a price and currency when that information has been supplied.

Additional offer properties should be added only when they accurately describe the real service.

8. What About an Unavailable Activity?

Suppose a provider has a historical tour page.

The business has confirmed that the activity is not currently operating.

What should your application do?

First, show the status clearly in the visible content.

For example:

<article> <h1>Example Coastal Scuba Tour</h1> <p> This is a historical activity description. </p> <p> <strong>Currently unavailable.</strong> </p> <p> No reservations are being accepted for this example activity. </p> </article> 

The page explains what the activity was without suggesting that it is bookable.

Our schema builder can still describe the service, but it won't publish a current priced offer.

That's a conservative approach for a historical information page.

It also avoids showing a reservation button when no reservation is possible.

9. Keep Verification Data Separate

The next improvement is to track where your information came from.

A useful internal record might look like this:

const record = { name: "Example Coastal Scuba Tour", status: "unavailable", verifiedAt: "2026-11-10", verifiedBy: "content-editor", sourceType: "official-business-notice", reviewRequired: false }; 

This is illustrative metadata, not a real verification record.

Don't publish a made-up verification date.

In a real content management system, the date should reflect when someone checked the source.

You may also want fields for:

  • The source document
  • The person who reviewed the listing
  • The last update made to the page
  • The next planned review
  • Notes about differences between old and new information

These fields help the editorial team maintain the content.

They do not all need to appear in public JSON-LD.

10. Add an Internal Content Review Check

We can create a small validation function to identify inconsistent data.

function validateTourRecord(tour) { const warnings = []; if (!tour.name?.trim()) { warnings.push("Missing service name."); } if (!tour.description?.trim()) { warnings.push("Missing service description."); } if (!Object.values(STATUS).includes(tour.status)) { warnings.push("Invalid availability status."); } if ( tour.status !== STATUS.AVAILABLE && tour.bookingEnabled === true ) { warnings.push( "Booking must be disabled for this status." ); } if ( tour.status === STATUS.AVAILABLE && !tour.verifiedAt ) { warnings.push( "Availability has not been verified." ); } return warnings; } 

This function doesn't decide whether a scuba activity is safe or suitable.

It simply looks for inconsistencies in the publishing data.

That's an important distinction.

Software can flag missing information.

It cannot replace the judgment of a dive professional or confirm real-world operational conditions without reliable evidence.

11. Generate the JSON-LD File

Now we can produce the markup.

Add the following code to build-schema.js after the data and functions:

const fs = require("node:fs"); const warnings = validateTourRecord(tour); if (warnings.length > 0) { console.error("Validation warnings:"); warnings.forEach((warning) => { console.error(`- ${warning}`); }); } const schema = buildServiceSchema(tour); fs.writeFileSync( "tour-schema.json", JSON.stringify(schema, null, 2), "utf8" ); console.log("JSON-LD file generated."); 

Run it with:

node build-schema.js 

You'll get:

tour-schema.json 

The generated file contains JSON-LD that can be reviewed before being included on the appropriate webpage.

For an actual implementation, you would normally add that data inside a script element:

<script type="application/ld+json"> { "@context": "https://schema.org", "@type": "Service", "name": "Example Coastal Scuba Tour", "description": "A fictional guided recreational scuba experience.", "provider": { "@type": "Organization", "name": "Example Ocean Activities" } } </script> 

Do not publish this fictional example as a real service.

Replace it with accurate information that matches the actual webpage.

12. Test the Validation Rules

Let's add a few basic tests.

Create test-records.js.

In a larger project, you'd export your functions into separate modules. For this compact example, the following tests assume hasVerifiedOffer() and validateTourRecord() are available in scope.

const assert = require("node:assert/strict"); const unavailable = { name: "Unavailable Example", description: "Historical activity", status: "unavailable", bookingEnabled: false, verifiedAt: null, price: null, currency: null }; assert.equal( hasVerifiedOffer(unavailable), false ); assert.deepEqual( validateTourRecord(unavailable), [] ); const misleading = { ...unavailable, bookingEnabled: true }; assert.ok( validateTourRecord(misleading).some( (warning) => warning.includes("Booking") ) ); console.log("Validation checks passed."); 

The key test is simple.

An unavailable record must not become a verified priced offer.

The second test checks that our application notices a conflicting booking flag.

A production test suite should also cover missing provider details, stale verification dates, malformed currencies, and unexpected status values.

13. A Real-World Lesson From Lahaina

This problem isn't theoretical.

Dive Maui / Hawaiian Rafting Adventures is a family-run scuba diving and ocean activity business with a published address at 1223 Front Street in Lahaina, Hawaii.

Its website contains information about diving education, equipment, and historically advertised ocean experiences.

Some previously offered activities are marked unavailable following operational challenges associated with the 2023 Lahaina wildfires.

For example, its two-tank diving trip page includes an availability notice explaining that the trip is currently unavailable.

Yet the page also retains historical trip details.

This is exactly the type of situation developers should handle carefully.

A simple scraper might extract the activity name, schedule, and price while overlooking the notice.

If that data automatically becomes a structured booking offer, a website may publish misleading information.

Anyone studying Maui scuba diving tours and Dive Maui's published activity information can review the official business website as an example of why current status notices matter.

This does not mean every historical page must be deleted.

It means the content and structured data should accurately represent the status of the activity.

14. Does JSON-LD Guarantee Better Rankings?

No.

Schema.org markup can help machines interpret a page's content.

However, valid structured data does not guarantee a special search result.

Google supports specific structured-data features with their own documentation and eligibility requirements.

A schema type may be valid under Schema.org without qualifying for a dedicated Google rich result.

That distinction matters.

The goal should not be to add as many schema properties as possible.

The goal is to describe the page accurately.

For a tourism business, accurate information about services, eligibility, locations, and availability is more useful than inflated markup.

If a service is unavailable, structured data should not pretend otherwise.

If a price hasn't been confirmed, don't invent one.

And if a trip has no verified itinerary, don't fabricate stops simply to populate an itinerary field.

15. A Practical Publishing Checklist

Before deploying structured data on a scuba tourism website, review the following:

Visible content

  • Does the page clearly identify the activity?
  • Does it explain whether the activity is operating?
  • Are historical details labeled where appropriate?
  • Is any booking action supported by actual availability?

Structured data

  • Is the Schema.org type suitable for the page?
  • Does the data match the visible content?
  • Are provider details accurate?
  • Are prices supported by current evidence?
  • Have outdated offers been removed?

Verification

  • When was the information last checked?
  • Was the source authoritative?
  • Is someone responsible for reviewing changes?
  • Are unavailable and unverified records handled separately?

Testing

  • Is the JSON syntactically valid?
  • Do Schema.org validators recognize the properties?
  • Does Google support any relevant rich-result feature for this markup?
  • Does the live page contain the same information as the structured data?

An important final point: the Google Rich Results Test and the Schema.org Validator have different purposes.

The Schema.org Validator can help inspect general vocabulary usage.

Google's Rich Results Test focuses on structured data relevant to Google's supported rich-result features.

A page can use valid Schema.org markup without qualifying for a Google rich result.

Final Thoughts

Developers building tourism websites often spend time improving performance, responsive design, accessibility, and user experience.

Structured data deserves the same care.

It should not be treated as an invisible place where outdated or unverified information can remain indefinitely.

For a scuba diving business, circumstances can change.

Tours may be postponed.

Equipment arrangements may change.

Training programs may become unavailable.

And a historical service page may remain online to provide useful background information.

A good publishing system needs to represent those differences accurately.

Our JavaScript example demonstrates a simple principle:

Describe the service.

Verify the offer.

Keep the booking state separate.

And never turn missing information into a promise.

Good structured data doesn't make a travel experience look better than it is. It helps describe what is actually known.