Forem: anti Gym Club

Role-Based Content in WordPress Without Membership Plugins

anti Gym Club — Tue, 12 May 2026 04:28:00 +0000

You need to hide a post from non-logged-in users. Or show certain pages only to Editors. Or create subscriber-only content.

The typical advice? Install a membership plugin with 50 features you don't need.

Here's how to do role-based content visibility with just PHP no bloated plugins required.

The Core Concept

WordPress already has a robust role and capability system. Every user has a role (administrator, editor, author, subscriber, etc.), and each role has capabilities.

We can leverage this to control content visibility at two levels:

Post/page level entire posts visible only to certain roles
Content level specific sections within a post

Method 1: Filter Posts by Role (Query Level)

This approach hides posts from archive pages and search results:

/**
 * Filter posts based on user role
 */
function filter_posts_by_role( $query ) {
    // Only on frontend, main queries, not single posts
    if ( is_admin() || ! $query->is_main_query() || is_singular() ) {
        return;
    }

    $user = wp_get_current_user();

    // Admins see everything
    if ( in_array( 'administrator', (array) $user->roles ) ) {
        return;
    }

    // Get all posts and check access
    $all_posts = get_posts( array(
        'post_type'      => 'post',
        'posts_per_page' => -1,
        'fields'         => 'ids',
        'post_status'    => 'publish',
    ) );

    $allowed_ids = array();

    foreach ( $all_posts as $post_id ) {
        if ( can_user_access_post( $post_id, $user ) ) {
            $allowed_ids[] = $post_id;
        }
    }

    if ( empty( $allowed_ids ) ) {
        $query->set( 'post__in', array( 0 ) ); // No posts
    } else {
        $query->set( 'post__in', $allowed_ids );
    }
}
add_action( 'pre_get_posts', 'filter_posts_by_role' );

Method 2: Block Direct URL Access

Filtering queries isn't enough users can still access posts via direct URL. Add this:

/**
 * Restrict direct URL access to role-restricted posts
 */
function restrict_direct_access() {
    if ( ! is_singular() ) {
        return;
    }

    global $post;
    $user = wp_get_current_user();

    // Admins bypass
    if ( in_array( 'administrator', (array) $user->roles ) ) {
        return;
    }

    if ( ! can_user_access_post( $post->ID, $user ) ) {
        // Option 1: Redirect to login
        wp_safe_redirect( wp_login_url( get_permalink() ) );
        exit;

        // Option 2: Show 404
        // global $wp_query;
        // $wp_query->set_404();
        // status_header( 404 );
    }
}
add_action( 'template_redirect', 'restrict_direct_access' );

The Access Check Function

Both methods above call can_user_access_post(). Here's the logic:

/**
 * Check if user can access a post
 *
 * @param int     $post_id Post ID
 * @param WP_User $user    User object (null = current user)
 * @return bool
 */
function can_user_access_post( $post_id, $user = null ) {
    if ( $user === null ) {
        $user = wp_get_current_user();
    }

    // Get allowed roles from post meta
    $allowed_roles = get_post_meta( $post_id, '_allowed_roles', true );
    $allowed_roles = is_array( $allowed_roles ) ? $allowed_roles : array();

    // No restrictions = public
    if ( empty( $allowed_roles ) ) {
        return true;
    }

    // Check for "everyone" flag
    if ( in_array( 'everyone', $allowed_roles ) ) {
        return true;
    }

    // Guest access
    if ( ! is_user_logged_in() ) {
        return in_array( 'guest', $allowed_roles );
    }

    // Check user roles against allowed roles
    $user_roles = (array) $user->roles;
    return ! empty( array_intersect( $allowed_roles, $user_roles ) );
}

Adding a Meta Box for Role Selection

Let editors choose which roles can see each post:

/**
 * Add meta box for role selection
 */
function add_role_visibility_meta_box() {
    add_meta_box(
        'role_visibility_box',
        'Content Visibility',
        'render_role_visibility_meta_box',
        'post',
        'side',
        'high'
    );
}
add_action( 'add_meta_boxes', 'add_role_visibility_meta_box' );

/**
 * Render meta box
 */
function render_role_visibility_meta_box( $post ) {
    $roles = wp_roles()->roles;
    $selected = get_post_meta( $post->ID, '_allowed_roles', true );
    $selected = is_array( $selected ) ? $selected : array();

    wp_nonce_field( 'role_visibility_nonce', 'role_visibility_nonce' );
    ?>
    <p><strong>Who can view this post?</strong></p>

    <label style="display:block; margin-bottom:5px;">
        <input type="checkbox" name="allowed_roles[]" value="everyone"
            <?php checked( in_array( 'everyone', $selected ) ); ?>>
        Everyone (Public)
    </label>

    <label style="display:block; margin-bottom:5px;">
        <input type="checkbox" name="allowed_roles[]" value="guest"
            <?php checked( in_array( 'guest', $selected ) ); ?>>
        Guests Only (Not logged in)
    </label>

    <hr>
    <p><strong>Logged-in roles:</strong></p>

    <?php foreach ( $roles as $role_key => $role ) : ?>
        <label style="display:block; margin-bottom:3px;">
            <input type="checkbox" name="allowed_roles[]"
                value="<?php echo esc_attr( $role_key ); ?>"
                <?php checked( in_array( $role_key, $selected ) ); ?>>
            <?php echo esc_html( $role['name'] ); ?>
        </label>
    <?php endforeach; ?>

    <p><em>No selection = visible to everyone</em></p>
    <?php
}

/**
 * Save meta box data
 */
function save_role_visibility_meta( $post_id ) {
    if ( ! isset( $_POST['role_visibility_nonce'] ) ||
         ! wp_verify_nonce( $_POST['role_visibility_nonce'], 'role_visibility_nonce' ) ) {
        return;
    }

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

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

    if ( isset( $_POST['allowed_roles'] ) && is_array( $_POST['allowed_roles'] ) ) {
        $roles = array_map( 'sanitize_text_field', $_POST['allowed_roles'] );
        update_post_meta( $post_id, '_allowed_roles', $roles );
    } else {
        delete_post_meta( $post_id, '_allowed_roles' );
    }
}
add_action( 'save_post', 'save_role_visibility_meta' );

Method 3: Shortcodes for Inline Content

Sometimes you need to hide just part of a post. Shortcodes work great for this:

/**
 * Show content only to specific roles
 * Usage: [if_role role="editor,author"]Secret content[/if_role]
 */
function shortcode_if_role( $atts, $content = '' ) {
    $atts = shortcode_atts( array(
        'role' => ''
    ), $atts );

    if ( empty( $atts['role'] ) || empty( $content ) ) {
        return '';
    }

    $allowed_roles = array_map( 'trim', explode( ',', $atts['role'] ) );
    $user = wp_get_current_user();

    if ( ! is_user_logged_in() ) {
        return '';
    }

    if ( array_intersect( $allowed_roles, (array) $user->roles ) ) {
        return do_shortcode( $content );
    }

    return '';
}
add_shortcode( 'if_role', 'shortcode_if_role' );

/**
 * Show content only to logged-in users
 * Usage: [if_logged_in]Members only![/if_logged_in]
 */
function shortcode_if_logged_in( $atts, $content = '' ) {
    if ( is_user_logged_in() ) {
        return do_shortcode( $content );
    }
    return '';
}
add_shortcode( 'if_logged_in', 'shortcode_if_logged_in' );

/**
 * Show content only to guests
 * Usage: [if_guest]Please log in to see more.[/if_guest]
 */
function shortcode_if_guest( $atts, $content = '' ) {
    if ( ! is_user_logged_in() ) {
        return do_shortcode( $content );
    }
    return '';
}
add_shortcode( 'if_guest', 'shortcode_if_guest' );

Usage Examples

<!-- Show premium content to subscribers -->
[if_role role="subscriber,administrator"]
<div class="premium-content">
    This is subscriber-only content.
</div>
[/if_role]

<!-- Different messages for logged in vs guests -->
[if_logged_in]
Welcome back! Here's your dashboard.
[/if_logged_in]

[if_guest]
Please <a href="/login">log in</a> to access your account.
[/if_guest]

Security Considerations

Always check on both query AND template_redirect query filtering alone isn't enough
Validate nonces when saving meta
Sanitize role values never trust user input
Admin bypass always let administrators see everything
Cache awareness if using page caching, exclude role-restricted pages

When This Isn't Enough

This approach works for simple role-based visibility. You'll need more if you want:

Subscription payments
Drip content
User registration forms
Progress tracking

For those, you actually need a membership plugin. But for basic "show this to editors only" or "hide from guests" the code above handles it.

If you want this functionality without maintaining custom code, I built Role Based Content Pro that handles all edge cases plus adds a visual indicator in the posts list.

Resources:

How to Create Safe External Redirects in WordPress

anti Gym Club — Mon, 04 May 2026 16:26:00 +0000

You want to redirect a WordPress post to an external URL. Maybe it's an affiliate link, a resource that moved, or a curated link collection.

The naive approach using wp_redirect() with any URL opens security holes. Here's how to do it safely.

The Problem with wp_redirect()

// DON'T DO THIS
wp_redirect( $_GET['url'] );
exit;

This is an open redirect vulnerability. Attackers can craft URLs like:

yoursite.com/post?url=https://malicious-site.com

And use your domain's reputation to phish users.

Safe External Redirects

WordPress provides wp_safe_redirect(), but it only allows redirects to whitelisted hosts. For external URLs, we need validation:

/**
 * Safely redirect to an external URL
 *
 * @param string $url         Destination URL
 * @param int    $status_code HTTP status code (301, 302, 307)
 */
function safe_external_redirect( $url, $status_code = 301 ) {
    // Validate URL format
    if ( ! filter_var( $url, FILTER_VALIDATE_URL ) ) {
        wp_die( 'Invalid redirect URL' );
    }

    // Only allow http/https protocols
    $allowed_protocols = array( 'http', 'https' );
    $parsed = wp_parse_url( $url );

    if ( ! isset( $parsed['scheme'] ) ||
         ! in_array( strtolower( $parsed['scheme'] ), $allowed_protocols, true ) ) {
        wp_die( 'Invalid URL protocol' );
    }

    // Validate status code
    $valid_codes = array( 301, 302, 307 );
    if ( ! in_array( $status_code, $valid_codes, true ) ) {
        $status_code = 301;
    }

    // Perform redirect
    wp_redirect( esc_url_raw( $url ), $status_code );
    exit;
}

Building a Post-Based Redirect System

Let's create a system where editors can set an external redirect URL per post.

Step 1: Add Meta Box

/**
 * Add redirect meta box
 */
function add_redirect_meta_box() {
    add_meta_box(
        'external_redirect_box',
        'External Redirect',
        'render_redirect_meta_box',
        'post',
        'side',
        'high'
    );
}
add_action( 'add_meta_boxes', 'add_redirect_meta_box' );

/**
 * Render meta box
 */
function render_redirect_meta_box( $post ) {
    $enabled = get_post_meta( $post->ID, '_redirect_enabled', true );
    $url = get_post_meta( $post->ID, '_redirect_url', true );

    wp_nonce_field( 'redirect_meta_nonce', 'redirect_nonce' );
    ?>
    <p>
        <label>
            <input type="checkbox" name="redirect_enabled" value="1"
                <?php checked( $enabled, '1' ); ?>>
            Enable external redirect
        </label>
    </p>
    <p>
        <label for="redirect_url">Destination URL:</label>
        <input type="url" name="redirect_url" id="redirect_url"
            class="widefat" placeholder="https://example.com"
            value="<?php echo esc_attr( $url ); ?>">
    </p>
    <p class="description">
        Visitors will be redirected to this URL when viewing this post.
    </p>
    <?php
}

Step 2: Save with Validation

/**
 * Save redirect meta
 */
function save_redirect_meta( $post_id ) {
    // Verify nonce
    if ( ! isset( $_POST['redirect_nonce'] ) ||
         ! wp_verify_nonce( $_POST['redirect_nonce'], 'redirect_meta_nonce' ) ) {
        return;
    }

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

    // Skip autosave
    if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE ) {
        return;
    }

    // Save enabled state
    $enabled = isset( $_POST['redirect_enabled'] ) ? '1' : '0';
    update_post_meta( $post_id, '_redirect_enabled', $enabled );

    // Validate and save URL
    $url = '';
    if ( isset( $_POST['redirect_url'] ) ) {
        $url = esc_url_raw( wp_unslash( $_POST['redirect_url'] ) );

        // Double-check it's a valid URL
        if ( ! empty( $url ) && ! filter_var( $url, FILTER_VALIDATE_URL ) ) {
            // Store error for admin notice
            set_transient( 'redirect_error_' . $post_id, 'invalid_url', 30 );
            return;
        }
    }

    update_post_meta( $post_id, '_redirect_url', $url );
}
add_action( 'save_post', 'save_redirect_meta' );

Step 3: Handle Frontend Redirect

/**
 * Handle redirect on frontend
 */
function handle_external_redirect() {
    // Only on single posts
    if ( ! is_singular( 'post' ) || ! is_main_query() ) {
        return;
    }

    $post_id = get_the_ID();
    $enabled = get_post_meta( $post_id, '_redirect_enabled', true );
    $url = get_post_meta( $post_id, '_redirect_url', true );

    if ( '1' !== $enabled || empty( $url ) ) {
        return;
    }

    // Allow admins to bypass for testing
    if ( current_user_can( 'edit_posts' ) && isset( $_GET['no_redirect'] ) ) {
        return;
    }

    // Validate URL before redirecting
    if ( ! filter_var( $url, FILTER_VALIDATE_URL ) ) {
        return;
    }

    // Redirect with 301 (permanent)
    wp_redirect( esc_url_raw( $url ), 301 );
    exit;
}
add_action( 'template_redirect', 'handle_external_redirect' );

Choosing the Right Status Code

Code	Name	When to Use
301	Permanent	The old URL will never be used again. SEO value transfers.
302	Found	Temporary redirect. Original URL might come back.
307	Temporary	Like 302, but preserves HTTP method (POST stays POST).

For most external redirects, 301 is correct. It tells search engines to update their index.

Modifying Permalinks in Listings

When a post has an external redirect, you might want links in menus and archives to point directly to the external URL:

/**
 * Modify permalink for redirected posts
 */
function modify_redirected_permalink( $permalink, $post ) {
    // Don't modify in admin
    if ( is_admin() ) {
        return $permalink;
    }

    $enabled = get_post_meta( $post->ID, '_redirect_enabled', true );
    $url = get_post_meta( $post->ID, '_redirect_url', true );

    if ( '1' === $enabled && ! empty( $url ) && filter_var( $url, FILTER_VALIDATE_URL ) ) {
        return $url;
    }

    return $permalink;
}
add_filter( 'post_link', 'modify_redirected_permalink', 10, 2 );

Adding Admin Bar Link for Testing

Editors need to view the actual post (not get redirected) when testing:

/**
 * Add "View Without Redirect" to admin bar
 */
function add_bypass_link( $wp_admin_bar ) {
    if ( ! is_singular( 'post' ) || ! current_user_can( 'edit_posts' ) ) {
        return;
    }

    $post_id = get_the_ID();
    $enabled = get_post_meta( $post_id, '_redirect_enabled', true );

    if ( '1' !== $enabled ) {
        return;
    }

    $wp_admin_bar->add_node( array(
        'id'    => 'view-no-redirect',
        'title' => 'View Without Redirect',
        'href'  => add_query_arg( 'no_redirect', '1', get_permalink() ),
        'meta'  => array( 'target' => '_blank' ),
    ) );
}
add_action( 'admin_bar_menu', 'add_bypass_link', 999 );

Security Checklist

Always validate URLs with filter_var( $url, FILTER_VALIDATE_URL )
Sanitize on save with esc_url_raw()
Escape on output with esc_url()
Check protocols only allow http/https
Use nonces when saving meta
Verify capabilities only editors should set redirects
Never redirect to user input without validation

Common Issues

Redirect loops:
Make sure the redirect URL isn't the post's own URL. Add this check:

$current_url = get_permalink( $post_id );
if ( trailingslashit( $url ) === trailingslashit( $current_url ) ) {
    return; // Don't redirect to self
}

Cached redirects:
If you change a redirect and it doesn't update, clear your site cache and browser cache. 301 redirects are aggressively cached.

SEO implications:
301 redirects pass ~90% of link equity. This is fine for legitimate use cases. But don't use redirects to manipulate search rankings that's against Google's guidelines.

If you want a complete solution with a settings page, redirect logging, and support for pages/CPTs, check out External Redirect Pro.

Resources:

Exporting WordPress Content to JSON for Headless and Static Sites

anti Gym Club — Mon, 27 Apr 2026 15:23:00 +0000

You've got years of content in WordPress. Now you want to move to a static site generator, build a headless frontend, or just back up your content in a portable format.

The WordPress REST API exists, but it requires authentication setup, pagination handling, and multiple requests. Sometimes you just want a clean JSON export.

Here's how to build one.

The Export Class

<?php
/**
 * WordPress Content Exporter
 */
class Content_Exporter {

    /**
     * Export posts based on options
     *
     * @param array $options Export options
     * @return array
     */
    public function export( $options = array() ) {
        $defaults = array(
            'post_type'      => 'post',
            'post_status'    => 'publish',
            'posts_per_page' => -1,
            'category'       => '',
            'include'        => array( 'content', 'excerpt', 'featured_image', 'taxonomies', 'meta' ),
        );

        $options = wp_parse_args( $options, $defaults );

        $args = array(
            'post_type'      => sanitize_key( $options['post_type'] ),
            'post_status'    => sanitize_key( $options['post_status'] ),
            'posts_per_page' => intval( $options['posts_per_page'] ),
            'orderby'        => 'date',
            'order'          => 'DESC',
        );

        // Category filter
        if ( ! empty( $options['category'] ) ) {
            $args['cat'] = intval( $options['category'] );
        }

        $query = new WP_Query( $args );
        $posts = array();

        if ( $query->have_posts() ) {
            while ( $query->have_posts() ) {
                $query->the_post();
                $posts[] = $this->format_post( get_post(), $options['include'] );
            }
            wp_reset_postdata();
        }

        return $posts;
    }

    /**
     * Format a single post
     */
    private function format_post( $post, $include ) {
        $data = array(
            'id'       => $post->ID,
            'title'    => $post->post_title,
            'slug'     => $post->post_name,
            'date'     => $post->post_date,
            'modified' => $post->post_modified,
            'status'   => $post->post_status,
            'type'     => $post->post_type,
            'url'      => get_permalink( $post->ID ),
            'author'   => $this->get_author( $post->post_author ),
        );

        if ( in_array( 'content', $include, true ) ) {
            $data['content'] = $post->post_content;
            $data['content_rendered'] = apply_filters( 'the_content', $post->post_content );
        }

        if ( in_array( 'excerpt', $include, true ) ) {
            $data['excerpt'] = $post->post_excerpt
                ? $post->post_excerpt
                : wp_trim_words( $post->post_content, 55 );
        }

        if ( in_array( 'featured_image', $include, true ) ) {
            $data['featured_image'] = $this->get_featured_image( $post->ID );
        }

        if ( in_array( 'taxonomies', $include, true ) ) {
            $data['taxonomies'] = $this->get_taxonomies( $post->ID, $post->post_type );
        }

        if ( in_array( 'meta', $include, true ) ) {
            $data['meta'] = $this->get_public_meta( $post->ID );
        }

        return $data;
    }

    /**
     * Get author data
     */
    private function get_author( $author_id ) {
        $user = get_userdata( $author_id );
        if ( ! $user ) {
            return null;
        }

        return array(
            'id'   => $user->ID,
            'name' => $user->display_name,
            'slug' => $user->user_nicename,
        );
    }

    /**
     * Get featured image
     */
    private function get_featured_image( $post_id ) {
        $thumbnail_id = get_post_thumbnail_id( $post_id );
        if ( ! $thumbnail_id ) {
            return null;
        }

        $image = wp_get_attachment_image_src( $thumbnail_id, 'full' );
        $alt = get_post_meta( $thumbnail_id, '_wp_attachment_image_alt', true );

        return array(
            'id'     => $thumbnail_id,
            'url'    => $image ? $image[0] : '',
            'width'  => $image ? $image[1] : 0,
            'height' => $image ? $image[2] : 0,
            'alt'    => $alt,
        );
    }

    /**
     * Get taxonomies
     */
    private function get_taxonomies( $post_id, $post_type ) {
        $taxonomies = get_object_taxonomies( $post_type, 'objects' );
        $data = array();

        foreach ( $taxonomies as $taxonomy ) {
            $terms = get_the_terms( $post_id, $taxonomy->name );
            if ( ! $terms || is_wp_error( $terms ) ) {
                continue;
            }

            $data[ $taxonomy->name ] = array_map( function( $term ) {
                return array(
                    'id'   => $term->term_id,
                    'name' => $term->name,
                    'slug' => $term->slug,
                );
            }, $terms );
        }

        return $data;
    }

    /**
     * Get public meta (exclude private _ prefixed keys)
     */
    private function get_public_meta( $post_id ) {
        $meta = get_post_meta( $post_id );
        $data = array();

        foreach ( $meta as $key => $values ) {
            // Skip private meta
            if ( strpos( $key, '_' ) === 0 ) {
                continue;
            }
            $data[ $key ] = count( $values ) === 1 ? $values[0] : $values;
        }

        return $data;
    }

    /**
     * Convert to JSON
     */
    public function to_json( $posts ) {
        return wp_json_encode(
            $posts,
            JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES
        );
    }
}

Usage

$exporter = new Content_Exporter();

// Export all posts
$posts = $exporter->export();
$json = $exporter->to_json( $posts );

// Export pages only
$pages = $exporter->export( array(
    'post_type' => 'page',
) );

// Export specific category
$tutorials = $exporter->export( array(
    'category' => 5, // category ID
) );

// Minimal export (no content, just metadata)
$minimal = $exporter->export( array(
    'include' => array( 'excerpt', 'featured_image' ),
) );

Adding an Admin Interface

/**
 * Add export page to admin
 */
function add_export_admin_page() {
    add_management_page(
        'Export Content',
        'Export Content',
        'manage_options',
        'content-export',
        'render_export_page'
    );
}
add_action( 'admin_menu', 'add_export_admin_page' );

/**
 * Handle export
 */
function render_export_page() {
    // Handle form submission
    if ( isset( $_POST['export_nonce'] ) &&
         wp_verify_nonce( $_POST['export_nonce'], 'content_export' ) ) {

        $exporter = new Content_Exporter();

        $options = array(
            'post_type' => sanitize_key( $_POST['post_type'] ?? 'post' ),
            'include'   => array_map( 'sanitize_key', $_POST['include'] ?? array() ),
        );

        $posts = $exporter->export( $options );
        $json = $exporter->to_json( $posts );

        // Trigger download
        header( 'Content-Type: application/json' );
        header( 'Content-Disposition: attachment; filename="export-' . date('Y-m-d') . '.json"' );
        echo $json;
        exit;
    }

    // Render form
    $post_types = get_post_types( array( 'public' => true ), 'objects' );
    ?>
    <div class="wrap">
        <h1>Export Content to JSON</h1>

        <form method="post">
            <?php wp_nonce_field( 'content_export', 'export_nonce' ); ?>

            <table class="form-table">
                <tr>
                    <th>Post Type</th>
                    <td>
                        <select name="post_type">
                            <?php foreach ( $post_types as $type ) : ?>
                                <option value="<?php echo esc_attr( $type->name ); ?>">
                                    <?php echo esc_html( $type->labels->name ); ?>
                                </option>
                            <?php endforeach; ?>
                        </select>
                    </td>
                </tr>
                <tr>
                    <th>Include</th>
                    <td>
                        <label><input type="checkbox" name="include[]" value="content" checked> Content</label><br>
                        <label><input type="checkbox" name="include[]" value="excerpt" checked> Excerpt</label><br>
                        <label><input type="checkbox" name="include[]" value="featured_image" checked> Featured Image</label><br>
                        <label><input type="checkbox" name="include[]" value="taxonomies" checked> Taxonomies</label><br>
                        <label><input type="checkbox" name="include[]" value="meta"> Custom Meta</label>
                    </td>
                </tr>
            </table>

            <?php submit_button( 'Download JSON' ); ?>
        </form>
    </div>
    <?php
}

Converting to Markdown

For static site generators like Hugo, Jekyll, or Astro, Markdown with frontmatter is often more useful:

/**
 * Convert posts array to Markdown files content
 */
public function to_markdown( $posts ) {
    $output = '';

    foreach ( $posts as $post ) {
        // Frontmatter
        $output .= "---\n";
        $output .= 'title: "\"' . str_replace( '\"', '\"', $post['title'] ) . \"\"\n\";"
        $output .= 'slug: ' . $post['slug'] . "\n";
        $output .= 'date: ' . $post['date'] . "\n";

        if ( ! empty( $post['author']['name'] ) ) {
            $output .= 'author: ' . $post['author']['name'] . "\n";
        }

        if ( ! empty( $post['featured_image']['url'] ) ) {
            $output .= 'featured_image: ' . $post['featured_image']['url'] . "\n";
        }

        if ( ! empty( $post['taxonomies']['category'] ) ) {
            $cats = array_column( $post['taxonomies']['category'], 'name' );
            $output .= 'categories: [' . implode( ', ', $cats ) . "]\n";
        }

        $output .= "---\n\n";

        // Content
        $output .= '# ' . $post['title'] . "\n\n";

        if ( ! empty( $post['content'] ) ) {
            $output .= $this->html_to_markdown( $post['content'] );
        }

        $output .= "\n\n---\n\n";
    }

    return trim( $output );
}

/**
 * Basic HTML to Markdown
 */
private function html_to_markdown( $html ) {
    // Remove WordPress block comments
    $html = preg_replace( '/<!-- \/?wp:[^>]+ -->/', '', $html );

    $replacements = array(
        '/<h1[^>]*>(.*?)<\/h1>/i'   => "# $1\n\n",
        '/<h2[^>]*>(.*?)<\/h2>/i'   => "## $1\n\n",
        '/<h3[^>]*>(.*?)<\/h3>/i'   => "### $1\n\n",
        '/<p[^>]*>(.*?)<\/p>/is'    => "$1\n\n",
        '/<strong>(.*?)<\/strong>/i' => "**$1**",
        '/<em>(.*?)<\/em>/i'        => "*$1*",
        '/<a[^>]+href=["\']([^"\']+)["\'][^>]*>(.*?)<\/a>/i' => "[$2]($1)",
        '/<ul[^>]*>(.*?)<\/ul>/is'  => "$1\n",
        '/<li[^>]*>(.*?)<\/li>/i'   => "- $1\n",
        '/<code>(.*?)<\/code>/i'    => "`$1`",
        '/<br\s*\/?>/i'             => "\n",
    );

    foreach ( $replacements as $pattern => $replacement ) {
        $html = preg_replace( $pattern, $replacement, $html );
    }

    return wp_strip_all_tags( $html );
}

Output Example

{
  "id": 123,
  "title": "Getting Started with WordPress",
  "slug": "getting-started-wordpress",
  "date": "2026-04-15 10:30:00",
  "modified": "2026-04-18 14:22:00",
  "status": "publish",
  "type": "post",
  "url": "https://example.com/getting-started-wordpress/",
  "author": {
    "id": 1,
    "name": "John Doe",
    "slug": "john-doe"
  },
  "content": "<!-- wp:paragraph -->Raw content here...",
  "content_rendered": "<p>Rendered HTML content...</p>",
  "excerpt": "A quick introduction to WordPress...",
  "featured_image": {
    "id": 456,
    "url": "https://example.com/wp-content/uploads/image.jpg",
    "width": 1200,
    "height": 630,
    "alt": "WordPress dashboard"
  },
  "taxonomies": {
    "category": [
      { "id": 1, "name": "Tutorials", "slug": "tutorials" }
    ],
    "post_tag": [
      { "id": 5, "name": "WordPress", "slug": "wordpress" }
    ]
  }
}

Use Cases

Migrating to Gatsby/Next.js export, transform, import
Backup portable content outside the database
Headless WordPress pre-generate JSON for frontend consumption
Static site migration export to Markdown for Hugo/Jekyll
Content analysis process exported JSON with external tools

ACF Support

If you use Advanced Custom Fields, add this method:

/**
 * Get ACF fields
 */
private function get_acf_fields( $post_id ) {
    if ( ! function_exists( 'get_fields' ) ) {
        return array();
    }

    $fields = get_fields( $post_id );
    return $fields ? $fields : array();
}

Then add 'acf' to the include array option.

If you need a ready-to-use solution with admin UI, date filtering, and format options, I built Content Exporter for exactly this.

Resources:

How to Add Skip Links to Any WordPress Theme

anti Gym Club — Tue, 21 Apr 2026 04:07:31 +0000

Skip links are one of the most important accessibility features and one of the most overlooked.

They let keyboard users bypass repetitive navigation and jump directly to content. WCAG 2.4.1 (Level A) requires them. Yet most WordPress themes don't include them.

Here's how to add skip links to any theme, with code you can use today.

What Are Skip Links?

A skip link is a hidden anchor link that becomes visible when a keyboard user presses Tab. It typically says "Skip to content" and jumps to the main content area.

For someone using a screen reader or keyboard-only navigation, this means not having to tab through 20 menu items on every single page.

The Basic Implementation

Add this to your theme's functions.php or a custom plugin:

/**
 * Add skip link to the beginning of the page
 */
function add_skip_link() {
    // Don't show in admin
    if ( is_admin() ) {
        return;
    }

    echo '<a class="skip-link screen-reader-text" href="#main-content">Skip to content</a>';
}
add_action( 'wp_body_open', 'add_skip_link', 1 );

The CSS (This Is Where Most Fail)

The skip link must be:

Invisible by default (but NOT display: none screen readers skip those)
Visible on focus
High contrast
Properly positioned

.skip-link {
    /* Visually hidden but accessible */
    clip: rect(1px, 1px, 1px, 1px);
    clip-path: inset(50%);
    height: 1px;
    width: 1px;
    margin: -1px;
    overflow: hidden;
    padding: 0;
    position: absolute;
    word-wrap: normal !important;
}

.skip-link:focus {
    /* Visible on focus */
    background-color: #000;
    color: #fff;
    clip: auto !important;
    clip-path: none;
    display: inline-block;
    font-size: 16px;
    font-weight: 600;
    height: auto;
    width: auto;
    margin: 0;
    overflow: visible;
    padding: 15px;
    position: fixed;
    top: 0;
    left: 0;
    z-index: 999999;
    text-decoration: none;
    outline: 2px solid #fff;
    outline-offset: 2px;
}

Enqueue it properly:

function enqueue_skip_link_styles() {
    wp_enqueue_style(
        'skip-link-style',
        get_template_directory_uri() . '/css/skip-link.css',
        array(),
        '1.0.0'
    );
}
add_action( 'wp_enqueue_scripts', 'enqueue_skip_link_styles' );

The Target Element Problem

Your skip link points to #main-content. But does that ID exist in your theme?

Check common IDs by theme:

Twenty Twenty-Four: main
Astra: content or primary
GeneratePress: content
Kadence: main
Custom themes: Check your single.php or index.php

If your theme doesn't have an ID on the main content wrapper, add one:

// In your theme's template files, find the main content div and add an ID
<main id="main-content" class="site-main">

Or use JavaScript as a fallback:

document.addEventListener('DOMContentLoaded', function() {
    // Find common main content elements
    const selectors = ['main', '[role="main"]', '#content', '#primary', '.site-main'];

    for (const selector of selectors) {
        const element = document.querySelector(selector);
        if (element && !element.id) {
            element.id = 'main-content';
            break;
        }
    }
});

Handling Themes Without wp_body_open

Older themes might not call wp_body_open(). Use a fallback:

function add_skip_link_with_fallback() {
    if ( is_admin() ) {
        return;
    }

    // Check if wp_body_open was already called
    if ( did_action( 'wp_body_open' ) ) {
        return; // Already rendered via wp_body_open
    }

    // Inject via JavaScript
    $html = '<a class="skip-link screen-reader-text" href="#main-content">Skip to content</a>';
    ?>
    <script>
    (function() {
        var skipLink = <?php echo wp_json_encode( $html ); ?>;
        var div = document.createElement('div');
        div.innerHTML = skipLink;
        document.body.insertBefore(div.firstChild, document.body.firstChild);
    })();
    </script>
    <?php
}
add_action( 'wp_footer', 'add_skip_link_with_fallback', 1 );

Adding Multiple Skip Links

Some sites benefit from multiple targets:

function add_multiple_skip_links() {
    if ( is_admin() ) {
        return;
    }
    ?>
    <nav class="skip-links" aria-label="Skip links">
        <a class="skip-link" href="#main-content">Skip to content</a>
        <a class="skip-link" href="#site-navigation">Skip to navigation</a>
        <a class="skip-link" href="#footer">Skip to footer</a>
    </nav>
    <?php
}
add_action( 'wp_body_open', 'add_multiple_skip_links', 1 );

Testing Your Implementation

Reload your site
Press Tab immediately
The skip link should appear
Press Enter
Focus should move to your main content

Test with actual assistive technology if possible. NVDA (Windows) and VoiceOver (Mac) are free.

Common Mistakes

Using display: none Screen readers skip it entirely
Wrong target ID Link goes nowhere
Low contrast colors Fails WCAG
Missing focus styles Users can't see the link
z-index too low Hidden behind sticky headers

The Easy Way

If you don't want to maintain custom code, I built Skip Links Generator Pro that handles all edge cases including themes without wp_body_open, automatic ID detection, and customizable styling.

But the code above will work for most themes. The important thing is to have skip links at all.

Resources:

llm.txt: How to Make Your Wordpress Readable by AI Assistants

anti Gym Club — Sun, 12 Apr 2026 23:37:17 +0000

You've heard of robots.txt. It tells search engines what to crawl.

Now there's llm.txt. It tells AI assistants what your site is about.

The Problem

AI assistants like ChatGPT and Claude are becoming how people find information. But they work differently
than Google.

Google crawls your site, follows links, understands structure. AI assistants? They need explicit context.

Without it, they might:

Ignore your site entirely
Hallucinate wrong information about you
Recommend competitors instead

What is llm.txt?

A plain text file at yoursite.com/llm.txt that provides context to AI.

Basic structure:

Site Name

Brief description of what this site does

About

Detailed information about the site or business.

Key Pages

/about - About page
/products - Product listings
/blog - Technical articles

Products/Services

Product 1 - Description
Product 2 - Description

Contact

email@example.com

Human-readable. Machine-parseable. Takes 5 minutes to create.

Why It Matters

AI search is growing:

ChatGPT: 100M+ weekly users
Perplexity: 10M+ monthly users
Google AI Overviews: 30%+ of searches

These tools decide what content to surface. Without context, they skip you.

Implementation in WordPress

Option 1: Manual

Create llm.txt in your root directory:

  // In functions.php - serve llm.txt
  add_action('init', function() {
      if ($_SERVER['REQUEST_URI'] === '/llm.txt') {
          header('Content-Type: text/plain');
          echo file_get_contents(ABSPATH . 'llm.txt');
          exit;
      }
  });

Then create the file manually and update it when you publish.

Option 2: Auto-generate

Query your posts and build the file dynamically:

  add_action('init', function() {
      if ($_SERVER['REQUEST_URI'] === '/llm.txt') {
          header('Content-Type: text/plain');

          $output = "# " . get_bloginfo('name') . "\n\n";
          $output .= "> " . get_bloginfo('description') . "\n\n";

          $output .= "## Recent Posts\n";
          $posts = get_posts(['numberposts' => 10]);
          foreach ($posts as $post) {
              $output .= "- " . get_permalink($post) . " - " . $post->post_title . "\n";
          }

          echo $output;
          exit;
      }
  });

This keeps it updated automatically.

Option 3: Use a Plugin

If you want more control without writing code, https://antigymclub.com/plugins/llm-txt-generator-pro/ handles:

Auto-generation from all content types
- Custom sections and context
- Updates on publish
- Preview before going live

Content Portability

Related problem: your content is trapped in WordPress's database.

For AI training, headless migrations, or proper backups, you need clean exports.

WordPress's native XML export is... not clean.

Better approach: export to JSON or Markdown.

  // Simple JSON export
  $posts = get_posts(['numberposts' => -1]);
  $export = [];

  foreach ($posts as $post) {
      $export[] = [
          'title' => $post->post_title,
          'content' => $post->post_content,
          'date' => $post->post_date,
          'url' => get_permalink($post)
      ];
  }

  header('Content-Type: application/json');
  echo json_encode($export, JSON_PRETTY_PRINT);

For Markdown with frontmatter, you'll need to convert HTML content - more complex but doable.

Full Solution

I built two plugins that work together:

LLM.txt Generator Pro - AI context file, auto-updated
Content Exporter JSON/MD - Clean exports to JSON/Markdown

Available as the https://antigymclub.com/bundles/ai-readiness-bundle/ - $29 for both.

Getting Started

Minimum viable approach:

Create llm.txt with your site description and key pages
Upload to root directory
Test: visit yoursite.com/llm.txt

That's it. AI assistants can now understand your site.

For automation, either write the code above or use a plugin.

Questions? Drop them in the comments.