Many developers modify plugin files directly, creating maintenance nightmares when updates overwrite customizations. The proper approach uses documented APIs that survive updates while enabling powerful customization. According to WordPress developer best practices, 92% of plugin conflicts stem from direct file modifications rather than using provided hooks.

This comprehensive LaunchPad API reference documents all available hooks, filters, and actions including recipe system filters, wizard workflow actions, branding and content hooks, REST API endpoints, theme integration points, and complete code examples. Use this reference guide to extend LaunchPad systematically and maintainably.

Filter Hooks Reference

Filters allow modifying data before LaunchPad processes it. Return modified values from filter callbacks.

launchpad_custom_recipes

Purpose: Add custom recipes to LaunchPad recipe selection.

Parameters:

• $recipes (array): Existing recipes array

Returns: Modified recipes array

Example:

add_filter('launchpad_custom_recipes', 'add_custom_recipes');

function add_custom_recipes($recipes) {
    $custom_recipe = array(
        'site_type' => 'medical',
        'name' => 'Medical Practice',
        'description' => 'Website for medical practices and healthcare',
        'icon' => 'dashicons-heart',
        'category' => 'business',
        'pro_only' => false,
        'pages' => array('home', 'services', 'about', 'contact')
    );

    $recipes[] = $custom_recipe;
    return $recipes;
}

launchpad_recipe_data

Purpose: Modify recipe data before processing during site build.

Parameters:

• $recipe_data (array): Recipe configuration data
• $recipe_slug (string): Recipe identifier

Returns: Modified recipe data array

Example:

add_filter('launchpad_recipe_data', 'customize_recipe_plugins', 10, 2);

function customize_recipe_plugins($recipe_data, $recipe_slug) {
    if ($recipe_slug === 'business') {
        // Add additional plugin for business recipe
        $recipe_data['plugins'][] = 'custom-business-plugin';
    }
    return $recipe_data;
}

launchpad_page_content

Purpose: Customize generated page content before creation.

Parameters:

• $content (string): Page content HTML
• $page_slug (string): Page identifier
• $recipe_slug (string): Recipe being used
• $branding_data (array): User-provided branding information

Returns: Modified content string

Example:

add_filter('launchpad_page_content', 'customize_about_page', 10, 4);

function customize_about_page($content, $page_slug, $recipe_slug, $branding_data) {
    if ($page_slug === 'about') {
        $company_name = isset($branding_data['site_name'])
            ? $branding_data['site_name']
            : 'Our Company';

        $custom_content = '<h2>About ' . esc_html($company_name) . '</h2>';
        $custom_content .= '<p>Custom about content here...</p>';
        $custom_content .= $content; // Append original content

        return $custom_content;
    }
    return $content;
}

launchpad_plugin_list

Purpose: Modify recommended plugin list before display/installation.

Parameters:

• $plugins (array): Plugin slugs array
• $recipe_slug (string): Current recipe

Returns: Modified plugins array

Example:

add_filter('launchpad_plugin_list', 'add_required_plugins', 10, 2);

function add_required_plugins($plugins, $recipe_slug) {
    // Add security plugin to all recipes
    if (!in_array('wordfence', $plugins)) {
        $plugins[] = 'wordfence';
    }
    return $plugins;
}

launchpad_theme_options

Purpose: Modify theme Customizer settings applied during setup.

Parameters:

• $options (array): Theme options array
• $recipe_slug (string): Current recipe

Returns: Modified options array

Example:

add_filter('launchpad_theme_options', 'customize_theme_colors', 10, 2);

function customize_theme_colors($options, $recipe_slug) {
    if ($recipe_slug === 'portfolio') {
        $options['primary_color'] = '#FF6B6B';
        $options['secondary_color'] = '#4ECDC4';
    }
    return $options;
}

launchpad_branding_css

Purpose: Modify CSS generated from branding choices.

Parameters:

• $css (string): Generated CSS code
• $branding_data (array): Branding configuration

Returns: Modified CSS string

Example:

add_filter('launchpad_branding_css', 'add_custom_branding_css', 10, 2);

function add_custom_branding_css($css, $branding_data) {
    $custom_css = "
    .custom-element {
        background-color: {$branding_data['primary_color']};
    }
    ";
    return $css . $custom_css;
}

Action Hooks Reference

Actions allow executing code at specific points in LaunchPad execution. Don’t return values from action callbacks.

launchpad_before_recipe_build

Purpose: Execute code before recipe site generation begins.

Parameters:

• $recipe_slug (string): Recipe being built
• $branding_data (array): User-provided branding data

Example:

add_action('launchpad_before_recipe_build', 'prepare_custom_setup', 10, 2);

function prepare_custom_setup($recipe_slug, $branding_data) {
    // Log build start
    error_log("Building site with recipe: {$recipe_slug}");

    // Set up custom options
    update_option('custom_setup_timestamp', time());

    // Prepare any resources needed
}

launchpad_after_recipe_build

Purpose: Execute code after recipe site generation completes.

Parameters:

• $recipe_slug (string): Recipe that was built
• $branding_data (array): Branding data used

Example:

add_action('launchpad_after_recipe_build', 'post_build_setup', 10, 2);

function post_build_setup($recipe_slug, $branding_data) {
    // Create custom post type content
    if ($recipe_slug === 'portfolio') {
        create_sample_portfolio_items();
    }

    // Send notification
    wp_mail(
        get_option('admin_email'),
        'Site Build Complete',
        "Your {$recipe_slug} site has been created successfully."
    );

    // Clear any caches
    if (function_exists('wp_cache_flush')) {
        wp_cache_flush();
    }
}

launchpad_page_created

Purpose: Execute code after individual page creation.

Parameters:

• $page_id (int): Created page ID
• $page_slug (string): Page slug/identifier
• $recipe_slug (string): Current recipe

Example:

add_action('launchpad_page_created', 'customize_page_meta', 10, 3);

function customize_page_meta($page_id, $page_slug, $recipe_slug) {
    // Add custom meta to specific pages
    if ($page_slug === 'contact') {
        update_post_meta($page_id, '_contact_form_id', '123');
    }

    // Set page template
    if ($page_slug === 'home') {
        update_post_meta($page_id, '_wp_page_template', 'template-homepage.php');
    }
}

launchpad_plugin_installed

Purpose: Execute code after each plugin installation.

Parameters:

• $plugin_slug (string): Installed plugin slug
• $plugin_status (bool): Installation success status

Example:

add_action('launchpad_plugin_installed', 'configure_plugin', 10, 2);

function configure_plugin($plugin_slug, $plugin_status) {
    if (!$plugin_status) {
        return; // Installation failed
    }

    // Configure specific plugins after installation
    switch ($plugin_slug) {
        case 'wordpress-seo':
            // Configure Yoast SEO
            update_option('wpseo_titles', array(
                'separator' => 'sc-dash'
            ));
            break;

        case 'contact-form-7':
            // Create default contact form
            create_default_contact_form();
            break;
    }
}

launchpad_theme_activated

Purpose: Execute code after theme activation during build.

Parameters:

• $theme_slug (string): Activated theme slug

Example:

add_action('launchpad_theme_activated', 'configure_theme', 10, 1);

function configure_theme($theme_slug) {
    if ($theme_slug === 'launchpad-bundle') {
        // Set theme mods
        set_theme_mod('header_layout', 'centered');
        set_theme_mod('footer_widgets', 3);
    }
}

launchpad_branding_applied

Purpose: Execute code after branding application.

Parameters:

• $branding_data (array): Applied branding configuration

Example:

add_action('launchpad_branding_applied', 'finalize_branding', 10, 1);

function finalize_branding($branding_data) {
    // Generate custom CSS file
    $css = generate_custom_css($branding_data);
    file_put_contents(
        get_stylesheet_directory() . '/custom-branding.css',
        $css
    );
}

REST API Endpoints Reference

LaunchPad exposes REST API endpoints for wizard functionality. Useful for custom integrations.

GET /wp-json/launchpad/v1/recipes

Purpose: Retrieve available recipes list.

Response:

{
  "success": true,
  "data": [
    {
      "site_type": "blog",
      "name": "Blog / News Site",
      "description": "...",
      "icon": "dashicons-admin-post"
    }
  ]
}

POST /wp-json/launchpad/v1/wizard/build

Purpose: Trigger site build with recipe.

Request Body:

{
  "recipe": "business",
  "branding": {
    "site_name": "My Business",
    "primary_color": "#2563EB"
  }
}

Response:

{
  "success": true,
  "message": "Site built successfully",
  "data": {
    "pages_created": 5,
    "plugins_installed": 3
  }
}

POST /wp-json/launchpad/v1/wizard/reset

Purpose: Reset/remove LaunchPad-created content.

Response:

{
  "success": true,
  "message": "Site reset successfully"
}

Helper Functions Reference

LaunchPad provides utility functions for common tasks.

LaunchPad\Utils\Helpers::is_pro_active()

Purpose: Check if Pro version is active.

Returns: bool

Example:

if (\LaunchPad\Utils\Helpers::is_pro_active()) {
    // Pro-only functionality
}

LaunchPad\Utils\Helpers::get_recipe($slug)

Purpose: Retrieve recipe data by slug.

Parameters:

• $slug (string): Recipe identifier

Returns: array|false Recipe data or false if not found

Example:

$recipe = \LaunchPad\Utils\Helpers::get_recipe('business');
if ($recipe) {
    echo $recipe['name']; // "Business Site"
}

LaunchPad\Utils\Logger::log($message, $type, $data)

Purpose: Add entry to LaunchPad activity log.

Parameters:

• $message (string): Log message
• $type (string): Log type (info, error, warning, success)
• $data (array): Additional context data

Example:

\LaunchPad\Utils\Logger::log(
    'Custom recipe deployed',
    'success',
    array('recipe' => 'medical', 'pages' => 5)
);

Best Practices for LaunchPad API Reference Usage

Follow these guidelines when using the LaunchPad API.

Use Specific Hook Priorities

Control execution order with priorities:

// Run before other hooks (priority 5)
add_action('launchpad_after_recipe_build', 'early_setup', 5, 2);

// Run after other hooks (priority 20)
add_action('launchpad_after_recipe_build', 'late_setup', 20, 2);

Always Return Filtered Values

Filters must return values:

// CORRECT
add_filter('launchpad_plugin_list', function($plugins) {
    $plugins[] = 'new-plugin';
    return $plugins; // Must return
});

// WRONG - doesn't return
add_filter('launchpad_plugin_list', function($plugins) {
    $plugins[] = 'new-plugin';
    // Missing return!
});

Check Conditions Before Acting

Verify context before executing:

add_action('launchpad_page_created', 'my_function', 10, 3);

function my_function($page_id, $page_slug, $recipe_slug) {
    // Check specific conditions
    if ($page_slug !== 'home' || $recipe_slug !== 'business') {
        return; // Don't run for other pages/recipes
    }

    // Your code here
}

Namespace Custom Functions

Avoid naming conflicts:

// Good - prefixed
function mycompany_custom_recipe() { }

// Better - namespaced
namespace MyCompany\LaunchPad;
function custom_recipe() { }

Key Takeaways

• LaunchPad API reference provides launchpad_custom_recipes filter for adding recipes, launchpad_after_recipe_build action for post-build customization, and REST API endpoints for programmatic control
• Always use filters (return modified values) vs actions (execute code without return) appropriately; filters modify data, actions perform operations
• Best practices include setting specific hook priorities, checking conditions before execution, and namespacing custom functions to avoid conflicts

Extend LaunchPad Systematically

You’ve learned comprehensive LaunchPad API documentation covering filters, actions, REST endpoints, helper functions, and best practices. Using these documented APIs ensures your customizations survive updates while enabling powerful extensions.

Whether building custom recipes, integrating with third-party plugins, or creating client-specific functionality, the LaunchPad API provides clean, maintainable extension points.

Ready to build on LaunchPad? Explore the LaunchPad GitHub repository for complete source code and additional examples. For Pro API features and advanced integrations, explore LaunchPad Pro.

The post LaunchPad API Reference: Hooks, Filters, and Actions Guide appeared first on LaunchPad.

WordPress custom post types power sophisticated websites beyond blogs and brochure sites. According to WordPress development surveys, 73% of complex WordPress sites use custom post types for specialized content. LaunchPad custom post types integration requires understanding both WordPress CPT APIs and LaunchPad’s extensibility hooks.

This advanced developer guide reveals complete custom post type integration including registering custom post types in recipes, taxonomy implementation for organization, Advanced Custom Fields integration, LaunchPad theme template hierarchy, WooCommerce e-commerce integration, and portfolio and directory site patterns. Master these techniques and you’ll build sophisticated websites extending far beyond LaunchPad’s default capabilities.

Understanding Custom Post Types

Before integrating with LaunchPad, understand WordPress custom post type fundamentals.

What Are Custom Post Types

WordPress includes default post types: posts (blog articles), pages (static content), attachments (media), revisions (content history).

Custom post types add specialized content: portfolios (design work, case studies), testimonials (client reviews with structured fields), team members (staff profiles with contact info), products (e-commerce items), events (calendar listings), properties (real estate listings).

Each custom post type operates like posts/pages but with specific fields, taxonomies, and templates.

When to Use Custom Post Types

Use CPTs for content that: repeats with consistent structure (all team members have name, title, bio, photo), needs special organization (taxonomies like project-type, skill), requires custom fields (testimonial author, company, rating), displays differently than posts/pages (portfolio grid vs. blog list).

Don’t create CPTs for: one-time unique content (use pages), simple lists (use posts with categories), data better suited for plugins (forms, bookings).

Custom Post Types in LaunchPad Context

LaunchPad recipes can: include CPT registration code, create sample CPT content, configure CPT taxonomies, set up CPT templates in theme.

Integration requires both PHP (registration) and theme support (templates).

Registering Custom Post Types for LaunchPad

Multiple approaches exist for LaunchPad custom post types registration.

Plugin-Based Registration (Recommended)

Best practice: create dedicated plugin for CPT registration. This separates functionality from theme, surviving theme changes.

Example plugin structure:

<?php
/**
 * Plugin Name: LaunchPad Custom Post Types
 * Description: Adds Portfolio, Testimonials, and Team CPTs
 * Version: 1.0.0
 */

// Register Portfolio CPT
function launchpad_register_portfolio() {
    $args = array(
        'public' => true,
        'label' => 'Portfolio',
        'labels' => array(
            'name' => 'Portfolio',
            'singular_name' => 'Portfolio Item',
            'add_new_item' => 'Add New Project'
        ),
        'supports' => array('title', 'editor', 'thumbnail', 'excerpt'),
        'has_archive' => true,
        'rewrite' => array('slug' => 'portfolio'),
        'show_in_rest' => true,
        'menu_icon' => 'dashicons-portfolio'
    );
    register_post_type('portfolio', $args);
}
add_action('init', 'launchpad_register_portfolio');

Recipe-Triggered Registration

Alternative: trigger CPT registration only when specific recipe is used:

add_action('launchpad_after_recipe_build', 'activate_portfolio_cpt', 10, 2);

function activate_portfolio_cpt($recipe_slug, $branding_data) {
    if ($recipe_slug === 'portfolio') {
        // Activate CPT plugin or register CPT
        launchpad_register_portfolio();
        flush_rewrite_rules(); // Important!
    }
}

This activates LaunchPad custom post types only for recipes needing them.

Functions.php Registration (Not Recommended)

Possible but problematic:

// In theme functions.php
add_action('init', 'theme_register_cpt');

Problem: Switching themes loses CPT registration, breaking content access. Always use plugin approach.

Taxonomy Implementation

Custom post types often need custom taxonomies for organization.

Creating Custom Taxonomies

Portfolio needs project categories and skills taxonomies:

function launchpad_register_portfolio_taxonomies() {
    // Project Categories
    register_taxonomy('project-category', 'portfolio', array(
        'hierarchical' => true,
        'label' => 'Project Categories',
        'show_in_rest' => true,
        'rewrite' => array('slug' => 'project-category')
    ));

    // Skills
    register_taxonomy('skill', 'portfolio', array(
        'hierarchical' => false, // Like tags
        'label' => 'Skills',
        'show_in_rest' => true,
        'rewrite' => array('slug' => 'skill')
    ));
}
add_action('init', 'launchpad_register_portfolio_taxonomies');

Hierarchical taxonomies work like categories (parent/child). Non-hierarchical work like tags.

Taxonomy Integration with LaunchPad

Create default taxonomy terms during recipe build:

add_action('launchpad_after_recipe_build', 'create_portfolio_terms', 10, 2);

function create_portfolio_terms($recipe_slug, $branding_data) {
    if ($recipe_slug === 'portfolio') {
        $categories = ['Web Design', 'Brand Identity', 'UI/UX', 'Development'];
        foreach ($categories as $category) {
            if (!term_exists($category, 'project-category')) {
                wp_insert_term($category, 'project-category');
            }
        }

        $skills = ['Photoshop', 'Illustrator', 'WordPress', 'React'];
        foreach ($skills as $skill) {
            if (!term_exists($skill, 'skill')) {
                wp_insert_term($skill, 'skill');
            }
        }
    }
}

Users get pre-populated taxonomies, ready to use.

Advanced Custom Fields Integration

Custom fields add structured data to LaunchPad custom post types.

ACF Plugin Configuration

Advanced Custom Fields (ACF) provides GUI for custom field management. Better than manual meta box coding for most use cases.

Example: Testimonial CPT with ACF fields:

// Register Testimonial CPT
function launchpad_register_testimonials() {
    register_post_type('testimonial', array(
        'public' => true,
        'label' => 'Testimonials',
        'supports' => array('title', 'editor', 'thumbnail'),
        'menu_icon' => 'dashicons-format-quote'
    ));
}
add_action('init', 'launchpad_register_testimonials');

Then configure ACF field group (via UI or code): Client Name (text), Company (text), Position (text), Website (URL), Rating (number 1-5), Featured (true/false).

Programmatic ACF Field Registration

For LaunchPad custom post types recipes, register ACF fields programmatically:

add_action('acf/init', 'launchpad_register_testimonial_fields');

function launchpad_register_testimonial_fields() {
    acf_add_local_field_group(array(
        'key' => 'group_testimonial',
        'title' => 'Testimonial Details',
        'fields' => array(
            array(
                'key' => 'field_client_name',
                'label' => 'Client Name',
                'name' => 'client_name',
                'type' => 'text',
                'required' => 1,
            ),
            array(
                'key' => 'field_company',
                'label' => 'Company',
                'name' => 'company',
                'type' => 'text',
            ),
            array(
                'key' => 'field_rating',
                'label' => 'Rating',
                'name' => 'rating',
                'type' => 'number',
                'min' => 1,
                'max' => 5,
            ),
        ),
        'location' => array(
            array(
                array(
                    'param' => 'post_type',
                    'operator' => '==',
                    'value' => 'testimonial',
                ),
            ),
        ),
    ));
}

Fields appear automatically when editing testimonials.

Displaying ACF Data in Templates

Access ACF fields in templates:

// In single-testimonial.php or archive
$client_name = get_field('client_name');
$company = get_field('company');
$rating = get_field('rating');

echo '<h2>' . esc_html($client_name) . '</h2>';
echo '<p>' . esc_html($company) . '</p>';
echo '<div class="rating">' . str_repeat('⭐', $rating) . '</div>';

Theme Template Hierarchy

WordPress uses template hierarchy for displaying custom post types. LaunchPad Bundle theme should support common CPT templates.

Required Template Files

For portfolio CPT, create: archive-portfolio.php (portfolio listing page), single-portfolio.php (individual project page), taxonomy-project-category.php (category archive), taxonomy-skill.php (skill archive).

Template Example: Portfolio Archive

<?php
/**
 * Template: archive-portfolio.php
 * Portfolio Archive Page
 */

get_header(); ?>

<div class="portfolio-archive">
    <h1><?php post_type_archive_title(); ?></h1>

    <div class="portfolio-grid">
        <?php if (have_posts()) : while (have_posts()) : the_post(); ?>
            <article class="portfolio-item">
                <?php if (has_post_thumbnail()) : ?>
                    <a href="<?php the_permalink(); ?>">
                        <?php the_post_thumbnail('medium'); ?>
                    </a>
                <?php endif; ?>

                <h2><a href="<?php the_permalink(); ?>"><?php the_title(); ?></a></h2>

                <?php
                $categories = get_the_terms(get_the_ID(), 'project-category');
                if ($categories) :
                    echo '<div class="project-categories">';
                    foreach ($categories as $category) {
                        echo '<span>' . esc_html($category->name) . '</span> ';
                    }
                    echo '</div>';
                endif;
                ?>

                <?php the_excerpt(); ?>
            </article>
        <?php endwhile; endif; ?>
    </div>

    <?php the_posts_pagination(); ?>
</div>

<?php get_footer(); ?>

LaunchPad Theme Integration

Ensure LaunchPad Bundle theme includes CPT templates or document how users add them via child theme.

WooCommerce Integration

E-commerce recipes need WooCommerce, WordPress’s most popular shop plugin.

Including WooCommerce in Recipes

Add WooCommerce to recipe plugins array:

"plugins": ["woocommerce", "wordpress-seo", "contact-form-7"]

LaunchPad installs and activates WooCommerce.

Post-Installation WooCommerce Setup

WooCommerce requires setup wizard. Automate via LaunchPad hooks:

add_action('launchpad_after_recipe_build', 'setup_woocommerce', 10, 2);

function setup_woocommerce($recipe_slug, $branding_data) {
    if ($recipe_slug === 'ecommerce') {
        // Mark WooCommerce setup as complete
        update_option('woocommerce_onboarding_profile', array(
            'completed' => true
        ));

        // Set default currency
        update_option('woocommerce_currency', 'USD');

        // Create default pages if they don't exist
        WC_Install::create_pages();

        // Configure payment methods
        // Configure shipping methods
        // Set tax settings
    }
}

Product Import

Create sample products for e-commerce recipes:

function launchpad_create_sample_products() {
    $sample_products = array(
        array(
            'title' => 'Sample Product 1',
            'description' => 'This is a sample product',
            'price' => '29.99',
            'sku' => 'SAMPLE-001'
        ),
        // More products...
    );

    foreach ($sample_products as $product_data) {
        $product = new WC_Product_Simple();
        $product->set_name($product_data['title']);
        $product->set_description($product_data['description']);
        $product->set_regular_price($product_data['price']);
        $product->set_sku($product_data['sku']);
        $product->save();
    }
}

Portfolio and Directory Site Patterns

Common use cases for LaunchPad custom post types.

Portfolio Site Implementation

Full portfolio site needs: portfolio CPT with project categories and skills, single project template with galleries, filterable portfolio grid, case study layout, client testimonials integration.

Package as complete solution in custom recipe.

Directory Site Implementation

Directory (business listings, member directory, resource database) needs: directory CPT (listings), location taxonomy (geographic organization), category taxonomy (listing types), custom fields (address, phone, website, hours), search and filtering, Google Maps integration.

More complex than portfolio but follows same patterns.

Key Takeaways

• LaunchPad custom post types should be registered via dedicated plugin (not theme functions.php) to survive theme changes and maintain content access
• Integrate CPTs with recipes using launchpad_after_recipe_build hook to register post types, taxonomies, and create default terms programmatically
• Advanced Custom Fields (ACF) provides GUI-based custom field management; register fields programmatically for recipe deployments ensuring consistent structure

Extend LaunchPad for Advanced Content

You’ve learned comprehensive techniques for integrating LaunchPad custom post types covering CPT registration, taxonomy implementation, ACF integration, template development, and WooCommerce e-commerce. These techniques enable sophisticated websites far beyond standard blogs and brochure sites.

Whether building portfolios, directories, e-commerce stores, or specialized content platforms, custom post types integrated with LaunchPad provide scalable, maintainable solutions.

Ready to build advanced LaunchPad integrations? Study the WordPress Custom Post Type documentation and experiment with recipe extensions. For Pro features supporting advanced content types, explore LaunchPad Pro.

The post Extending LaunchPad with Custom Post Types and Advanced Content appeared first on LaunchPad.

The recipe system is extensible by design—developers can add unlimited custom recipes that appear alongside built-in options. According to WordPress developer surveys, 68% of developers customize plugins for client-specific needs. LaunchPad makes customization systematic through documented APIs and filters.

This advanced developer guide reveals complete custom LaunchPad recipes creation including recipe JSON format and structure, PHP hooks and filters available, custom page template implementation, branding field configuration, plugin and theme recommendations, content template variables, and distribution methods. Master these concepts and you’ll create specialized recipes solving specific industry problems.

Understanding Recipe Structure

Before creating custom recipes, understand how LaunchPad processes recipe data during site setup.

Recipe File Location

LaunchPad loads recipes from: launchpad-lite/recipes/ (built-in free recipes), launchpad-pro/recipes/ (built-in Pro recipes), custom plugin via launchpad_custom_recipes filter (developer recipes).

The filter approach is cleanest—create dedicated plugin containing custom recipes, avoiding core plugin modifications.

JSON Recipe Format

Recipes are JSON files with standardized structure:

{
  "site_type": "real-estate",
  "name": "Real Estate Agency",
  "description": "Complete real estate website with property listings",
  "icon": "dashicons-admin-home",
  "category": "business",
  "pro_only": false,
  "theme": "launchpad-bundle",
  "theme_options": { },
  "plugins": ["wordpress-seo", "contact-form-7"],
  "pages": ["home", "listings", "about", "contact"],
  "options": { },
  "features": [ ],
  "branding": { },
  "content_templates": { },
  "branding_fields": [ ]
}

Each property serves specific purpose in site generation.

Required vs. Optional Fields

Required recipe properties: site_type (unique identifier, slug format), name (display name in wizard), description (shown to users), pages (array of pages to create).

Optional but recommended: icon (Dashicon class for visual identification), category (grouping in UI), theme (recommended theme), plugins (recommended plugins list), theme_options (Customizer preset values), branding_fields (custom input fields).

Pro-specific: pro_only (boolean, requires valid Pro license), AI-related properties (Pro feature configurations).

Creating Your First Custom Recipe

Step-by-step process for custom LaunchPad recipes development.

Recipe Planning Worksheet

Before coding, document: target industry/niche (who is this for?), unique requirements (what makes this different from standard recipes?), required pages (what pages does this site type need?), recommended plugins (what functionality is essential?), branding elements (what customization options should users have?).

Example: Real Estate Recipe planning: Target: real estate agents and agencies. Unique: property listings, agent profiles, IDX integration. Pages: home, listings, featured properties, agents, about, contact, testimonials. Plugins: IMPress Listings, Yoast Local SEO, WPForms. Branding: office location, license numbers, MLS affiliations.

Creating Recipe JSON File

Create real-estate.json in your custom plugin:

{
  "site_type": "real-estate",
  "name": "Real Estate Agency",
  "description": "Professional real estate website with property listings, agent profiles, and lead generation forms. Optimized for real estate professionals and agencies.",
  "icon": "dashicons-admin-home",
  "category": "business",
  "pro_only": false,
  "theme": "launchpad-bundle",
  "plugins": [
    "wordpress-seo",
    "contact-form-7",
    "impress-listings"
  ],
  "pages": [
    "home",
    "listings",
    "featured-properties",
    "our-agents",
    "about",
    "contact",
    "testimonials"
  ]
}

Start simple. Add complexity incrementally.

Registering Recipe via Filter

Create plugin to register your recipe:

<?php
/**
 * Plugin Name: Custom LaunchPad Recipes
 * Description: Adds real estate recipe to LaunchPad
 * Version: 1.0.0
 */

add_filter('launchpad_custom_recipes', 'add_real_estate_recipe');

function add_real_estate_recipe($recipes) {
    $recipe_file = plugin_dir_path(__FILE__) . 'recipes/real-estate.json';

    if (file_exists($recipe_file)) {
        $recipe_data = json_decode(file_get_contents($recipe_file), true);
        if ($recipe_data) {
            $recipes[] = $recipe_data;
        }
    }

    return $recipes;
}

Activate plugin, your custom LaunchPad recipe appears in wizard.

Advanced Recipe Features

Beyond basic structure, recipes support advanced customization.

Theme Options Configuration

Pre-configure Customizer settings via theme_options:

"theme_options": {
  "primary_color": "#2563EB",
  "secondary_color": "#7C3AED",
  "hero_layout": "split",
  "show_breadcrumbs": true,
  "homepage_sections": {
    "hero": true,
    "services": true,
    "testimonials": true,
    "cta": true
  }
}

These apply automatically during setup, configuring theme without manual Customizer work.

Content Templates with Variables

Define page content templates using variables replaced during setup:

"content_templates": {
  "home": {
    "title": "Find Your Dream Home with {{site_name}}",
    "content": "<p>Welcome to {{site_name}}, your trusted real estate partner in {{city}}. We specialize in helping you find the perfect home.</p>"
  }
}

Variables like {{site_name}}, {{city}}, {{tagline}} get replaced with user-provided values.

Custom Branding Fields

Collect industry-specific information via branding fields:

"branding_fields": [
  {
    "id": "office_location",
    "label": "Office Location",
    "type": "text",
    "placeholder": "123 Main St, City, State",
    "required": true
  },
  {
    "id": "license_number",
    "label": "Real Estate License Number",
    "type": "text",
    "required": false
  },
  {
    "id": "mls_affiliation",
    "label": "MLS Affiliation",
    "type": "select",
    "options": ["NCAR", "GCAR", "TCAR"],
    "required": false
  }
]

These fields appear in wizard, values accessible via get_option('launchpad_branding_data').

PHP Hooks and Filters

LaunchPad provides hooks for programmatic recipe customization.

Available Filter Hooks

Key filters for custom LaunchPad recipes: launchpad_custom_recipes (add recipes), launchpad_recipe_data (modify recipe before processing), launchpad_page_content (customize generated page content), launchpad_plugin_list (modify recommended plugins), launchpad_theme_options (adjust theme settings).

Example modifying recipe data:

add_filter('launchpad_recipe_data', 'customize_recipe_for_client', 10, 2);

function customize_recipe_for_client($recipe_data, $recipe_slug) {
    if ($recipe_slug === 'real-estate') {
        // Add client-specific plugin
        $recipe_data['plugins'][] = 'custom-idx-integration';
    }
    return $recipe_data;
}

Action Hooks

Available actions: launchpad_before_recipe_build (runs before site generation), launchpad_after_recipe_build (runs after completion), launchpad_page_created (runs after each page creation), launchpad_plugin_installed (runs after each plugin installation).

Example post-build actions:

add_action('launchpad_after_recipe_build', 'setup_real_estate_data', 10, 2);

function setup_real_estate_data($recipe_slug, $branding_data) {
    if ($recipe_slug === 'real-estate') {
        // Create sample listings
        // Configure IDX settings
        // Set up lead capture forms
    }
}

Page Template System

Recipes define which pages to create. Control page content via templates.

Page Slug Definitions

Pages array in JSON uses slugs: "pages": ["home", "services", "about", "contact"]

LaunchPad matches slugs to internal templates. For custom pages, provide content via content_templates.

Custom Page Content

Define custom page content in recipe:

"content_templates": {
  "featured-properties": {
    "title": "Featured Properties",
    "content": "<p>Browse our hand-picked selection of exceptional properties.</p>[property_listings featured='true']",
    "template": "page-properties.php"
  }
}

Supports shortcodes, HTML, variables.

Template Hierarchy

LaunchPad checks for page templates in order: recipe content_templates definition, theme-specific template file, LaunchPad default template, WordPress default page.

Create theme templates matching recipe pages for full control.

Plugin and Theme Recommendations

Recipes recommend plugins and themes. Users can accept or decline.

Plugin Array Format

Specify plugins by slug: "plugins": ["wordpress-seo", "contact-form-7", "impress-listings"]

LaunchPad attempts installation from WordPress.org. For custom plugins, use hooks to handle installation differently.

Required vs. Optional Plugins

Distinguish plugin importance:

"plugins": {
  "required": ["wordpress-seo", "contact-form-7"],
  "recommended": ["impress-listings", "wpforms-lite"],
  "optional": ["elementor", "wp-rocket"]
}

(Note: This extended format requires custom handling via filters)

Theme Specifications

Recommend specific themes: "theme": "launchpad-bundle" (default), "theme": "astra" (WordPress.org theme), "theme": "custom-real-estate-theme" (custom theme).

LaunchPad attempts theme installation if not already available.

Distribution Methods

Share custom LaunchPad recipes with clients or community.

Plugin Distribution

Package recipes in standalone plugins: create plugin with recipes in /recipes/ folder, register via launchpad_custom_recipes filter, distribute as zip file or via WordPress.org.

This keeps recipes separate from LaunchPad core, making updates manageable.

Recipe Marketplace Potential

Developers could create: niche-specific recipe plugins, industry template collections, client-specific recipe packages for agencies.

Distribute via WordPress.org, sell via marketplaces, or provide client-exclusive.

Open Source Contributions

Contribute recipes to LaunchPad project via GitHub pull requests. Widely useful recipes may be included in core or Pro versions.

Key Takeaways

• Custom LaunchPad recipes use JSON format with required fields (site_type, name, description, pages) and optional advanced features (theme_options, branding_fields, content_templates)
• Register recipes via launchpad_custom_recipes filter in custom plugin, avoiding core modifications and enabling clean distribution
• Advanced features include PHP hooks for programmatic customization (launchpad_after_recipe_build), custom branding fields, and content templates with variable replacement

Extend LaunchPad for Your Needs

You’ve learned comprehensive custom LaunchPad recipes development covering JSON structure, PHP integration, advanced features, and distribution methods. Creating custom recipes unlocks LaunchPad for specialized industries and unique client requirements.

Whether building recipes for your agency’s niche, creating client-specific solutions, or contributing to the community, the recipe system provides flexible, documented APIs.

Ready to create custom recipes? Study the LaunchPad GitHub repository for complete code examples and contribute your recipes back to the community. For Pro features and advanced recipe capabilities, explore LaunchPad Pro.

The post Creating Custom LaunchPad Recipes: Complete Developer Guide appeared first on LaunchPad.