EnvatoBuildSDK 1.0.2

EnvatoBuildSDK

A comprehensive .NET SDK for interacting with the Envato Market API. This library provides a simple and intuitive way to access Envato's API endpoints for managing user accounts, tracking sales, retrieving item details, and accessing financial statements.

Features

• User account management (username, email, profile)
• Sales tracking and history
• Item details and catalog access
• Financial statements and transactions
• Purchase code/license verification and activation
• Buyer purchase history and downloads
• Author statistics and earnings analytics
• Private & public collections management
• Marketplace search functionality
• Popular, featured, trending, and free items
• Category browsing and filtering
• Public user profiles and badges
• WordPress theme/plugin version tracking
• Similar items discovery
• Item pricing information (regular & extended licenses)
• Per-item sales analytics for authors
• Comment and review search
• Batch operations for multiple items
• Complete Envato Market API coverage
• All marketplace sites support (ThemeForest, CodeCanyon, VideoHive, AudioJungle, GraphicRiver, PhotoDune, 3DOcean)
• Fully async/await compatible
• Strongly-typed models
• Comprehensive error handling
• Support for pagination
• Cancellation token support

Installation

NuGet Package Manager

Install-Package EnvatoBuildSDK

.NET CLI

dotnet add package EnvatoBuildSDK

Package Reference

<PackageReference Include="EnvatoBuildSDK" Version="1.0.0" />

Getting Started

Prerequisites

You'll need a personal token from Envato to use this SDK:

1. Log in to your Envato account
2. Navigate to Settings > API Keys
3. Generate a new Personal Token with the required permissions

Basic Usage

using EnvatoBuildSDK.Api;
using EnvatoBuildSDK.Api.Models;

// Initialize the client with your personal token
using var client = new EnvatoClient("your-personal-token-here");

// Get user account information
var user = await client.GetUserAccountAsync();
Console.WriteLine($"Username: {user.Username}");
Console.WriteLine($"Sales: {user.Sales}");
Console.WriteLine($"Balance: ${user.Balance}");

API Examples

User Account Operations

// Get full account details
var account = await client.GetUserAccountAsync();
Console.WriteLine($"Name: {account.FirstName} {account.Surname}");
Console.WriteLine($"Email: {account.Email}");
Console.WriteLine($"Country: {account.Country}");

// Get just the username
var username = await client.GetUsernameAsync();
Console.WriteLine($"Logged in as: {username}");

Sales Management

// Get all sales (first page)
var sales = await client.GetSalesAsync();
foreach (var sale in sales)
{
    Console.WriteLine($"Item: {sale.Item?.Name}");
    Console.WriteLine($"Buyer: {sale.Buyer}");
    Console.WriteLine($"Amount: {sale.Amount}");
    Console.WriteLine($"Date: {sale.SoldAt}");
    Console.WriteLine($"License: {sale.License}");
    Console.WriteLine();
}

// Get sales with pagination
var page2Sales = await client.GetSalesAsync(page: 2);

Item Details

// Get details for a specific item
long itemId = 12345678;
var item = await client.GetItemAsync(itemId);

Console.WriteLine($"Name: {item.Name}");
Console.WriteLine($"Description: {item.Description}");
Console.WriteLine($"Price: ${item.PriceCents / 100.0}");
Console.WriteLine($"Sales: {item.NumberOfSales}");
Console.WriteLine($"Rating: {item.Rating?.RatingValue} ({item.Rating?.Count} reviews)");
Console.WriteLine($"Author: {item.AuthorUsername}");
Console.WriteLine($"URL: {item.Url}");

Financial Statements

// Get all statements
var statements = await client.GetStatementsAsync();
foreach (var statement in statements)
{
    Console.WriteLine($"Date: {statement.OccurredAt}");
    Console.WriteLine($"Type: {statement.Kind}");
    Console.WriteLine($"Amount: {statement.Amount}");
    Console.WriteLine($"Balance: {statement.Balance}");
    Console.WriteLine($"Detail: {statement.Detail}");
    Console.WriteLine();
}

// Get statements with date filtering
var startDate = new DateTime(2024, 1, 1);
var endDate = new DateTime(2024, 12, 31);
var filteredStatements = await client.GetStatementsAsync(
    fromDate: startDate,
    toDate: endDate
);

// Get statements with pagination
var page1 = await client.GetStatementsAsync(page: 1);

License/Purchase Code Verification

// Verify a purchase code when a customer activates their license
string purchaseCode = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";

try
{
    var verification = await client.VerifyPurchaseCodeAsync(purchaseCode);

    Console.WriteLine($"Valid Purchase: {verification.IsValid}");
    Console.WriteLine($"Buyer: {verification.Buyer}");
    Console.WriteLine($"Item: {verification.Item?.Name}");
    Console.WriteLine($"Purchase Date: {verification.SoldAt}");
    Console.WriteLine($"License Type: {verification.License}");
    Console.WriteLine($"Amount Paid: {verification.Amount}");
    Console.WriteLine($"Support Until: {verification.SupportedUntil}");
    Console.WriteLine($"Support Active: {verification.IsSupportActive}");
}
catch (EnvatoApiException ex)
{
    Console.WriteLine($"Invalid purchase code: {ex.Message}");
}

// Quick validation check
bool isValid = await client.IsPurchaseCodeValidAsync(purchaseCode);
if (isValid)
{
    Console.WriteLine("License activated successfully!");
}

// Check if support is still active
bool hasSupport = await client.IsSupportActiveAsync(purchaseCode);
if (!hasSupport)
{
    Console.WriteLine("Support has expired. Please renew for continued support.");
}

// Get buyer information
string buyer = await client.GetBuyerFromPurchaseCodeAsync(purchaseCode);
Console.WriteLine($"Licensed to: {buyer}");

// Get the item ID for database storage
long? itemId = await client.GetItemIdFromPurchaseCodeAsync(purchaseCode);

Complete License Activation Flow

public async Task<bool> ActivateLicenseAsync(string purchaseCode, string domain)
{
    try
    {
        // Step 1: Verify the purchase code is valid
        var verification = await client.VerifyPurchaseCodeAsync(purchaseCode);

        if (!verification.IsValid)
        {
            Console.WriteLine("Invalid purchase code");
            return false;
        }

        // Step 2: Check if the purchase is for the correct item
        if (verification.Item?.Id != YOUR_ITEM_ID)
        {
            Console.WriteLine("This purchase code is for a different product");
            return false;
        }

        // Step 3: Store activation in your database
        await SaveActivationToDatabase(new
        {
            PurchaseCode = purchaseCode,
            Buyer = verification.Buyer,
            Domain = domain,
            ItemId = verification.Item.Id,
            ItemName = verification.Item.Name,
            ActivatedAt = DateTime.UtcNow,
            SupportUntil = verification.SupportedUntil,
            LicenseType = verification.License
        });

        // Step 4: Return success
        Console.WriteLine($"License activated for {verification.Buyer} on {domain}");
        Console.WriteLine($"Support valid until: {verification.SupportedUntil}");

        return true;
    }
    catch (EnvatoApiException ex)
    {
        Console.WriteLine($"Activation failed: {ex.Message}");
        return false;
    }
}

Author Statistics and Analytics

// Get total sales count
int totalSales = await client.GetTotalSalesAsync();
Console.WriteLine($"Total Sales: {totalSales}");

// Get total items count
int totalItems = await client.GetTotalItemsAsync();
Console.WriteLine($"Total Items: {totalItems}");

// Get earnings summary
var earnings = await client.GetEarningsSummaryAsync();
Console.WriteLine($"Available Earnings: {earnings.AvailableEarnings}");
Console.WriteLine($"Total Earnings: {earnings.TotalEarnings}");
Console.WriteLine($"Balance: {earnings.Balance}");

Collections Management

// Get all your private collections
var collections = await client.GetPrivateCollectionsAsync();
foreach (var collection in collections)
{
    Console.WriteLine($"Collection: {collection.Name}");
    Console.WriteLine($"Items: {collection.ItemCount}");
    Console.WriteLine($"Created: {collection.CreatedAt}");
    Console.WriteLine($"Private: {collection.IsPrivate}");
    Console.WriteLine();
}

// Get a specific collection
string collectionId = "abc123";
var collection = await client.GetCollectionAsync(collectionId);
Console.WriteLine($"Collection '{collection.Name}' has {collection.ItemCount} items");

Marketplace Search

// Search for items
var searchResults = await client.SearchItemsAsync("wordpress theme");
Console.WriteLine($"Found {searchResults.Matches} matches");

foreach (var item in searchResults.Items ?? new List<SearchItem>())
{
    Console.WriteLine($"Item: {item.Name}");
    Console.WriteLine($"Price: ${item.PriceCents / 100.0}");
    Console.WriteLine($"Sales: {item.Sales}");
    Console.WriteLine($"Rating: {item.Rating} ({item.RatingCount} reviews)");
    Console.WriteLine($"Trending: {item.Trending}");
    Console.WriteLine();
}

// Search with site filter
var themeForestResults = await client.SearchItemsAsync(
    "admin dashboard",
    site: "themeforest.net",
    page: 1
);

// Search CodeCanyon
var codeResults = await client.SearchItemsAsync(
    "php script",
    site: "codecanyon.net"
);

Popular and Featured Items

// Get popular items from CodeCanyon
var popularItems = await client.GetPopularItemsAsync("codecanyon");
Console.WriteLine("Popular Items:");
foreach (var item in popularItems)
{
    Console.WriteLine($"- {item.Name} ({item.NumberOfSales} sales)");
}

// Get popular items from ThemeForest
var popularThemes = await client.GetPopularItemsAsync("themeforest");

// Get featured items
var featuredItems = await client.GetFeaturedItemsAsync("codecanyon");
Console.WriteLine($"Featured: {featuredItems.Count} items");

// Get random new items
var randomNew = await client.GetRandomNewItemsAsync("codecanyon");
Console.WriteLine($"Random New Items: {randomNew.Count}");

Browse by Category

// Get items from a specific category
var phpScripts = await client.GetItemsByCategoryAsync(
    category: "php-scripts",
    site: "codecanyon"
);

Console.WriteLine($"PHP Scripts: {phpScripts.Count} items");
foreach (var item in phpScripts)
{
    Console.WriteLine($"- {item.Name}");
    Console.WriteLine($"  Price: ${item.PriceCents / 100.0}");
    Console.WriteLine($"  Sales: {item.NumberOfSales}");
}

// Get WordPress themes
var wpThemes = await client.GetItemsByCategoryAsync(
    category: "wordpress",
    site: "themeforest"
);

Buyer Purchases and Downloads

// Get all your purchases as a buyer
var purchases = await client.GetBuyerPurchasesAsync();
foreach (var purchase in purchases)
{
    Console.WriteLine($"Item: {purchase.Item?.Name}");
    Console.WriteLine($"Purchase Code: {purchase.Code}");
    Console.WriteLine($"Purchase Date: {purchase.SoldAt}");
    Console.WriteLine($"License: {purchase.License}");
    Console.WriteLine($"Support Until: {purchase.SupportedUntil}");
    Console.WriteLine($"Support Active: {purchase.IsSupportActive}");
    Console.WriteLine();
}

// Get a specific purchase by code
string myPurchaseCode = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
var purchase = await client.GetBuyerPurchaseAsync(myPurchaseCode);
Console.WriteLine($"You purchased: {purchase.Item?.Name}");

// Get download information for a purchased item
long itemId = 12345678;
var downloadInfo = await client.GetDownloadAsync(itemId);
Console.WriteLine($"Download URL: {downloadInfo.DownloadUrl}");
Console.WriteLine($"Item: {downloadInfo.ItemName}");

// WordPress metadata included
if (downloadInfo.WordPressMetadata != null)
{
    Console.WriteLine($"Theme: {downloadInfo.WordPressMetadata.ThemeName}");
    Console.WriteLine($"Version: {downloadInfo.WordPressMetadata.Version}");
}

Public User Profiles

// Get public profile for any user
var profile = await client.GetPublicUserProfileAsync("Alpha");
Console.WriteLine($"Username: {profile.Username}");
Console.WriteLine($"Country: {profile.Country}");
Console.WriteLine($"Total Sales: {profile.Sales}");
Console.WriteLine($"Followers: {profile.Followers}");
Console.WriteLine($"Homepage: {profile.Homepage}");

// Get user badges
var badges = await client.GetUserBadgesAsync("Alpha");
foreach (var badge in badges)
{
    Console.WriteLine($"Badge: {badge.Label}");
    Console.WriteLine($"Description: {badge.Tooltip}");
}

// Get all items by a user on specific site
var userItems = await client.GetUserItemsBySiteAsync("Alpha", "codecanyon");
Console.WriteLine($"User has {userItems.Count} items on CodeCanyon");

// Get user's new files
var newFiles = await client.GetUserNewFilesAsync("Alpha", "themeforest");
Console.WriteLine($"Recent uploads: {newFiles.Count}");

WordPress Version Information

// Get WordPress theme/plugin version details
long wpItemId = 12345678;
var versionInfo = await client.GetItemVersionAsync(wpItemId);

Console.WriteLine($"Current Version: {versionInfo.Version}");
Console.WriteLine($"Updated: {versionInfo.UpdatedAt}");
Console.WriteLine($"WordPress Required: {versionInfo.WordPressVersionRequired}");
Console.WriteLine($"WordPress Tested: {versionInfo.WordPressVersionTested}");
Console.WriteLine($"PHP Required: {versionInfo.PhpVersionRequired}");

Market Statistics and Discovery

// Get total Envato Market users
int totalUsers = await client.GetTotalUsersAsync();
Console.WriteLine($"Total Envato Users: {totalUsers:N0}");

// Get categories for a marketplace
var categories = await client.GetCategoriesAsync("codecanyon");
foreach (var category in categories)
{
    Console.WriteLine($"Category: {category.Name}");
    Console.WriteLine($"Items: {category.ItemsCount}");
    Console.WriteLine($"Path: {category.Path}");
}

// Find similar items
long itemId = 12345678;
var similarItems = await client.GetSimilarItemsAsync(itemId);
Console.WriteLine($"Found {similarItems.Count} similar items");
foreach (var item in similarItems)
{
    Console.WriteLine($"- {item.Name} (${item.PriceCents / 100.0})");
}

// Get email of authenticated user
string email = await client.GetEmailAsync();
Console.WriteLine($"Your email: {email}");

Item Pricing Information

// Get detailed pricing for an item
long itemId = 12345678;
var pricing = await client.GetItemPricingAsync(itemId);

Console.WriteLine($"Regular License: ${pricing.RegularPrice}");
Console.WriteLine($"Extended License: ${pricing.ExtendedPrice}");
Console.WriteLine($"Price Difference: ${pricing.PriceDifference}");
Console.WriteLine($"Currency: {pricing.Currency}");
Console.WriteLine($"Site: {pricing.Site}");

// Compare pricing across multiple items
var itemIds = new[] { 123456L, 234567L, 345678L };
foreach (var id in itemIds)
{
    var price = await client.GetItemPricingAsync(id);
    Console.WriteLine($"Item {id}: ${price.RegularPrice}");
}

Public Collections

// Get a public collection (different from private user collections)
string publicCollectionId = "abc123xyz";
var publicCollection = await client.GetPublicCollectionAsync(publicCollectionId);

Console.WriteLine($"Collection: {publicCollection.Name}");
Console.WriteLine($"Description: {publicCollection.Description}");
Console.WriteLine($"Total Items: {publicCollection.ItemCount}");
Console.WriteLine($"Created: {publicCollection.CreatedAt}");

// Browse items in the public collection
if (publicCollection.Items != null)
{
    foreach (var item in publicCollection.Items)
    {
        Console.WriteLine($"- {item.Name} (${item.PriceCents / 100.0})");
    }
}

Comment and Review Search

// Search for comments/reviews on a specific item
long itemId = 12345678;
var commentResults = await client.SearchItemCommentsAsync(itemId);

Console.WriteLine($"Found {commentResults.Matches} comments");

foreach (var comment in commentResults.Comments ?? new List<Comment>())
{
    Console.WriteLine($"User: {comment.Username}");
    Console.WriteLine($"Rating: {comment.Rating}/5");
    Console.WriteLine($"Comment: {comment.Body}");
    Console.WriteLine($"Posted: {comment.CreatedAt}");
    Console.WriteLine();
}

// Get comments with pagination
var page2Comments = await client.SearchItemCommentsAsync(itemId, page: 2);

// Analyze overall sentiment
var allComments = commentResults.Comments ?? new List<Comment>();
var averageRating = allComments
    .Where(c => c.Rating.HasValue)
    .Average(c => c.Rating!.Value);
Console.WriteLine($"Average Rating: {averageRating:F2}/5");

Author Per-Item Sales Analytics

// Get sales for a specific item you authored
long myItemId = 12345678;
var itemSales = await client.GetItemSalesAsync(myItemId);

Console.WriteLine($"Total sales for this item: {itemSales.Count}");

// Analyze sales data
var totalRevenue = itemSales.Sum(s => decimal.Parse(s.Amount ?? "0"));
var averageSale = itemSales.Average(s => decimal.Parse(s.Amount ?? "0"));

Console.WriteLine($"Total Revenue: ${totalRevenue}");
Console.WriteLine($"Average Sale: ${averageSale:F2}");

// Get sales by license type
var regularLicenses = itemSales.Count(s => s.License == "Regular License");
var extendedLicenses = itemSales.Count(s => s.License == "Extended License");

Console.WriteLine($"Regular Licenses: {regularLicenses}");
Console.WriteLine($"Extended Licenses: {extendedLicenses}");

// Get all items you've authored across all marketplaces
var myItems = await client.GetMyItemsAsync();
Console.WriteLine($"You have {myItems.Count} total items");

foreach (var item in myItems)
{
    Console.WriteLine($"- {item.Name} on {item.Site}");
    Console.WriteLine($"  Sales: {item.NumberOfSales}, Rating: {item.Rating?.RatingValue}");
}

Trending Items and Free Files

// Get currently trending items on CodeCanyon
var trendingItems = await client.GetTrendingItemsAsync("codecanyon");
Console.WriteLine("Top 20 Trending Items:");
foreach (var item in trendingItems)
{
    Console.WriteLine($"{item.Name} - {item.NumberOfSales} sales");
}

// Get trending themes
var trendingThemes = await client.GetTrendingItemsAsync("themeforest");

// Get free files available on a marketplace
var freeFiles = await client.GetFreeFilesAsync("codecanyon");
Console.WriteLine($"\nFree Files Available: {freeFiles.Count}");

foreach (var freeFile in freeFiles.Take(10))
{
    Console.WriteLine($"Free: {freeFile.Name}");
    Console.WriteLine($"Author: {freeFile.AuthorUsername}");
    Console.WriteLine($"Downloads: {freeFile.NumberOfSales}");
    Console.WriteLine();
}

// Get free files from other marketplaces
var freeThemes = await client.GetFreeFilesAsync("themeforest");
var freeGraphics = await client.GetFreeFilesAsync("graphicriver");
var freeMusic = await client.GetFreeFilesAsync("audiojungle");

Batch Operations

// Fetch multiple items at once efficiently
var itemIds = new[] { 12345678L, 23456789L, 34567890L, 45678901L, 56789012L };
var items = await client.GetItemsBatchAsync(itemIds);

foreach (var kvp in items)
{
    if (kvp.Value != null)
    {
        Console.WriteLine($"Item {kvp.Key}: {kvp.Value.Name} - ${kvp.Value.PriceCents / 100.0}");
    }
    else
    {
        Console.WriteLine($"Item {kvp.Key}: Failed to fetch");
    }
}

// Process results
var successfulFetches = items.Where(i => i.Value != null).ToList();
var failedFetches = items.Where(i => i.Value == null).ToList();

Console.WriteLine($"Successfully fetched: {successfulFetches.Count}");
Console.WriteLine($"Failed fetches: {failedFetches.Count}");

// Compare prices across items
var prices = items
    .Where(i => i.Value != null)
    .Select(i => new { i.Value!.Name, Price = i.Value.PriceCents / 100.0 })
    .OrderBy(i => i.Price);

foreach (var item in prices)
{
    Console.WriteLine($"{item.Name}: ${item.Price}");
}

Marketplace Site Information

// Get all available Envato marketplace sites
var sites = client.GetAvailableSites();
Console.WriteLine("Available Marketplaces:");
foreach (var site in sites)
{
    Console.WriteLine($"- {site}");
}

// Get site descriptions
var siteDescriptions = client.GetSiteDescriptions();
foreach (var kvp in siteDescriptions)
{
    Console.WriteLine($"{kvp.Key}: {kvp.Value}");
}

// Example output:
// themeforest: WordPress Themes & Website Templates
// codecanyon: Code Scripts & Plugins
// videohive: Video Templates & Stock Footage
// audiojungle: Royalty Free Music & Audio
// graphicriver: Graphics, Print Templates & Fonts
// photodune: Stock Photography
// 3docean: 3D Models & Materials

// Loop through all marketplaces
foreach (var site in sites)
{
    var popularItems = await client.GetPopularItemsAsync(site);
    Console.WriteLine($"\n{site} - Top {popularItems.Count} popular items");
}

Advanced Usage

Using Dependency Injection

// In Startup.cs or Program.cs
services.AddHttpClient<EnvatoClient>((serviceProvider, httpClient) =>
{
    var token = serviceProvider.GetRequiredService<IConfiguration>()["Envato:PersonalToken"];
    return new EnvatoClient(token, httpClient);
});

// In your service or controller
public class MyService
{
    private readonly EnvatoClient _envatoClient;

    public MyService(EnvatoClient envatoClient)
    {
        _envatoClient = envatoClient;
    }

    public async Task<User> GetUserInfo()
    {
        return await _envatoClient.GetUserAccountAsync();
    }
}

Error Handling

try
{
    var user = await client.GetUserAccountAsync();
}
catch (EnvatoApiException ex)
{
    Console.WriteLine($"API Error: {ex.Message}");
    Console.WriteLine($"Status Code: {ex.StatusCode}");
    Console.WriteLine($"Response: {ex.ResponseBody}");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
}

Using Cancellation Tokens

var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));

try
{
    var sales = await client.GetSalesAsync(cancellationToken: cts.Token);
}
catch (OperationCanceledException)
{
    Console.WriteLine("Request was cancelled");
}

Models

The SDK includes strongly-typed models for all API responses:

Core Models:

• User - User account information
• Sale - Sales transaction data
• Item - Marketplace item details
• Statement - Financial statement entries

License & Purchase:

• PurchaseCodeVerification - Purchase code verification details
• PurchaseItem - Item information from purchase verification
• LicenseActivation - License activation data

Statistics & Analytics:

• AuthorStatistics - Author performance metrics
• MonthlyEarnings - Month-by-month earnings data
• EarningsSummary - Overall earnings summary
• ItemSalesStatistics - Per-item sales statistics

Collections:

• Collection - User collection information (private and public)
• CollectionItem - Items within collections

Search & Browse:

• SearchResult - Search results container
• SearchItem - Individual search result
• Category - Category information
• PopularItem - Popular item data

Buyer/Purchases:

• BuyerPurchase - Buyer purchase information
• PurchaseItemDetails - Detailed item info from purchase
• DownloadInfo - Download URLs and metadata
• WordPressMetadata - WordPress theme/plugin metadata

Public Profiles:

• PublicUserProfile - Public user profile data
• UserBadge - User achievement badges
• UserItemsBySite - User's items grouped by site
• ItemVersion - WordPress item version information

Pricing & Comments:

• ItemPricing - Item pricing details (regular & extended licenses)
• Comment - User comment/review data
• CommentSearchResult - Comment search results with pagination

Utility:

• ApiResponse<T> - Generic paginated response wrapper
• EnvatoApiException - API error handling

Building the Package

To build the NuGet package locally:

dotnet build -c Release
dotnet pack -c Release

The package will be created in bin/Release/.

Publishing to NuGet

dotnet nuget push bin/Release/EnvatoBuildSDK.1.0.0.nupkg --api-key YOUR_API_KEY --source https://api.nuget.org/v3/index.json

API Documentation

For more information about the Envato API, visit:

• Envato API Documentation
• API Reference

Requirements

• .NET 8.0 or higher
• Valid Envato personal token

License

MIT License - feel free to use this in your projects.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Support

If you encounter any issues or have questions:

• Open an issue on GitHub
• Check the Envato API documentation
• Review the example code in this README

Changelog

Version 1.0.2 (Latest)

• Enhanced Marketplace Discovery - New powerful features for browsing and analytics!
• Added 10+ new API features:
  • Item Pricing: Detailed pricing information with regular and extended license prices
  • Public Collections: Browse and discover public collections across marketplaces
  • Comment Search: Search and analyze item comments/reviews with sentiment analysis
  • Per-Item Sales Analytics: Track sales performance for individual items
  • Trending Items: Discover currently trending products on any marketplace
  • Free Files: Find and access free items across all Envato sites
  • Batch Operations: Efficiently fetch multiple items simultaneously
  • Site Information: Complete marketplace site reference and descriptions
  • Author Portfolio: Get all items authored by the authenticated user across all sites
  • Enhanced Analytics: Revenue breakdown, license type analysis, and more
• Added new models: ItemPricing, Comment, CommentSearchResult
• Improved documentation with detailed examples for all new features
• Better support for all 7 Envato marketplaces
• Performance improvements for bulk operations

Version 1.0.1

• Complete Envato Market API Coverage - All major endpoints now implemented!
• Added 20+ new API features:
  • Buyer Features: Purchase history, download management, purchase lookup
  • Author Statistics: Total sales, total items, earnings summary
  • Collections: Private collections management and browsing
  • Search & Discovery: Marketplace search, similar items, categories
  • Popular Content: Popular, featured, and random new items
  • Public Profiles: User profiles, badges, author items
  • WordPress: Theme/plugin version tracking and metadata
  • Market Stats: Total users, categories, advanced filtering
  • User Info: Email retrieval, enhanced profile access
• Enhanced models for all API response types
• Comprehensive examples for every feature
• Full pagination support across all endpoints

Version 1.0.0

• Initial release
• User account management
• Sales tracking
• Item details retrieval
• Financial statements access
• Purchase code/license verification and activation
• Full async/await support
• Comprehensive error handling
• Support validation helpers
• Buyer information retrieval