Partner API Capabilities & Integration Guide¶

Document Version: 1.0 Last Updated: 2025-11-27 Purpose: Partner evaluation guide for API integration opportunities Audience: AWS ISV Partners, System Integrators, Technology Partners

Executive Summary¶

Vellocity provides a comprehensive GTM (Go-To-Market) automation platform for AWS Marketplace partners. This document outlines:

Which capabilities are exposed via API (available for partner integration)
Which capabilities are internal-only (platform-managed)
Partner integration use cases with build vs. buy analysis
Technical architecture for API access

Quick Decision Framework¶

If You Need...	Build Yourself	Use Vellocity API
One-off content generation	Consider	Recommended
Ongoing GTM automation	Not recommended	Highly recommended
Co-sell partner matching	Very difficult	Only option
AWS Marketplace compliance	Complex	Included
Multi-channel campaigns	3-6 months	Days

API Capability Matrix¶

Legend¶

Status	Meaning
✅ Exposed	Available via Partner API
🔒 Internal	Platform-managed, not directly accessible
🔜 Roadmap	Planned for API exposure
⚡ Real-time	WebSocket/streaming available

1. Content Generation APIs¶

Exposed Capabilities (Partner API)¶

Capability	Endpoint	Method	Description	Credits
✅ Text Generation	`/api/v1/generate/text`	POST	Blog posts, emails, social content	10
✅ Content Series	`/api/v1/generate/series`	POST	Coordinated multi-piece campaigns	30
✅ Image Generation	`/api/v1/generate/image`	POST	Marketing visuals (Bedrock SD)	20
✅ Presentation Generation	`/api/v1/generate/presentation`	POST	AI slide decks	50
✅ Battlecard Generation	`/api/v1/generate/battlecard`	POST	Competitive positioning	25
✅ ACE Brief Generation	`/api/v1/generate/ace-brief`	POST	AWS Partner Central submissions	15
🔜 Video Script	`/api/v1/generate/video-script`	POST	Demo/explainer scripts	TBD

Internal Capabilities (Platform-Managed)¶

Capability	Why Internal	Partner Alternative
🔒 Brand Voice Engine	Requires tenant context, training data	Use API with `brand_profile_id`
🔒 Content Guardrails	AWS Bedrock Guardrails configuration	Inherit platform guardrails
🔒 Model Selection	Optimized routing to Bedrock models	Platform selects optimal model
🔒 Credit Optimization	Usage tracking, billing	Transparent credit consumption

API Example: Content Generation¶

POST /api/v1/generate/text
Authorization: Bearer {partner_api_key}
Content-Type: application/json

{
  "content_type": "blog_post",
  "topic": "AWS Marketplace listing optimization best practices",
  "brand_profile_id": "bp_abc123",
  "parameters": {
    "length": "long",
    "tone": "professional",
    "target_keywords": ["AWS Marketplace", "listing optimization", "ISV"],
    "target_persona": "Partner Marketing Manager"
  },
  "metadata": {
    "campaign_id": "camp_xyz789",
    "attribution_source": "partner_api"
  }
}

Response:
{
  "success": true,
  "content_id": "cnt_def456",
  "content": "# AWS Marketplace Listing Optimization...",
  "word_count": 1247,
  "credits_consumed": 10,
  "seo_score": 82,
  "brand_alignment_score": 89,
  "generation_model": "bedrock-claude-3-sonnet"
}

2. Knowledge & Intelligence APIs¶

Exposed Capabilities¶

Capability	Endpoint	Method	Description	Credits
✅ Knowledge Query	`/api/v1/knowledge/query`	POST	RAG search over uploaded docs	2
✅ Competitive Analysis	`/api/v1/intelligence/competitive`	POST	Competitor listing analysis	15
✅ Agreement Analysis	`/api/v1/intelligence/agreement`	POST	Parse contracts for key terms	10
✅ ICP Analysis	`/api/v1/intelligence/icp`	POST	Ideal customer profile matching	10
🔜 Market Trends	`/api/v1/intelligence/trends`	GET	AWS Marketplace category trends	TBD

Internal Capabilities¶

Capability	Why Internal	Partner Alternative
🔒 Bedrock Knowledge Base	Infrastructure management	Use Knowledge Query API
🔒 Embedding Generation	Titan embeddings pipeline	Automatic with doc upload
🔒 Vector Store	FAISS/OpenSearch management	Abstracted via API

3. Workflow & Agent APIs¶

Exposed Capabilities¶

Capability	Endpoint	Method	Description	Credits
✅ Start Workflow	`/api/v1/workflows/start`	POST	Execute pre-built GTM workflow	Varies
✅ Workflow Status	`/api/v1/workflows/{id}/status`	GET	Check execution progress	0
⚡ Workflow Stream	`wss://api.vell.io/v1/workflows/{id}`	WebSocket	Real-time status updates	0
✅ List Workflows	`/api/v1/workflows/templates`	GET	Available workflow templates	0
✅ Custom Workflow	`/api/v1/workflows/custom`	POST	Define custom workflow steps	Varies
🔜 Scheduled Workflow	`/api/v1/workflows/schedule`	POST	Schedule recurring workflows	TBD

Available Workflow Templates¶

Template ID	Name	Description	Avg Credits
`wf_product_launch`	Product Launch Campaign	Blog + 5 LinkedIn + 3 emails	80
`wf_competitive_brief`	Competitive Intelligence	Battlecard + positioning	40
`wf_ace_opportunity`	ACE Opportunity Brief	AWS Partner Central submission	25
`wf_private_offer`	Private Offer Campaign	Email sequence + social	60
`wf_partner_cosell`	Partner Co-Sell Brief	Meeting prep + talking points	35
`wf_weekly_digest`	Weekly GTM Digest	Performance summary	20
`wf_listing_optimize`	Listing Optimization	Analysis + recommendations	30
`wf_agreement_review`	Agreement Analyzer	Contract parsing + alerts	15

Internal Capabilities¶

Capability	Why Internal	Partner Alternative
🔒 AgentOrchestrator	Core orchestration engine	Use Workflow API
🔒 Step Functions Integration	AWS infrastructure	Abstracted via API
🔒 DynamoDB State Management	Workflow state tracking	Use Status API
🔒 Lambda Function Pool	Compute management	Platform-managed

4. AWS Marketplace Integration APIs¶

Exposed Capabilities¶

Capability	Endpoint	Method	Description	Credits
✅ Get Listing	`/api/v1/marketplace/listings/{id}`	GET	Retrieve own listing data	0
✅ Listing Health	`/api/v1/marketplace/listings/{id}/health`	GET	Compliance score + recommendations	5
✅ Generate Listing	`/api/v1/marketplace/listings/generate`	POST	AI-optimized listing content	40
✅ Agreement Sync	`/api/v1/marketplace/agreements/sync`	POST	Pull subscription data	5
✅ Agreement List	`/api/v1/marketplace/agreements`	GET	List active agreements	0
🔒 Publish Listing	N/A	N/A	Requires direct AWS access	N/A

Internal Capabilities¶

Capability	Why Internal	Partner Alternative
🔒 Marketplace Catalog API	Cross-account IAM complexity	Platform handles auth
🔒 Marketplace Agreement API	Seller-specific access	Use Agreement Sync
🔒 Marketplace Discovery API	Gated AWS access required	Request via Vell
🔒 IAM Role Assumption	Security boundary	CloudFormation template

5. Co-Sell & Partner APIs¶

Exposed Capabilities¶

Capability	Endpoint	Method	Description	Credits
✅ Partner Discovery	`/api/v1/cosell/discover`	POST	Find matching partners	20
✅ Partner Profile	`/api/v1/cosell/partners/{id}`	GET	Partner details + fit score	0
✅ Initiate Co-Sell	`/api/v1/cosell/campaigns`	POST	Start joint campaign	40
✅ Campaign Status	`/api/v1/cosell/campaigns/{id}`	GET	Track co-sell progress	0
🔜 CleanRooms Analysis	`/api/v1/cosell/overlap`	POST	Account overlap analysis	30

Internal Capabilities¶

Capability	Why Internal	Partner Alternative
🔒 Partner Matching Algorithm	Proprietary ICP scoring	Use Discovery API
🔒 AWS CleanRooms	Data clean room setup	Use Overlap API (when ready)
🔒 Partner Network Graph	Network effect data	Platform-managed

6. Publishing & Distribution APIs¶

Exposed Capabilities¶

Capability	Endpoint	Method	Description
✅ Publish LinkedIn	`/api/v1/publish/linkedin`	POST	Post to connected LinkedIn
✅ Schedule Post	`/api/v1/publish/schedule`	POST	Schedule for future publish
✅ Get Connections	`/api/v1/publish/connections`	GET	List connected accounts
🔜 Publish Twitter	`/api/v1/publish/twitter`	POST	Post to Twitter/X
🔜 Email Send	`/api/v1/publish/email`	POST	Send via connected ESP

Internal Capabilities¶

Capability	Why Internal	Partner Alternative
🔒 OAuth Token Management	Security, refresh handling	Connect once in UI
🔒 Rate Limiting	Platform-managed throttling	Automatic
🔒 Analytics Collection	Cross-platform tracking	Use Analytics API

7. Analytics & Attribution APIs¶

Exposed Capabilities¶

Capability	Endpoint	Method	Description
✅ Content Performance	`/api/v1/analytics/content/{id}`	GET	Views, engagement, attribution
✅ Campaign Analytics	`/api/v1/analytics/campaigns/{id}`	GET	Campaign-level metrics
✅ Pipeline Attribution	`/api/v1/analytics/attribution`	GET	Content → pipeline influence
🔜 ROI Dashboard	`/api/v1/analytics/roi`	GET	Partner ROI metrics

Partner Use Cases¶

Use Case 1: Automated Product Launch GTM¶

Scenario: Partner launches new feature on AWS Marketplace monthly. Needs consistent, high-quality GTM content without dedicated marketing headcount.

Build vs. Vell Analysis¶

Component	Build Yourself	Use Vellocity
LLM Integration	2-4 weeks, $5K-15K/month (OpenAI/Bedrock)	Included
Prompt Engineering	4-8 weeks, ongoing refinement	Pre-optimized for AWS
Brand Voice Training	2-3 weeks per brand	Upload once, use always
Multi-channel Coordination	6-8 weeks development	API call
AWS Marketplace Compliance	Ongoing research	Built-in guardrails
Content Quality Scoring	3-4 weeks	Automatic
Total Time to Value	3-6 months	Days
Monthly Cost	$8K-25K+	Credit-based (~$500)

API Integration Pattern¶

// Partner's CI/CD pipeline or scheduler
async function launchProductGTM(productInfo) {
  // 1. Start product launch workflow
  const workflow = await vell.workflows.start({
    template: 'wf_product_launch',
    parameters: {
      product_name: productInfo.name,
      key_features: productInfo.features,
      target_audience: productInfo.icp,
      launch_date: productInfo.date,
      aws_listing_id: productInfo.marketplaceId
    }
  });

  // 2. Stream progress updates
  const ws = vell.workflows.stream(workflow.id);
  ws.on('step_complete', (step) => {
    console.log(`Completed: ${step.name}`);
    // Update internal dashboard
  });

  // 3. Get generated content
  ws.on('complete', async () => {
    const content = await vell.workflows.getOutput(workflow.id);
    // content.blog_post, content.linkedin_series, content.emails

    // 4. Auto-publish or queue for review
    if (autoPublish) {
      await vell.publish.linkedin(content.linkedin_series[0]);
    }
  });
}

ROI Calculation¶

Metric	Without Vell	With Vell
Time per launch	16-24 hours	30 minutes
Content pieces	3-5	10-15
Launches per month	1-2	4+
Marketing FTE needed	0.5-1.0	0.1
Annual savings	—	$80K-150K

Use Case 2: Co-Sell Partner Program at Scale¶

Scenario: Partner wants to identify and engage complementary AWS ISV partners for joint GTM but lacks the data and tools to find good matches.

Build vs. Vell Analysis¶

Component	Build Yourself	Use Vellocity
Partner Database	Build/buy ($50K+), ongoing maintenance	500+ AWS ISV profiles
ICP Matching Algorithm	8-12 weeks ML development	API call
AWS CleanRooms Setup	4-6 weeks, AWS expertise required	Integrated
Joint Content Generation	Same as Use Case 1	Included
Approval Workflows	3-4 weeks	Built-in
Attribution Tracking	6-8 weeks	Included
Total Time to Value	6-12 months	Weeks

API Integration Pattern¶

// Weekly partner discovery job
async function discoverCoSellPartners() {
  // 1. Find matching partners
  const matches = await vell.cosell.discover({
    icp_overlap_min: 0.6,
    product_categories: ['Security', 'Data Analytics'],
    market_segments: ['Enterprise', 'Mid-Market'],
    exclude_competitors: true,
    limit: 20
  });

  // 2. Score and rank
  const ranked = matches.sort((a, b) =>
    b.composite_score - a.composite_score
  );

  // 3. Auto-initiate outreach for top matches
  for (const partner of ranked.slice(0, 5)) {
    if (partner.composite_score > 0.8) {
      await vell.cosell.initiate({
        partner_id: partner.id,
        campaign_type: 'joint_webinar',
        message_template: 'intro_high_fit'
      });
    }
  }

  // 4. Generate co-sell briefs for sales team
  const briefs = await Promise.all(
    ranked.slice(0, 10).map(p =>
      vell.generate.aceBrief({
        partner_id: p.id,
        opportunity_type: 'co_sell'
      })
    )
  );

  return { matches: ranked, briefs };
}

Value Metrics¶

Metric	Without Vell	With Vell
Partners evaluated/month	5-10 (manual)	100+
Match quality	Low (gut feel)	Data-driven
Time to first co-sell	3-6 months	2-4 weeks
Co-sell pipeline influenced	$0-500K	$2M+
Partner manager productivity	5 partners	25+ partners

Use Case 3: AWS Marketplace Listing Optimization¶

Scenario: Partner has underperforming AWS Marketplace listing. Needs data-driven optimization without hiring marketplace specialist.

Build vs. Vell Analysis¶

Component	Build Yourself	Use Vellocity
AWS Marketplace Best Practices	Research, always changing	Continuously updated
Competitor Analysis	Manual review, 4-8 hours/competitor	API: minutes
Compliance Validation	Manual checklist	Automated scoring
SEO Optimization	Hire specialist ($5K+/month)	Built-in
A/B Test Variants	2-4 weeks development	API call
Performance Tracking	Build dashboard	Included

API Integration Pattern¶

// Quarterly listing optimization
async function optimizeListing(listingId) {
  // 1. Get current listing health
  const health = await vell.marketplace.getHealth(listingId);
  console.log(`Current score: ${health.overall_score}/100`);
  console.log(`Issues: ${health.issues.map(i => i.type).join(', ')}`);

  // 2. Analyze top competitors
  const competitive = await vell.intelligence.competitive({
    listing_id: listingId,
    competitor_count: 5,
    analysis_depth: 'detailed'
  });

  // 3. Generate optimized listing
  const optimized = await vell.marketplace.generateListing({
    current_listing_id: listingId,
    competitive_insights: competitive.id,
    optimization_goals: ['seo', 'conversion', 'compliance'],
    generate_variants: 3
  });

  // 4. Return recommendations
  return {
    current_score: health.overall_score,
    projected_score: optimized.projected_score,
    variants: optimized.variants,
    top_changes: optimized.key_improvements,
    competitive_gaps: competitive.positioning_gaps
  };
}

ROI Calculation¶

Metric	Before Optimization	After Optimization
Listing health score	45-60	80-95
Organic discovery	Low	+40-60%
Click-through rate	2-3%	5-8%
Time to optimize	20-40 hours	2 hours
Pipeline impact	—	+25-50%

Use Case 4: Competitive Intelligence Automation¶

Scenario: Partner needs to monitor competitor AWS Marketplace activity and respond quickly to positioning changes.

Build vs. Vell Analysis¶

Component	Build Yourself	Use Vellocity
Competitor Monitoring	Build scraper, maintain, legal risk	API + alerts
Change Detection	ML pipeline, 4-8 weeks	Automatic
Battlecard Generation	Manual, 4-8 hours each	API: 5 minutes
Sales Enablement	Create + distribute	Generate + push
Alert System	Build notification pipeline	Webhooks

API Integration Pattern¶

// Webhook handler for competitive alerts
app.post('/webhooks/vell/competitive', async (req, res) => {
  const alert = req.body;

  if (alert.type === 'competitor_listing_change') {
    // 1. Auto-generate updated battlecard
    const battlecard = await vell.generate.battlecard({
      competitor_id: alert.competitor_id,
      change_summary: alert.changes,
      our_listing_id: OUR_LISTING_ID
    });

    // 2. Notify sales team
    await slack.post('#sales-enablement', {
      text: `Competitor ${alert.competitor_name} updated their listing`,
      attachments: [{
        title: 'Updated Battlecard',
        text: battlecard.summary,
        actions: [{
          type: 'button',
          text: 'View Full Battlecard',
          url: battlecard.url
        }]
      }]
    });

    // 3. Update CRM
    await salesforce.updateCompetitorRecord(alert.competitor_id, {
      last_change: alert.timestamp,
      battlecard_url: battlecard.url
    });
  }

  res.status(200).send('OK');
});

Use Case 5: Agreement Intelligence & Revenue Operations¶

Scenario: Partner has 50+ AWS Marketplace agreements and needs automated tracking of renewals, revenue, and churn risk.

Build vs. Vell Analysis¶

Component	Build Yourself	Use Vellocity
Agreement API Integration	2-4 weeks	Included
Contract Parsing (PDF/text)	ML pipeline, 6-8 weeks	API call
Renewal Calendar	Build + maintain	Automatic
Revenue Forecasting	Analytics build	Included
Churn Risk Scoring	ML model	Included
Alert System	Build pipeline	Webhooks

API Integration Pattern¶

// Daily revenue operations sync
async function syncAgreements() {
  // 1. Sync all agreements from AWS
  const syncResult = await vell.marketplace.syncAgreements();
  console.log(`Synced ${syncResult.new} new, ${syncResult.updated} updated`);

  // 2. Get agreements needing attention
  const alerts = await vell.marketplace.getAgreementAlerts({
    types: ['renewal_approaching', 'churn_risk', 'expansion_opportunity']
  });

  // 3. Process each alert type
  for (const alert of alerts) {
    switch (alert.type) {
      case 'renewal_approaching':
        // Generate renewal brief
        const brief = await vell.generate.text({
          content_type: 'renewal_brief',
          context: { agreement: alert.agreement }
        });
        await notifyCSM(alert.agreement.owner, brief);
        break;

      case 'churn_risk':
        // Escalate to leadership
        await createChurnTicket(alert);
        break;

      case 'expansion_opportunity':
        // Queue for sales outreach
        await salesforce.createOpportunity({
          account: alert.agreement.customer,
          type: 'Expansion',
          source: 'Vell AI Detection'
        });
        break;
    }
  }

  // 4. Update revenue dashboard
  const metrics = await vell.analytics.getRevenueMetrics();
  await updateDashboard(metrics);
}

API Architecture¶

Authentication¶

Partner App → API Gateway → Lambda Authorizer → Vell Services
                  ↓
            Validate API Key
            Check Rate Limits
            Log Usage
            Route Request

Endpoints¶

Environment	Base URL
Production	`https://api.vell.io/v1`
Sandbox	`https://sandbox-api.vell.io/v1`
WebSocket	`wss://api.vell.io/v1/ws`

Rate Limits¶

Tier	Requests/min	Concurrent	WebSocket Connections
Starter	60	5	2
Professional	300	25	10
Enterprise	1000	100	50

Error Handling¶

{
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Rate limit exceeded. Retry after 60 seconds.",
    "retry_after": 60,
    "request_id": "req_abc123"
  }
}

Partner Capabilities Summary (For Slide Deck)¶

Slide 1: What You Get¶

Capability	API Access	Time to Value
GTM Content Generation	✅ Full API	Minutes
AWS Marketplace Integration	✅ Full API	Hours
Co-Sell Partner Discovery	✅ Full API	Days
Competitive Intelligence	✅ Full API	Minutes
Agreement Analytics	✅ Full API	Hours
Multi-Channel Publishing	✅ Full API	Minutes

Slide 2: Build vs. Buy¶

Building Yourself	Using Vellocity
6-12 months development	Days to integrate
$200K-500K investment	Credit-based pricing
2-4 FTE ongoing	Self-service API
Constant maintenance	Always updated
Risk of outdated practices	AWS-aligned best practices

Slide 3: Integration Effort¶

Integration Type	Effort	Example
Webhook (passive)	1 day	Receive alerts on competitor changes
API polling	2-3 days	Sync agreement data daily
Workflow trigger	1 week	Launch GTM on product release
Full automation	2-4 weeks	End-to-end GTM pipeline

Slide 4: ROI Metrics¶

Partner Type	Typical Annual Value
Early-stage ISV	$50K-100K (FTE replacement)
Growth ISV	$150K-300K (velocity + quality)
Enterprise ISV	$500K+ (scale + co-sell)

Slide 5: Getting Started¶

Sign up → Get API key (sandbox)
Test → Try content generation API
Integrate → Connect to your workflow
Scale → Add workflows as needed

Next Steps for Partners¶

Request API Access: Contact partners@vell.io
Review Documentation: https://docs.vell.io/api
Try Sandbox: Test endpoints without credits
Schedule Demo: See use cases in action
Start Integration: Begin with single workflow

Appendix: Full API Reference¶

See /docs/api/ for complete OpenAPI specification including: - All endpoints with request/response schemas - Authentication details - Webhook event types - SDK downloads (Python, Node.js, PHP)

Document maintained by Vellocity Partner Team For API access: partners@vell.io For technical support: api-support@vell.io