Browsing & Installing

Find and install the perfect agent for your needs.

Searching the Store

Via Dashboard

1. Go to Store in the main navigation
2. Use the search bar for keywords
3. Filter by category, pricing, and ratings
4. Sort results by popularity, rating, or recency

Via API

const results = await client.store.browse({
  // Search term
  search: 'customer support',

  // Filters
  category: 'support',          // assistant, support, coding, writing, analysis, automation, integration
  pricing: 'free',              // free, paid, all
  tags: ['chatbot', 'helpdesk'],

  // Sort
  sortBy: 'popular',            // popular, rating, recent, name

  // Pagination
  limit: 20,
  offset: 0
});

for (const listing of results.data) {
  console.log({
    name: listing.name,
    description: listing.shortDescription,
    category: listing.category,
    rating: listing.rating,
    reviews: listing.reviewCount,
    installs: listing.installCount,
    price: listing.productPricing
  });
}

Understanding Listings

Listing Structure

interface StoreListing {
  // Identity
  id: string;
  name: string;
  slug: string;                    // URL-friendly name
  shortDescription: string;        // Max 200 chars
  description: string;             // Full description (markdown)
  tagline?: string;                // Max 120 chars

  // Classification
  category: ListingCategory;
  tags: string[];                  // Max 10 tags
  icon?: string;

  // Agent Configuration
  config: {
    name: string;
    model: string;                 // claude-sonnet-4-20250514, etc
    tools: string[];
    settings?: Record<string, unknown>;
  };

  // Pricing
  pricingModel: 'free' | 'one_time' | 'subscription' | 'freemium';
  productPricing: ProductPricing;
  license: LicenseType;

  // Social Proof
  installCount: number;
  activeInstalls: number;
  rating: number;                  // 0-5
  reviewCount: number;

  // Content
  version: string;
  changelog?: string;
  screenshots: string[];
  documentation?: string;          // Markdown
  supportUrl?: string;
  demoUrl?: string;

  // Vendor
  vendor: {
    id: string;
    displayName: string;
    slug: string;
    tier: 'starter' | 'verified' | 'partner' | 'enterprise';
    badges: VendorBadge[];
    rating: number;
  };

  // Dates
  createdAt: string;
  updatedAt: string;
  featuredAt?: string;
}

Pricing Models

Free

{
  pricingModel: 'free',
  productPricing: {
    model: 'free',
    currency: 'EUR'
  }
}

One-Time Purchase

{
  pricingModel: 'one_time',
  productPricing: {
    model: 'one_time',
    price: 4999,                   // €49.99 in cents
    currency: 'EUR'
  }
}

Subscription

{
  pricingModel: 'subscription',
  productPricing: {
    model: 'subscription',
    monthlyPrice: 999,             // €9.99/month
    yearlyPrice: 9900,             // €99/year (2 months free)
    currency: 'EUR'
  }
}

Freemium

{
  pricingModel: 'freemium',
  productPricing: {
    model: 'freemium',
    currency: 'EUR',
    freeTier: {
      name: 'Basic',
      features: ['5 conversations/day', 'Email support'],
      limitations: ['No file uploads', 'No integrations']
    },
    paidTiers: [
      {
        id: 'pro',
        name: 'Pro',
        price: 1999,               // €19.99
        billingPeriod: 'monthly',
        features: ['Unlimited conversations', 'File uploads', 'Priority support']
      }
    ]
  }
}

Viewing Details

Get full details for a listing:

const listing = await client.store.get('listing-123');

console.log({
  // Basic info
  name: listing.name,
  description: listing.description,

  // What you get
  tools: listing.config.tools,
  model: listing.config.model,

  // Trust signals
  vendor: listing.vendor.displayName,
  vendorTier: listing.vendor.tier,
  vendorBadges: listing.vendor.badges,

  // Social proof
  rating: listing.rating,
  reviews: listing.reviewCount,
  installs: listing.installCount,

  // Documentation
  docs: listing.documentation,
  screenshots: listing.screenshots
});

Reading Reviews

const reviews = await client.store.getReviews('listing-123', {
  limit: 10,
  offset: 0
});

for (const review of reviews.data) {
  console.log({
    rating: review.rating,
    title: review.title,
    content: review.content,
    author: review.userName,
    verified: review.isVerifiedPurchase,
    helpful: review.helpfulCount,
    date: review.createdAt,

    // Vendor response if any
    vendorResponse: review.vendorResponse?.content
  });
}

Installing a Listing

Free Listings

// One-click install
const install = await client.store.install('listing-123');

console.log({
  installId: install.id,
  agentId: install.agentId,        // New agent created in your workspace
  version: install.installedVersion
});

// The agent is now ready to use
const conversation = await client.conversations.create({
  agentId: install.agentId
});

Paid Listings

// Initiate purchase
const purchase = await client.store.purchase('listing-123', {
  pricingOption: 'monthly',        // For subscriptions
  tierId: 'pro'                    // For freemium tiers
});

// Returns Stripe checkout URL
window.location.href = purchase.checkoutUrl;

// After successful payment, install is automatic

Managing Installations

// List your installations
const installs = await client.store.getInstalls();

for (const install of installs.data) {
  console.log({
    id: install.id,
    listingName: install.listing.name,
    agentId: install.agentId,
    version: install.installedVersion,
    status: install.status,        // active, uninstalled
    installedAt: install.installedAt
  });
}

// Uninstall
await client.store.uninstall('install-123');

Purchases & Licenses

View Purchases

const purchases = await client.store.getPurchases({
  status: 'completed',             // pending, completed, refunded, disputed
  limit: 50
});

for (const purchase of purchases.data) {
  console.log({
    id: purchase.id,
    listing: purchase.listingName,
    amount: purchase.amount,
    currency: purchase.currency,
    type: purchase.purchaseType,   // one_time, subscription
    status: purchase.status,
    date: purchase.createdAt
  });
}

View Licenses

const licenses = await client.store.getLicenses();

for (const license of licenses.data) {
  console.log({
    id: license.id,
    listing: license.listingName,
    type: license.type,            // perpetual, subscription, trial
    validUntil: license.validUntil,
    deployedAgent: license.deployedAgentId,
    status: license.status         // active, expired, revoked
  });
}

Request Refund

// Within refund window (14-30 days)
await client.store.requestRefund('purchase-123', {
  reason: 'Agent did not meet my requirements'
});

Writing Reviews

Only verified purchasers can leave reviews:

await client.store.createReview('listing-123', {
  rating: 5,                       // 1-5
  title: 'Excellent customer support agent',
  content: 'This agent handles 80% of our support tickets automatically. Setup was easy and the documentation is comprehensive.'
});

Rating Guidelines

Rating	Meaning
5	Excellent - Exceeds expectations
4	Good - Meets expectations with minor issues
3	Average - Works but has notable limitations
2	Poor - Significant issues
1	Bad - Does not work as described

Contacting Vendors

Start a support thread with the vendor:

// Create support thread
const thread = await client.store.createThread({
  listingId: 'listing-123',
  subject: 'Question about integration',
  message: 'How do I connect this agent to my Slack workspace?',
  type: 'support'                  // general, support, feedback, bug_report, feature_request
});

// Check for responses
const messages = await client.store.getThreadMessages(thread.id);

// Reply to thread
await client.store.sendMessage(thread.id, {
  content: 'Thanks for the quick response!'
});

Thread Types

Type	Use Case
general	General questions
support	Technical support
feedback	Share feedback
bug_report	Report issues
feature_request	Request features
refund_request	Request refund

Featured Listings

Discover curated picks:

const featured = await client.store.getFeatured();

// Returns top 6 featured listings
// These are hand-picked by the Deeployd team

Best Practices

Before Installing

1. Read the description carefully
2. Check reviews from other users
3. Verify vendor badges for trust
4. Review tools included for security
5. Test free tier first if available

After Installing

1. Configure settings for your use case
2. Set up integrations if needed
3. Test with sample conversations
4. Leave a review to help others

Security Considerations

• Review the tools the agent uses
• Check vendor verification status
• Read the privacy policy
• Understand data handling

---

Next: Learn about the Vendor Program to sell your own agents.