This developer guide shows you how to extend Nexus Pro’s entity templates, add custom meta fields, integrate with schema output, and create admin interfaces for your custom data.

Understanding Nexus Pro Architecture

Foundation for safe extensions.

Entity Template Structure

Three Custom Post Types:

1. Person (nexus_person):

• Name, job title, bio
• Social profiles
• Contact information
• Person schema markup

2. Product (nexus_product):

• Product name, description
• Price, availability
• Images, SKU
• Product schema markup

3. Place (nexus_place):

• Business name, type
• Address, coordinates
• Hours, contact
• LocalBusiness schema markup

Hook System

Nexus Pro provides hooks for:

• Adding meta fields to admin
• Saving custom meta data
• Filtering schema output
• Modifying entity queries
• Extending admin interfaces

Hook Naming Convention:

nexus_pro_{entity}_{action}

Examples:

• nexus_pro_person_meta_fields
• nexus_pro_product_schema
• nexus_pro_place_save_meta

Adding Custom Fields to Person Entity

Extend Person template with additional fields.

Register Custom Meta Fields

Add Fields to Admin:

/**
 * Add custom fields to Person entity edit screen.
 */
function add_custom_person_fields($post) {
    // Get current values
    $linkedin = get_post_meta($post->ID, 'linkedin_url', true);
    $github = get_post_meta($post->ID, 'github_url', true);
    $expertise = get_post_meta($post->ID, 'expertise_areas', true);
    ?>
    <div class="nexus-pro-custom-fields">
        <h3>Additional Professional Information</h3>

        <p>
            <label for="linkedin_url">LinkedIn Profile:</label><br>
            <input type="url" id="linkedin_url" name="linkedin_url"
                   value="<?php echo esc_attr($linkedin); ?>"
                   class="widefat" placeholder="https://linkedin.com/in/username">
        </p>

        <p>
            <label for="github_url">GitHub Profile:</label><br>
            <input type="url" id="github_url" name="github_url"
                   value="<?php echo esc_attr($github); ?>"
                   class="widefat" placeholder="https://github.com/username">
        </p>

        <p>
            <label for="expertise_areas">Expertise Areas (comma-separated):</label><br>
            <input type="text" id="expertise_areas" name="expertise_areas"
                   value="<?php echo esc_attr($expertise); ?>"
                   class="widefat" placeholder="WordPress, PHP, JavaScript">
        </p>
    </div>
    <?php
}
add_action('nexus_pro_person_meta_fields', 'add_custom_person_fields');

Save Custom Meta Data

Hook Into Save Process:

/**
 * Save custom Person meta fields.
 */
function save_custom_person_meta($post_id) {
    // Security checks
    if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
        return;
    }

    if (!current_user_can('edit_post', $post_id)) {
        return;
    }

    // Verify post type
    if (get_post_type($post_id) !== 'nexus_person') {
        return;
    }

    // Save LinkedIn URL
    if (isset($_POST['linkedin_url'])) {
        update_post_meta(
            $post_id,
            'linkedin_url',
            esc_url_raw($_POST['linkedin_url'])
        );
    }

    // Save GitHub URL
    if (isset($_POST['github_url'])) {
        update_post_meta(
            $post_id,
            'github_url',
            esc_url_raw($_POST['github_url'])
        );
    }

    // Save expertise areas
    if (isset($_POST['expertise_areas'])) {
        $expertise = sanitize_text_field($_POST['expertise_areas']);
        update_post_meta($post_id, 'expertise_areas', $expertise);
    }
}
add_action('save_post_nexus_person', 'save_custom_person_meta');

Add to Person Schema

Extend Schema Output:

/**
 * Add custom fields to Person schema.
 */
function extend_person_schema($schema, $post_id) {
    // Add LinkedIn to sameAs
    $linkedin = get_post_meta($post_id, 'linkedin_url', true);
    if ($linkedin) {
        if (!isset($schema['sameAs'])) {
            $schema['sameAs'] = [];
        }
        $schema['sameAs'][] = $linkedin;
    }

    // Add GitHub to sameAs
    $github = get_post_meta($post_id, 'github_url', true);
    if ($github) {
        if (!isset($schema['sameAs'])) {
            $schema['sameAs'] = [];
        }
        $schema['sameAs'][] = $github;
    }

    // Add expertise as knowsAbout
    $expertise = get_post_meta($post_id, 'expertise_areas', true);
    if ($expertise) {
        $areas = array_map('trim', explode(',', $expertise));
        $schema['knowsAbout'] = $areas;
    }

    return $schema;
}
add_filter('nexus_pro_person_schema', 'extend_person_schema', 10, 2);

Adding Custom Fields to Product Entity

Extend Product template.

Product Meta Fields

Additional Product Data:

/**
 * Add custom fields to Product entity.
 */
function add_custom_product_fields($post) {
    $dimensions = get_post_meta($post->ID, 'product_dimensions', true);
    $weight = get_post_meta($post->ID, 'product_weight', true);
    $material = get_post_meta($post->ID, 'product_material', true);
    $warranty = get_post_meta($post->ID, 'warranty_period', true);
    ?>
    <div class="nexus-pro-product-specs">
        <h3>Product Specifications</h3>

        <p>
            <label for="product_dimensions">Dimensions (L x W x H in cm):</label><br>
            <input type="text" id="product_dimensions" name="product_dimensions"
                   value="<?php echo esc_attr($dimensions); ?>"
                   placeholder="30 x 20 x 15">
        </p>

        <p>
            <label for="product_weight">Weight (kg):</label><br>
            <input type="number" id="product_weight" name="product_weight"
                   value="<?php echo esc_attr($weight); ?>"
                   step="0.01" min="0">
        </p>

        <p>
            <label for="product_material">Material:</label><br>
            <input type="text" id="product_material" name="product_material"
                   value="<?php echo esc_attr($material); ?>"
                   placeholder="Stainless Steel">
        </p>

        <p>
            <label for="warranty_period">Warranty Period (months):</label><br>
            <input type="number" id="warranty_period" name="warranty_period"
                   value="<?php echo esc_attr($warranty); ?>"
                   min="0">
        </p>
    </div>
    <?php
}
add_action('nexus_pro_product_meta_fields', 'add_custom_product_fields');

Save Product Meta

/**
 * Save custom Product meta fields.
 */
function save_custom_product_meta($post_id) {
    if (get_post_type($post_id) !== 'nexus_product') {
        return;
    }

    $fields = [
        'product_dimensions' => 'sanitize_text_field',
        'product_weight' => 'floatval',
        'product_material' => 'sanitize_text_field',
        'warranty_period' => 'absint'
    ];

    foreach ($fields as $field => $sanitize_callback) {
        if (isset($_POST[$field])) {
            $value = call_user_func($sanitize_callback, $_POST[$field]);
            update_post_meta($post_id, $field, $value);
        }
    }
}
add_action('save_post_nexus_product', 'save_custom_product_meta');

Extend Product Schema

/**
 * Add specifications to Product schema.
 */
function extend_product_schema($schema, $post_id) {
    // Add dimensions
    $dimensions = get_post_meta($post_id, 'product_dimensions', true);
    if ($dimensions) {
        $schema['depth'] = [
            '@type' => 'QuantitativeValue',
            'value' => $dimensions
        ];
    }

    // Add weight
    $weight = get_post_meta($post_id, 'product_weight', true);
    if ($weight) {
        $schema['weight'] = [
            '@type' => 'QuantitativeValue',
            'value' => $weight,
            'unitCode' => 'KGM' // Kilograms
        ];
    }

    // Add material
    $material = get_post_meta($post_id, 'product_material', true);
    if ($material) {
        $schema['material'] = $material;
    }

    // Add warranty
    $warranty = get_post_meta($post_id, 'warranty_period', true);
    if ($warranty) {
        $schema['warranty'] = [
            '@type' => 'WarrantyPromise',
            'durationOfWarranty' => [
                '@type' => 'QuantitativeValue',
                'value' => $warranty,
                'unitCode' => 'MON' // Months
            ]
        ];
    }

    return $schema;
}
add_filter('nexus_pro_product_schema', 'extend_product_schema', 10, 2);

Adding Custom Fields to Place Entity

Extend LocalBusiness template.

Place Meta Fields

Business-Specific Data:

/**
 * Add custom fields to Place entity.
 */
function add_custom_place_fields($post) {
    $parking = get_post_meta($post->ID, 'parking_available', true);
    $accessibility = get_post_meta($post->ID, 'wheelchair_accessible', true);
    $payment_methods = get_post_meta($post->ID, 'payment_methods', true);
    $languages = get_post_meta($post->ID, 'languages_spoken', true);
    ?>
    <div class="nexus-pro-place-amenities">
        <h3>Business Amenities</h3>

        <p>
            <label>
                <input type="checkbox" name="parking_available" value="1"
                       <?php checked($parking, '1'); ?>>
                Parking Available
            </label>
        </p>

        <p>
            <label>
                <input type="checkbox" name="wheelchair_accessible" value="1"
                       <?php checked($accessibility, '1'); ?>>
                Wheelchair Accessible
            </label>
        </p>

        <p>
            <label>Payment Methods Accepted:</label><br>
            <select name="payment_methods[]" multiple size="5" class="widefat">
                <?php
                $methods = ['Cash', 'Credit Card', 'Debit Card', 'PayPal', 'Apple Pay', 'Google Pay'];
                $selected = is_array($payment_methods) ? $payment_methods : [];
                foreach ($methods as $method) {
                    $is_selected = in_array($method, $selected) ? 'selected' : '';
                    echo "<option value='" . esc_attr($method) . "' $is_selected>$method</option>";
                }
                ?>
            </select>
            <small>Hold Ctrl/Cmd to select multiple</small>
        </p>

        <p>
            <label>Languages Spoken:</label><br>
            <input type="text" name="languages_spoken"
                   value="<?php echo esc_attr($languages); ?>"
                   class="widefat" placeholder="English, Spanish, French">
        </p>
    </div>
    <?php
}
add_action('nexus_pro_place_meta_fields', 'add_custom_place_fields');

Save Place Meta

/**
 * Save custom Place meta fields.
 */
function save_custom_place_meta($post_id) {
    if (get_post_type($post_id) !== 'nexus_place') {
        return;
    }

    // Save checkboxes
    update_post_meta($post_id, 'parking_available',
        isset($_POST['parking_available']) ? '1' : '0');

    update_post_meta($post_id, 'wheelchair_accessible',
        isset($_POST['wheelchair_accessible']) ? '1' : '0');

    // Save payment methods array
    if (isset($_POST['payment_methods'])) {
        $methods = array_map('sanitize_text_field', $_POST['payment_methods']);
        update_post_meta($post_id, 'payment_methods', $methods);
    } else {
        delete_post_meta($post_id, 'payment_methods');
    }

    // Save languages
    if (isset($_POST['languages_spoken'])) {
        update_post_meta($post_id, 'languages_spoken',
            sanitize_text_field($_POST['languages_spoken']));
    }
}
add_action('save_post_nexus_place', 'save_custom_place_meta');

Extend LocalBusiness Schema

/**
 * Add amenities to LocalBusiness schema.
 */
function extend_place_schema($schema, $post_id) {
    // Add parking
    $parking = get_post_meta($post_id, 'parking_available', true);
    if ($parking === '1') {
        $schema['amenityFeature'][] = [
            '@type' => 'LocationFeatureSpecification',
            'name' => 'Parking',
            'value' => true
        ];
    }

    // Add accessibility
    $accessibility = get_post_meta($post_id, 'wheelchair_accessible', true);
    if ($accessibility === '1') {
        $schema['amenityFeature'][] = [
            '@type' => 'LocationFeatureSpecification',
            'name' => 'Wheelchair Accessible',
            'value' => true
        ];
    }

    // Add payment methods
    $payment_methods = get_post_meta($post_id, 'payment_methods', true);
    if (is_array($payment_methods) && !empty($payment_methods)) {
        $schema['paymentAccepted'] = implode(', ', $payment_methods);
    }

    // Add languages
    $languages = get_post_meta($post_id, 'languages_spoken', true);
    if ($languages) {
        $lang_array = array_map('trim', explode(',', $languages));
        $schema['availableLanguage'] = $lang_array;
    }

    return $schema;
}
add_filter('nexus_pro_place_schema', 'extend_place_schema', 10, 2);

Creating Custom Meta Boxes

Professional admin interfaces.

Meta Box with Tabs

Organized Field Groups:

/**
 * Register tabbed meta box.
 */
function register_tabbed_meta_box() {
    add_meta_box(
        'nexus_pro_extended_meta',
        'Extended Information',
        'render_tabbed_meta_box',
        ['nexus_person', 'nexus_product', 'nexus_place'],
        'normal',
        'high'
    );
}
add_action('add_meta_boxes', 'register_tabbed_meta_box');

/**
 * Render tabbed interface.
 */
function render_tabbed_meta_box($post) {
    wp_nonce_field('save_extended_meta', 'extended_meta_nonce');
    ?>
    <div class="nexus-pro-tabs">
        <ul class="tab-nav">
            <li><a href="#tab-basic" class="active">Basic Info</a></li>
            <li><a href="#tab-advanced">Advanced</a></li>
            <li><a href="#tab-schema">Schema Data</a></li>
        </ul>

        <div id="tab-basic" class="tab-content active">
            <?php render_basic_fields($post); ?>
        </div>

        <div id="tab-advanced" class="tab-content">
            <?php render_advanced_fields($post); ?>
        </div>

        <div id="tab-schema" class="tab-content">
            <?php render_schema_fields($post); ?>
        </div>
    </div>

    <style>
        .tab-nav { list-style: none; margin: 0; padding: 0; border-bottom: 1px solid #ccc; }
        .tab-nav li { display: inline-block; margin: 0; }
        .tab-nav a { display: block; padding: 10px 15px; text-decoration: none; border: 1px solid #ccc; border-bottom: none; background: #f1f1f1; }
        .tab-nav a.active { background: #fff; }
        .tab-content { display: none; padding: 20px; border: 1px solid #ccc; border-top: none; }
        .tab-content.active { display: block; }
    </style>

    <script>
    jQuery(document).ready(function($) {
        $('.tab-nav a').click(function(e) {
            e.preventDefault();
            $('.tab-nav a, .tab-content').removeClass('active');
            $(this).addClass('active');
            $($(this).attr('href')).addClass('active');
        });
    });
    </script>
    <?php
}

Repeatable Fields

Dynamic Field Groups:

/**
 * Render repeatable fields (e.g., certifications).
 */
function render_repeatable_certifications($post) {
    $certifications = get_post_meta($post->ID, 'certifications', true);
    if (!is_array($certifications)) {
        $certifications = [];
    }
    ?>
    <div id="certifications-container">
        <h4>Certifications</h4>
        <div class="certifications-list">
            <?php
            if (empty($certifications)) {
                $certifications = [['name' => '', 'issuer' => '', 'date' => '']];
            }
            foreach ($certifications as $index => $cert) {
                ?>
                <div class="certification-item" data-index="<?php echo $index; ?>">
                    <input type="text" name="certifications[<?php echo $index; ?>][name]"
                           value="<?php echo esc_attr($cert['name'] ?? ''); ?>"
                           placeholder="Certification Name">
                    <input type="text" name="certifications[<?php echo $index; ?>][issuer]"
                           value="<?php echo esc_attr($cert['issuer'] ?? ''); ?>"
                           placeholder="Issuing Organization">
                    <input type="date" name="certifications[<?php echo $index; ?>][date]"
                           value="<?php echo esc_attr($cert['date'] ?? ''); ?>">
                    <button type="button" class="remove-certification">Remove</button>
                </div>
                <?php
            }
            ?>
        </div>
        <button type="button" id="add-certification">Add Certification</button>
    </div>

    <script>
    jQuery(document).ready(function($) {
        var certIndex = <?php echo count($certifications); ?>;

        $('#add-certification').click(function() {
            var html = '<div class="certification-item" data-index="' + certIndex + '">' +
                '<input type="text" name="certifications[' + certIndex + '][name]" placeholder="Certification Name">' +
                '<input type="text" name="certifications[' + certIndex + '][issuer]" placeholder="Issuing Organization">' +
                '<input type="date" name="certifications[' + certIndex + '][date]">' +
                '<button type="button" class="remove-certification">Remove</button>' +
                '</div>';
            $('.certifications-list').append(html);
            certIndex++;
        });

        $(document).on('click', '.remove-certification', function() {
            $(this).closest('.certification-item').remove();
        });
    });
    </script>
    <?php
}

Best Practices

Professional extension guidelines.

Use Proper Hook Priorities

// Default priority (10)
add_filter('nexus_pro_person_schema', 'extend_person_schema', 10, 2);

// Run late to ensure all other modifications are done
add_filter('nexus_pro_person_schema', 'final_person_adjustments', 999, 2);

Validate and Sanitize

// Always validate and sanitize user input
function save_custom_meta($post_id) {
    // URL validation
    if (isset($_POST['website'])) {
        $url = esc_url_raw($_POST['website']);
        if (filter_var($url, FILTER_VALIDATE_URL)) {
            update_post_meta($post_id, 'website', $url);
        }
    }

    // Email validation
    if (isset($_POST['email'])) {
        $email = sanitize_email($_POST['email']);
        if (is_email($email)) {
            update_post_meta($post_id, 'email', $email);
        }
    }

    // Number validation
    if (isset($_POST['price'])) {
        $price = floatval($_POST['price']);
        if ($price >= 0) {
            update_post_meta($post_id, 'price', $price);
        }
    }
}

Check for Empty Values

// Don't add empty fields to schema
function extend_schema_safely($schema, $post_id) {
    $custom_field = get_post_meta($post_id, 'custom_field', true);

    if (!empty($custom_field)) {
        $schema['customProperty'] = $custom_field;
    }

    return $schema;
}

Use Nonces for Security

// Add nonce to form
wp_nonce_field('save_custom_meta', 'custom_meta_nonce');

// Verify nonce when saving
function save_custom_meta($post_id) {
    if (!isset($_POST['custom_meta_nonce']) ||
        !wp_verify_nonce($_POST['custom_meta_nonce'], 'save_custom_meta')) {
        return;
    }

    // Proceed with saving
}

Document Your Extensions

/**
 * Extend Nexus Pro Person entity with professional certifications.
 *
 * Adds repeatable certification fields to Person entity admin interface
 * and includes them in Person schema output as credentials.
 *
 * @since 1.0.0
 * @param WP_Post $post The post object.
 */
function add_certification_fields($post) {
    // Implementation
}

Conclusion

Extending Nexus Pro through hooks and filters allows adding custom fields to entity templates while maintaining plugin compatibility. By understanding the hook system, implementing proper validation, and following WordPress development best practices, you can customize Nexus Pro for any project requirements.

Extension Checklist:

1. ✓ Use Nexus Pro hooks (not core files)
2. ✓ Add meta fields with action hooks
3. ✓ Save data securely with nonces
4. ✓ Validate and sanitize all input
5. ✓ Extend schema with filter hooks
6. ✓ Check for empty values
7. ✓ Test schema with validators
8. ✓ Document custom code
9. ✓ Prefix function names
10. ✓ Test with plugin updates

Available Hooks:

• nexus_pro_{entity}_meta_fields – Add fields to admin
• nexus_pro_{entity}_schema – Filter schema output
• save_post_nexus_{entity} – Save custom meta
• nexus_pro_{entity}_query – Modify entity queries

Start with simple single-field additions to understand the hook system, then progress to complex meta boxes, repeatable fields, and advanced schema integrations. Always test extensions after Nexus Pro updates to ensure compatibility.

Related Articles:

• WordPress Hooks and Filters Guide
• Custom Schema Types Tutorial
• Schema Markup: 7 Essential Types
• WordPress Plugin Development Best Practices

The post Extending Nexus Pro: Add Custom Fields to Entity Templates appeared first on Developry Themes.

This advanced guide shows you how to create custom schema types, extend existing schemas, implement complex nested structures, and validate your structured data for Google compatibility.

Understanding Schema.org Structure

Foundation knowledge for custom implementations.

Schema.org Hierarchy

Core Concept: Schema.org uses hierarchical types where specific types inherit properties from parent types.

Example Hierarchy:

Thing
└── CreativeWork
    └── Article
        └── NewsArticle
        └── BlogPosting
        └── TechArticle

Inheritance: NewsArticle inherits all properties from Article, CreativeWork, and Thing.

JSON-LD Format

Structure:

{
  "@context": "https://schema.org",
  "@type": "TypeName",
  "property1": "value1",
  "property2": "value2",
  "nestedObject": {
    "@type": "NestedType",
    "nestedProperty": "value"
  }
}

Key Elements:

• @context: Schema.org vocabulary
• @type: Schema type
• Properties: Type-specific attributes
• Values: Strings, numbers, objects, arrays

Common Schema Types

Available on Schema.org:

Organizations:

• Organization
• LocalBusiness
• Corporation
• EducationalOrganization

Creative Works:

• Article
• BlogPosting
• Book
• Movie
• MusicAlbum

Events:

• Event
• BusinessEvent
• SocialEvent

Products:

• Product
• SoftwareApplication
• Vehicle

People:

• Person

200+ types available: Check Schema.org for complete list.

Creating Basic Custom Schema

Implement custom schema from scratch.

Step 1: Choose Schema Type

Determine Type: Browse Schema.org to find appropriate type for your content.

Example: Creating SoftwareApplication schema for plugin documentation.

Step 2: Define Schema Structure

Plan Properties:

/**
 * SoftwareApplication schema properties:
 * - name: Application name
 * - applicationCategory: Category (e.g., "DeveloperApplication")
 * - operatingSystem: "WordPress"
 * - offers: Price/availability
 * - aggregateRating: User ratings
 */

Step 3: Create Schema Function

Implementation:

function custom_software_schema($post_id) {
    // Get post data
    $post = get_post($post_id);

    // Build schema array
    $schema = [
        '@context' => 'https://schema.org',
        '@type' => 'SoftwareApplication',
        'name' => get_the_title($post_id),
        'description' => get_the_excerpt($post_id),
        'applicationCategory' => 'DeveloperApplication',
        'operatingSystem' => 'WordPress',
        'offers' => [
            '@type' => 'Offer',
            'price' => get_post_meta($post_id, 'price', true),
            'priceCurrency' => 'USD',
            'availability' => 'https://schema.org/InStock'
        ],
        'aggregateRating' => [
            '@type' => 'AggregateRating',
            'ratingValue' => get_post_meta($post_id, 'rating', true),
            'reviewCount' => get_post_meta($post_id, 'review_count', true)
        ]
    ];

    return $schema;
}

Step 4: Output Schema

Add to WordPress:

function output_software_schema() {
    if (is_singular('plugin')) {
        $schema = custom_software_schema(get_the_ID());
        echo '<script type="application/ld+json">' .
             wp_json_encode($schema, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT) .
             '</script>';
    }
}
add_action('wp_head', 'output_software_schema');

Output:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Nexus Pro",
  ...
}
</script>

Extending Existing Schema

Add properties to Nexus Pro schemas.

Filter Nexus Pro Schema

Hook Into Schema Output:

// Add custom properties to Article schema
add_filter('nexus_pro_article_schema', 'extend_article_schema', 10, 2);

function extend_article_schema($schema, $post_id) {
    // Add wordCount property
    $content = get_post_field('post_content', $post_id);
    $word_count = str_word_count(strip_tags($content));
    $schema['wordCount'] = $word_count;

    // Add timeRequired for reading
    $minutes = ceil($word_count / 200); // 200 words per minute
    $schema['timeRequired'] = 'PT' . $minutes . 'M'; // ISO 8601 duration

    // Add inLanguage
    $schema['inLanguage'] = get_locale();

    // Add audience
    $difficulty = get_post_meta($post_id, 'difficulty_level', true);
    if ($difficulty) {
        $schema['audience'] = [
            '@type' => 'EducationalAudience',
            'educationalRole' => $difficulty // Beginner, Intermediate, Advanced
        ];
    }

    return $schema;
}

Add Nested Schemas

Complex Structures:

add_filter('nexus_pro_article_schema', 'add_citation_schema', 10, 2);

function add_citation_schema($schema, $post_id) {
    // Get cited sources from custom field
    $citations = get_post_meta($post_id, 'citations', true);

    if (!empty($citations)) {
        $schema['citation'] = [];

        foreach ($citations as $citation) {
            $schema['citation'][] = [
                '@type' => 'CreativeWork',
                'name' => $citation['title'],
                'url' => $citation['url'],
                'author' => [
                    '@type' => 'Person',
                    'name' => $citation['author']
                ]
            ];
        }
    }

    return $schema;
}

Advanced Schema Patterns

Complex implementations.

Breadcrumb Schema

Navigation Structure:

function generate_breadcrumb_schema() {
    if (!is_singular()) {
        return;
    }

    $breadcrumbs = [];
    $position = 1;

    // Home
    $breadcrumbs[] = [
        '@type' => 'ListItem',
        'position' => $position++,
        'name' => 'Home',
        'item' => home_url('/')
    ];

    // Categories
    $categories = get_the_category();
    if ($categories) {
        $category = $categories[0];
        $breadcrumbs[] = [
            '@type' => 'ListItem',
            'position' => $position++,
            'name' => $category->name,
            'item' => get_category_link($category->term_id)
        ];
    }

    // Current post
    $breadcrumbs[] = [
        '@type' => 'ListItem',
        'position' => $position,
        'name' => get_the_title(),
        'item' => get_permalink()
    ];

    $schema = [
        '@context' => 'https://schema.org',
        '@type' => 'BreadcrumbList',
        'itemListElement' => $breadcrumbs
    ];

    return $schema;
}

Recipe Schema

Detailed Cooking Instructions:

function create_recipe_schema($post_id) {
    $schema = [
        '@context' => 'https://schema.org',
        '@type' => 'Recipe',
        'name' => get_the_title($post_id),
        'image' => get_the_post_thumbnail_url($post_id, 'large'),
        'author' => [
            '@type' => 'Person',
            'name' => get_the_author_meta('display_name')
        ],
        'datePublished' => get_the_date('c', $post_id),
        'description' => get_the_excerpt($post_id),
        'prepTime' => 'PT' . get_post_meta($post_id, 'prep_time', true) . 'M',
        'cookTime' => 'PT' . get_post_meta($post_id, 'cook_time', true) . 'M',
        'totalTime' => 'PT' . get_post_meta($post_id, 'total_time', true) . 'M',
        'recipeYield' => get_post_meta($post_id, 'servings', true),
        'recipeCategory' => get_post_meta($post_id, 'category', true),
        'recipeCuisine' => get_post_meta($post_id, 'cuisine', true),
        'nutrition' => [
            '@type' => 'NutritionInformation',
            'calories' => get_post_meta($post_id, 'calories', true) . ' calories'
        ],
        'recipeIngredient' => get_post_meta($post_id, 'ingredients', true), // Array
        'recipeInstructions' => []
    ];

    // Build instructions
    $steps = get_post_meta($post_id, 'instructions', true);
    foreach ($steps as $index => $step) {
        $schema['recipeInstructions'][] = [
            '@type' => 'HowToStep',
            'name' => 'Step ' . ($index + 1),
            'text' => $step,
            'url' => get_permalink($post_id) . '#step-' . ($index + 1)
        ];
    }

    // Aggregate rating
    $rating = get_post_meta($post_id, 'rating', true);
    if ($rating) {
        $schema['aggregateRating'] = [
            '@type' => 'AggregateRating',
            'ratingValue' => $rating,
            'reviewCount' => get_post_meta($post_id, 'review_count', true)
        ];
    }

    return $schema;
}

Video Object Schema

YouTube/Vimeo Integration:

function create_video_schema($post_id) {
    $video_url = get_post_meta($post_id, 'video_url', true);

    if (empty($video_url)) {
        return null;
    }

    $schema = [
        '@context' => 'https://schema.org',
        '@type' => 'VideoObject',
        'name' => get_the_title($post_id),
        'description' => get_the_excerpt($post_id),
        'thumbnailUrl' => get_the_post_thumbnail_url($post_id, 'large'),
        'uploadDate' => get_the_date('c', $post_id),
        'duration' => 'PT' . get_post_meta($post_id, 'duration', true) . 'S', // seconds
        'contentUrl' => $video_url,
        'embedUrl' => $video_url,
        'publisher' => [
            '@type' => 'Organization',
            'name' => get_bloginfo('name'),
            'logo' => [
                '@type' => 'ImageObject',
                'url' => get_site_icon_url()
            ]
        ]
    ];

    return $schema;
}

Multiple Schemas Per Page

Implement graph structure.

Schema Graph

Multiple Related Schemas:

function output_schema_graph() {
    $graph = [
        '@context' => 'https://schema.org',
        '@graph' => []
    ];

    // Add Organization schema
    $graph['@graph'][] = [
        '@type' => 'Organization',
        '@id' => home_url('/#organization'),
        'name' => get_bloginfo('name'),
        'url' => home_url('/'),
        'logo' => get_site_icon_url()
    ];

    // Add WebSite schema
    $graph['@graph'][] = [
        '@type' => 'WebSite',
        '@id' => home_url('/#website'),
        'url' => home_url('/'),
        'name' => get_bloginfo('name'),
        'publisher' => [
            '@id' => home_url('/#organization')
        ],
        'potentialAction' => [
            '@type' => 'SearchAction',
            'target' => home_url('/?s={search_term_string}'),
            'query-input' => 'required name=search_term_string'
        ]
    ];

    // Add Article schema (if single post)
    if (is_singular('post')) {
        $graph['@graph'][] = create_article_schema(get_the_ID());
    }

    // Add Breadcrumb schema
    $graph['@graph'][] = generate_breadcrumb_schema();

    // Output
    echo '<script type="application/ld+json">' .
         wp_json_encode($graph, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT) .
         '</script>';
}
add_action('wp_head', 'output_schema_graph');

Benefits:

• All schemas in one script tag
• Clear entity relationships
• Efficient for Google parsing

Custom Meta Boxes for Schema

Admin interface for schema data.

Register Meta Box

function register_schema_meta_box() {
    add_meta_box(
        'custom_schema_meta',
        'Schema Markup Data',
        'render_schema_meta_box',
        'post',
        'side',
        'default'
    );
}
add_action('add_meta_boxes', 'register_schema_meta_box');

Render Fields

function render_schema_meta_box($post) {
    wp_nonce_field('save_schema_meta', 'schema_meta_nonce');

    $rating = get_post_meta($post->ID, 'rating', true);
    $review_count = get_post_meta($post->ID, 'review_count', true);
    $price = get_post_meta($post->ID, 'price', true);
    ?>
    <p>
        <label>Rating (1-5):</label><br>
        <input type="number" name="rating" value="<?php echo esc_attr($rating); ?>"
               min="1" max="5" step="0.1">
    </p>
    <p>
        <label>Review Count:</label><br>
        <input type="number" name="review_count" value="<?php echo esc_attr($review_count); ?>">
    </p>
    <p>
        <label>Price ($):</label><br>
        <input type="number" name="price" value="<?php echo esc_attr($price); ?>"
               min="0" step="0.01">
    </p>
    <?php
}

Save Meta Data

function save_schema_meta($post_id) {
    // Security checks
    if (!isset($_POST['schema_meta_nonce']) ||
        !wp_verify_nonce($_POST['schema_meta_nonce'], 'save_schema_meta')) {
        return;
    }

    if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
        return;
    }

    if (!current_user_can('edit_post', $post_id)) {
        return;
    }

    // Save fields
    if (isset($_POST['rating'])) {
        update_post_meta($post_id, 'rating', sanitize_text_field($_POST['rating']));
    }

    if (isset($_POST['review_count'])) {
        update_post_meta($post_id, 'review_count', absint($_POST['review_count']));
    }

    if (isset($_POST['price'])) {
        update_post_meta($post_id, 'price', sanitize_text_field($_POST['price']));
    }
}
add_action('save_post', 'save_schema_meta');

Validation and Testing

Ensure schema correctness.

Google Rich Results Test

Test URL: https://search.google.com/test/rich-results

Process:

1. Enter your URL or paste schema code
2. Click “Test URL” or “Test Code”
3. Review validation results
4. Fix any errors or warnings

Schema Markup Validator

Official Tool: https://validator.schema.org/

Features:

• Validates JSON-LD syntax
• Checks property compatibility
• Identifies schema errors
• Suggests improvements

Common Validation Errors

Missing Required Properties:

// ERROR - missing required 'name'
$schema = [
    '@type' => 'Person'
    // Missing 'name' property
];

// CORRECT
$schema = [
    '@type' => 'Person',
    'name' => 'John Doe' // Required
];

Incorrect Data Types:

// ERROR - price should be number
'price' => '$99'

// CORRECT
'price' => '99.00',
'priceCurrency' => 'USD'

Invalid URLs:

// ERROR - not a valid URL
'url' => 'example.com'

// CORRECT
'url' => 'https://example.com'

Best Practices

Professional schema implementation.

Use Constants for @context

const SCHEMA_CONTEXT = 'https://schema.org';

$schema = [
    '@context' => SCHEMA_CONTEXT,
    '@type' => 'Article'
];

Sanitize All Data

$schema = [
    '@type' => 'Article',
    'headline' => esc_html(get_the_title()),
    'description' => esc_html(get_the_excerpt()),
    'url' => esc_url(get_permalink())
];

Check for Empty Values

$rating = get_post_meta($post_id, 'rating', true);

if (!empty($rating)) {
    $schema['aggregateRating'] = [
        '@type' => 'AggregateRating',
        'ratingValue' => $rating
    ];
}

Use ISO 8601 for Dates

// Correct format
'datePublished' => get_the_date('c', $post_id), // 2025-01-15T10:30:00+00:00

// Wrong
'datePublished' => get_the_date('F j, Y') // January 15, 2025

Document Custom Schemas

/**
 * Generate SoftwareApplication schema for plugin posts.
 *
 * @param int $post_id Post ID.
 * @return array Schema markup array.
 */
function custom_software_schema($post_id) {
    // Implementation
}

Conclusion

Creating custom schema types in WordPress extends structured data beyond standard implementations. By understanding Schema.org vocabulary, JSON-LD format, and WordPress development practices, you can implement any schema type for your specific needs.

Key Implementation Steps:

1. Choose appropriate Schema.org type
2. Define required and recommended properties
3. Create PHP function to build schema array
4. Output JSON-LD in wp_head
5. Create admin interface for data input
6. Validate with Google Rich Results Test
7. Test with Schema.org validator
8. Monitor Search Console for enhancements

Development Checklist:

• ✓ Use proper @context and @type
• ✓ Include all required properties
• ✓ Sanitize and escape data
• ✓ Use correct data types
• ✓ Validate before deployment
• ✓ Check for empty values
• ✓ Use ISO 8601 for dates
• ✓ Test in multiple validators

Start by extending Nexus Pro’s existing schemas with custom properties, then progress to creating completely custom schema types for specialized content. Always validate implementations before deployment to ensure Google compatibility.

Related Articles:

• WordPress Hooks and Filters Guide
• Extending Nexus Pro: Custom Fields
• Schema Markup: 7 Essential Types
• FAQ Schema Guide for Rich Results

The post How to Create Custom Schema Types in WordPress (Advanced Tutorial) appeared first on Developry Themes.