Network

The Network module enables cross-business search for marketplace and aggregator platforms.

Search Services

Search for services across multiple businesses in a network.

const result = await sdk.network.searchServices({
networkKey: 'beauty-marketplace',
query: 'haircut',
location: {
  lat: 40.7128,
  lng: -74.0060,
  radius: 10 // miles
},
priceMin: 2000,
priceMax: 10000,
cursor: null,
limit: 20
});

if (result.ok) {
result.val.items.forEach(service => {
  console.log(service.name, service.business.name, service.price);
});
}

Search Products

Search for products across multiple businesses.

const result = await sdk.network.searchProducts({
  networkKey: 'artisan-marketplace',
  query: 'handmade jewelry',
  category: 'accessories',
  priceMin: 1000,
  priceMax: 15000,
  sortBy: 'price',
  sortOrder: 'asc',
  cursor: null,
  limit: 24
});

if (result.ok) {
  result.val.items.forEach(product => {
    console.log(product.name, product.business.name, product.price);
  });
}

Search Providers

Search for service providers across businesses.

const result = await sdk.network.searchProviders({
  networkKey: 'fitness-network',
  query: 'personal trainer',
  location: {
    lat: 34.0522,
    lng: -118.2437,
    radius: 15
  },
  serviceId: 'svc_personal_training',
  cursor: null,
  limit: 20
});

if (result.ok) {
  result.val.items.forEach(provider => {
    console.log(provider.name, provider.business.name, provider.distance);
  });
}

Response Format

Network search results include business information:

interface NetworkServiceResult {
  id: string;
  name: string;
  description: string;
  price: number;
  duration: number;
  business: {
    id: string;
    name: string;
    slug: string;
    logo: string;
    rating: number;
    address: Address;
  };
  distance?: number; // If location filter used
}

interface NetworkProductResult {
  id: string;
  name: string;
  description: string;
  price: number;
  images: string[];
  inventory: number;
  business: {
    id: string;
    name: string;
    slug: string;
    logo: string;
    rating: number;
  };
}

interface NetworkProviderResult {
  id: string;
  name: string;
  bio: string;
  image: string;
  services: string[];
  business: {
    id: string;
    name: string;
    address: Address;
  };
  distance?: number;
}

Use Cases

Marketplace Platform

// Build a service marketplace
async function searchMarketplace(filters: SearchFilters) {
  const services = await sdk.network.searchServices({
    networkKey: 'wellness-marketplace',
    query: filters.query,
    location: filters.location,
    category: filters.category,
    priceMin: filters.priceRange[0],
    priceMax: filters.priceRange[1],
    limit: 20
  });

  return services.ok ? services.val.items : [];
}

// Display results with business info
function ServiceCard({ service }) {
  return (
    <div className="service-card">
      <h3>{service.name}</h3>
      <p className="business">{service.business.name}</p>
      <p className="price">${(service.price / 100).toFixed(2)}</p>
      <p className="distance">{service.distance?.toFixed(1)} miles away</p>
      <a href={`/book/${service.business.slug}/${service.id}`}>
        Book Now
      </a>
    </div>
  );
}

Aggregator Site

// Aggregate products from multiple vendors
async function loadProducts(category: string) {
  const result = await sdk.network.searchProducts({
    networkKey: 'artisan-collective',
    category,
    inStock: true,
    sortBy: 'newest',
    limit: 48
  });

  if (result.ok) {
    return result.val.items.map(product => ({
      ...product,
      vendorUrl: `/vendor/${product.business.slug}`,
      productUrl: `/product/${product.business.slug}/${product.id}`
    }));
  }

  return [];
}

Franchise Locator

// Find nearby franchise locations
async function findNearbyLocations(lat: number, lng: number) {
  const result = await sdk.network.searchProviders({
    networkKey: 'franchise-network',
    location: { lat, lng, radius: 25 },
    sortBy: 'distance',
    limit: 10
  });

  return result.ok ? result.val.items : [];
}