diff --git a/allterrain-forms.php b/allterrain-forms.php
index 1700e16..531f3f7 100644
--- a/allterrain-forms.php
+++ b/allterrain-forms.php
@@ -154,6 +154,8 @@
 require_once ATF_DIR . 'includes/dev-mode.php';
 require_once ATF_DIR . 'includes/demo-data.php';
 require_once ATF_DIR . 'includes/templates.php';
+require_once ATF_DIR . 'includes/importers.php';
+require_once ATF_DIR . 'includes/importer-cf7.php';
 require_once ATF_DIR . 'includes/rest.php';
 require_once ATF_DIR . 'includes/preview.php';
 require_once ATF_DIR . 'includes/shortcode.php';
diff --git a/docs/hooks-reference.md b/docs/hooks-reference.md
index 200c6b7..bd6ea06 100644
--- a/docs/hooks-reference.md
+++ b/docs/hooks-reference.md
@@ -776,6 +776,59 @@ do_action( 'atf_retention_applied', int $deleted );
 
 ---
 
+## Importers
+
+### `atf_importers` — Filter — *Experimental*
+
+```php
+apply_filters( 'atf_importers', array $importers );
+```
+
+The registry behind **Forms → Import**. Each entry is keyed by importer id and
+holds four things: a `label`, and three callables — `available()` (does the
+source plugin's data exist on this site), `forms()` (source id => title, for
+the picker), and `import( $source_id )` (returns the new form id or a
+`WP_Error`). The built-in importers register through this same filter, exactly
+as a third-party source would.
+
+Importers read the source plugin's *data*, not its API — the moment somebody
+most wants to import is right after deactivating the old plugin.
+
+```php
+add_filter( 'atf_importers', function ( $importers ) {
+	$importers['my-forms'] = array(
+		'label'     => 'My Forms',
+		'available' => fn() => (bool) get_option( 'my_forms' ),
+		'forms'     => fn() => wp_list_pluck( get_option( 'my_forms' ), 'title', 'id' ),
+		'import'    => 'my_forms_import_one',
+	);
+
+	return $importers;
+} );
+```
+
+### `atf_imported_schema` — Filter — *Experimental*
+
+```php
+apply_filters( 'atf_imported_schema', array $schema, string $importer_id, string $source_id );
+```
+
+The converted schema, before it is normalised and saved. The place to correct
+a mapping the converter got wrong for your data — rename a field, add a
+notification — without forking the importer.
+
+### `atf_form_imported` — Action — *Experimental*
+
+```php
+do_action( 'atf_form_imported', int $form_id, string $importer_id, string $source_id );
+```
+
+Fires after a form is imported. The source plugin's data is never modified, so
+importing is safe to repeat — hook here if you need to record the mapping or
+redirect shortcodes.
+
+---
+
 ## Themes
 
 ### `atf_theme_tokens` — Filter — *Stable*
diff --git a/includes/importer-cf7.php b/includes/importer-cf7.php
new file mode 100644
index 0000000..b88de1c
--- /dev/null
+++ b/includes/importer-cf7.php
@@ -0,0 +1,576 @@
+<?php
+/**
+ * Importer — Contact Form 7.
+ *
+ * CF7 stores each form as a `wpcf7_contact_form` post whose meta holds a text
+ * template (`_form`), the mail settings (`_mail`, `_mail_2`) and the messages
+ * (`_messages`). All of that survives the plugin being deactivated, so this
+ * importer reads the posts directly and never needs CF7's classes — the moment
+ * somebody most wants to import is right after switching the old plugin off.
+ *
+ * The template is a run of form-tags like `[text* your-name]`, usually wrapped
+ * in `<label>` markup carrying the human question. Both halves matter: the tag
+ * becomes the field, the label text becomes the field's label, and the mail
+ * template's `[your-name]` references become `{field:…}` merge tags on the new
+ * form's notification.
+ *
+ * @package AllTerrain_Forms
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * Registers the importer.
+ *
+ * @since 0.2.0
+ *
+ * @param array[] $importers Importer id => definition.
+ * @return array[]
+ */
+function atf_register_cf7_importer( $importers ) {
+	$importers['contact-form-7'] = array(
+		'label'     => __( 'Contact Form 7', 'allterrain-forms' ),
+		'available' => 'atf_cf7_available',
+		'forms'     => 'atf_cf7_forms',
+		'import'    => 'atf_cf7_import',
+	);
+
+	return $importers;
+}
+add_filter( 'atf_importers', 'atf_register_cf7_importer' );
+
+/**
+ * Whether any Contact Form 7 forms exist on this site.
+ *
+ * Counted from the posts table rather than asking the plugin, so the data is
+ * found whether CF7 is active, deactivated or already deleted.
+ *
+ * @since 0.2.0
+ *
+ * @return bool
+ */
+function atf_cf7_available() {
+	return (bool) atf_cf7_forms();
+}
+
+/**
+ * The CF7 forms on this site, id => title.
+ *
+ * @since 0.2.0
+ *
+ * @return array
+ */
+function atf_cf7_forms() {
+	$posts = get_posts(
+		array(
+			'post_type'      => 'wpcf7_contact_form',
+			'post_status'    => 'any',
+			// A hard bound, not a page size: a site with more CF7 forms than
+			// this has other problems, and an unbounded query on a page load
+			// is how an importer takes the admin down with it.
+			'posts_per_page' => 200,
+			'orderby'        => 'title',
+			'order'          => 'ASC',
+		)
+	);
+
+	$forms = array();
+
+	foreach ( $posts as $post ) {
+		$forms[ (string) $post->ID ] = '' !== $post->post_title ? $post->post_title : __( '(untitled)', 'allterrain-forms' );
+	}
+
+	return $forms;
+}
+
+/**
+ * Imports one CF7 form.
+ *
+ * @since 0.2.0
+ *
+ * @param string $source_id The CF7 post id.
+ * @return int|WP_Error The new form's id.
+ */
+function atf_cf7_import( $source_id ) {
+	$post = get_post( absint( $source_id ) );
+
+	if ( ! $post || 'wpcf7_contact_form' !== $post->post_type ) {
+		return new WP_Error( 'atf_import_missing', __( 'That form no longer exists.', 'allterrain-forms' ) );
+	}
+
+	$schema = atf_cf7_convert(
+		(string) get_post_meta( $post->ID, '_form', true ),
+		(array) get_post_meta( $post->ID, '_mail', true ),
+		(array) get_post_meta( $post->ID, '_mail_2', true ),
+		(array) get_post_meta( $post->ID, '_messages', true )
+	);
+
+	return atf_create_imported_form( $post->post_title, $schema, 'contact-form-7', (string) $post->ID );
+}
+
+/**
+ * Converts one CF7 form's stored pieces into a schema.
+ *
+ * Pure — no database, no capability checks — so the conversion rules can be
+ * tested against fixture templates without inserting posts.
+ *
+ * @since 0.2.0
+ *
+ * @param string $template The `_form` template.
+ * @param array  $mail     The `_mail` settings.
+ * @param array  $mail_2   The `_mail_2` settings.
+ * @param array  $messages The `_messages` strings.
+ * @return array A raw schema, ready for `atf_normalize_schema()`.
+ */
+function atf_cf7_convert( $template, $mail, $mail_2, $messages ) {
+	$parsed = atf_cf7_parse_template( $template );
+
+	$schema = array(
+		'fields'        => $parsed['fields'],
+		'notifications' => array(),
+		'confirmations' => array(),
+	);
+
+	if ( '' !== $parsed['submit_label'] ) {
+		$schema['settings'] = array( 'submitLabel' => $parsed['submit_label'] );
+	}
+
+	$notification = atf_cf7_convert_mail( $mail, $parsed['map'], __( 'Notification', 'allterrain-forms' ) );
+
+	if ( $notification ) {
+		$schema['notifications'][] = $notification;
+	}
+
+	// Mail (2) only counts when its own switch is on — CF7 stores the settings
+	// either way, and importing a disabled autoresponder as a live one would
+	// start e-mailing visitors nobody meant to e-mail.
+	if ( ! empty( $mail_2['active'] ) ) {
+		$second = atf_cf7_convert_mail( $mail_2, $parsed['map'], __( 'Mail (2)', 'allterrain-forms' ) );
+
+		if ( $second ) {
+			$schema['notifications'][] = $second;
+		}
+	}
+
+	if ( ! empty( $messages['mail_sent_ok'] ) ) {
+		$schema['confirmations'][] = array(
+			'name'    => __( 'Thank you', 'allterrain-forms' ),
+			'type'    => 'message',
+			'message' => (string) $messages['mail_sent_ok'],
+		);
+	}
+
+	return $schema;
+}
+
+/**
+ * Parses a CF7 template into fields.
+ *
+ * @since 0.2.0
+ *
+ * @param string $template The `_form` template.
+ * @return array {
+ *     @type array[] $fields       The converted fields, in template order.
+ *     @type array   $map          CF7 field name => new field id.
+ *     @type string  $submit_label The `[submit]` tag's label, or ''.
+ * }
+ */
+function atf_cf7_parse_template( $template ) {
+	$fields       = array();
+	$map          = array();
+	$submit_label = '';
+	$next         = 1;
+
+	if ( ! preg_match_all( '/\[([a-zA-Z_][a-zA-Z0-9_]*)(\*)?((?:[^\]"]|"[^"]*")*)\]/', (string) $template, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER ) ) {
+		return array(
+			'fields'       => $fields,
+			'map'          => $map,
+			'submit_label' => $submit_label,
+		);
+	}
+
+	foreach ( $matches as $match ) {
+		$type     = strtolower( $match[1][0] );
+		$required = '' !== $match[2][0];
+		$rest     = atf_cf7_parse_tag_body( isset( $match[3][0] ) ? $match[3][0] : '' );
+		$offset   = $match[0][1];
+
+		if ( 'submit' === $type ) {
+			$submit_label = isset( $rest['values'][0] ) ? $rest['values'][0] : '';
+			continue;
+		}
+
+		// A closing tag ([/acceptance]) or a tag with no name is not a field.
+		if ( '' === $rest['name'] || '/' === $type[0] ) {
+			continue;
+		}
+
+		$field = atf_cf7_tag_to_field( $type, $required, $rest, "f{$next}" );
+
+		if ( ! $field ) {
+			continue;
+		}
+
+		$field['label'] = atf_cf7_label_for( (string) $template, $offset, $rest['name'] );
+
+		// Acceptance carries its condition as tag *content* —
+		// `[acceptance name] I agree… [/acceptance]` — which reads better as
+		// the consent line than as the label.
+		if ( 'consent' === $field['type'] ) {
+			$content = atf_cf7_tag_content( (string) $template, $offset + strlen( $match[0][0] ), 'acceptance' );
+
+			if ( '' !== $content ) {
+				$field['consentText'] = $content;
+			}
+		}
+
+		$fields[]             = $field;
+		$map[ $rest['name'] ] = $field['id'];
+		++$next;
+	}
+
+	return array(
+		'fields'       => $fields,
+		'map'          => $map,
+		'submit_label' => $submit_label,
+	);
+}
+
+/**
+ * Splits a tag's body into its name, options and quoted values.
+ *
+ * CF7's grammar inside the brackets: the first bare word is the field name,
+ * further bare words are options (`min:1`, `placeholder`, `multiple`), and
+ * every double-quoted string is a value — a choice, a default, a label.
+ *
+ * @since 0.2.0
+ *
+ * @param string $body Everything between the tag's type and its `]`.
+ * @return array { name: string, options: string[], values: string[] }
+ */
+function atf_cf7_parse_tag_body( $body ) {
+	$name    = '';
+	$options = array();
+	$values  = array();
+
+	preg_match_all( '/"([^"]*)"|(\S+)/', (string) $body, $parts, PREG_SET_ORDER );
+
+	foreach ( $parts as $part ) {
+		if ( isset( $part[1] ) && '' !== $part[0] && '"' === $part[0][0] ) {
+			$values[] = $part[1];
+			continue;
+		}
+
+		if ( '' === $name ) {
+			$name = $part[2];
+			continue;
+		}
+
+		$options[] = $part[2];
+	}
+
+	return array(
+		'name'    => $name,
+		'options' => $options,
+		'values'  => $values,
+	);
+}
+
+/**
+ * One CF7 option's parameter, e.g. `min:3` => `3`.
+ *
+ * @since 0.2.0
+ *
+ * @param string[] $options The tag's bare options.
+ * @param string   $key     The option name.
+ * @return string The part after the colon, or '' when absent.
+ */
+function atf_cf7_option( $options, $key ) {
+	foreach ( $options as $option ) {
+		if ( 0 === strpos( $option, $key . ':' ) ) {
+			return substr( $option, strlen( $key ) + 1 );
+		}
+	}
+
+	return '';
+}
+
+/**
+ * Converts one parsed tag into a field.
+ *
+ * @since 0.2.0
+ *
+ * @param string $type     The CF7 tag type, without the `*`.
+ * @param bool   $required Whether the tag carried a `*`.
+ * @param array  $rest     The parsed body: name, options, values.
+ * @param string $id       The id the new field will take.
+ * @return array|null The field, or null when the tag has no equivalent.
+ */
+function atf_cf7_tag_to_field( $type, $required, $rest, $id ) {
+	$simple = array(
+		'text'     => 'text',
+		'email'    => 'email',
+		'url'      => 'url',
+		'tel'      => 'tel',
+		'textarea' => 'textarea',
+		'number'   => 'number',
+		'range'    => 'range',
+		'date'     => 'date',
+		'hidden'   => 'hidden',
+		'file'     => 'file',
+	);
+
+	$field = array(
+		'id'       => $id,
+		'required' => $required,
+	);
+
+	$options = $rest['options'];
+	$values  = $rest['values'];
+
+	if ( isset( $simple[ $type ] ) ) {
+		$field['type'] = $simple[ $type ];
+
+		// The first quoted value is the default — unless the `placeholder`
+		// option (or its older alias `watermark`) says it is the grey hint
+		// text instead. CF7 overloads the slot; the option is the tiebreak.
+		if ( isset( $values[0] ) && '' !== $values[0] ) {
+			if ( in_array( 'placeholder', $options, true ) || in_array( 'watermark', $options, true ) ) {
+				$field['placeholder'] = $values[0];
+			} else {
+				$field['default'] = $values[0];
+			}
+		}
+
+		foreach ( array( 'min', 'max', 'minlength', 'maxlength', 'step' ) as $bound ) {
+			$value = atf_cf7_option( $options, $bound );
+
+			if ( '' !== $value ) {
+				$field[ $bound ] = $value;
+			}
+		}
+
+		if ( 'file' === $field['type'] ) {
+			unset( $field['default'], $field['placeholder'] );
+
+			$filetypes = atf_cf7_option( $options, 'filetypes' );
+
+			if ( '' !== $filetypes ) {
+				$field['filetypes'] = array_values( array_filter( array_map( 'trim', explode( '|', strtolower( $filetypes ) ) ) ) );
+			}
+		}
+
+		return $field;
+	}
+
+	switch ( $type ) {
+		case 'select':
+			$field['type']    = in_array( 'multiple', $options, true ) ? 'multiselect' : 'select';
+			$field['choices'] = atf_cf7_choices( $values );
+
+			return $field;
+
+		case 'checkbox':
+			// An `exclusive` checkbox group allows exactly one answer, which
+			// is a radio group wearing checkbox clothes.
+			$field['type']    = in_array( 'exclusive', $options, true ) ? 'radio' : 'checkboxes';
+			$field['choices'] = atf_cf7_choices( $values );
+
+			return $field;
+
+		case 'radio':
+			$field['type']    = 'radio';
+			$field['choices'] = atf_cf7_choices( $values );
+
+			return $field;
+
+		case 'acceptance':
+			$field['type'] = 'consent';
+			// CF7 acceptance is required by default; the `optional` option is
+			// how a form relaxes it.
+			$field['required'] = ! in_array( 'optional', $options, true );
+
+			return $field;
+
+		case 'quiz':
+			// CF7's quiz is an anti-spam question, and this plugin already
+			// screens for spam without charging the visitor for it.
+		case 'captchac':
+		case 'captchar':
+		case 'count':
+		case 'response':
+			return null;
+	}
+
+	// An unrecognised tag — a CF7 add-on's type — becomes a plain text field
+	// rather than disappearing: a visible field with the right label is
+	// reviewable in the builder, a silently dropped one is data loss.
+	$field['type'] = 'text';
+
+	return $field;
+}
+
+/**
+ * Turns CF7's quoted choice values into choices.
+ *
+ * CF7 supports a `label|value` pipe syntax inside each quoted string; without
+ * a pipe the label is the value, as ordinary CF7 forms use.
+ *
+ * @since 0.2.0
+ *
+ * @param string[] $values The tag's quoted strings.
+ * @return array[]
+ */
+function atf_cf7_choices( $values ) {
+	$choices = array();
+
+	foreach ( $values as $value ) {
+		$parts = explode( '|', $value, 2 );
+
+		$choices[] = array(
+			'label' => trim( $parts[0] ),
+			'value' => trim( isset( $parts[1] ) ? $parts[1] : $parts[0] ),
+		);
+	}
+
+	return $choices;
+}
+
+/**
+ * The human label for a tag, read from the markup around it.
+ *
+ * CF7's default template wraps each tag as `<label> Your name [text* your-name]
+ * </label>`, so the text between the opening `<label>` and the tag is the
+ * question as the author wrote it. When the markup does not cooperate, the
+ * field name is humanised instead — `your-name` reads as `Your name`.
+ *
+ * @since 0.2.0
+ *
+ * @param string $template The whole template.
+ * @param int    $offset   Byte offset of the tag's `[`.
+ * @param string $name     The CF7 field name, the fallback.
+ * @return string
+ */
+function atf_cf7_label_for( $template, $offset, $name ) {
+	$before = substr( $template, 0, $offset );
+
+	if ( preg_match( '/<label[^>]*>\s*([^<>\[\]]*?)\s*$/s', $before, $found ) && '' !== trim( $found[1] ) ) {
+		return trim( preg_replace( '/\s+/', ' ', $found[1] ) );
+	}
+
+	return ucfirst( str_replace( array( '-', '_' ), ' ', $name ) );
+}
+
+/**
+ * The content between a tag and its closing pair, for content-carrying tags.
+ *
+ * @since 0.2.0
+ *
+ * @param string $template The whole template.
+ * @param int    $offset   Byte offset just past the opening tag's `]`.
+ * @param string $type     The tag type, e.g. `acceptance`.
+ * @return string The trimmed content, or '' when there is no closing tag.
+ */
+function atf_cf7_tag_content( $template, $offset, $type ) {
+	$closing = strpos( $template, '[/' . $type . ']', $offset );
+
+	if ( false === $closing ) {
+		return '';
+	}
+
+	return trim( preg_replace( '/\s+/', ' ', substr( $template, $offset, $closing - $offset ) ) );
+}
+
+/**
+ * Converts one CF7 mail block into a notification.
+ *
+ * @since 0.2.0
+ *
+ * @param array  $mail The `_mail` or `_mail_2` settings.
+ * @param array  $map  CF7 field name => new field id.
+ * @param string $name The notification's display name.
+ * @return array|null The notification, or null when the block is empty.
+ */
+function atf_cf7_convert_mail( $mail, $map, $name ) {
+	$recipient = isset( $mail['recipient'] ) ? (string) $mail['recipient'] : '';
+	$body      = isset( $mail['body'] ) ? (string) $mail['body'] : '';
+
+	if ( '' === $recipient && '' === $body ) {
+		return null;
+	}
+
+	// A plain-text CF7 body routinely reads `[your-name] <[your-email]>`, and
+	// the message field is kses-filtered on save — which reads `<…>` as a bogus
+	// tag and deletes the visitor's address outright. Encoding the brackets
+	// keeps them visible. An HTML body is left alone: there the brackets *are*
+	// markup, and kses is the right judge of it.
+	if ( empty( $mail['use_html'] ) ) {
+		$body = str_replace( array( '<', '>' ), array( '&lt;', '&gt;' ), $body );
+	}
+
+	$notification = array(
+		'name'    => $name,
+		'to'      => atf_cf7_replace_mail_tags( $recipient, $map ),
+		'subject' => atf_cf7_replace_mail_tags( isset( $mail['subject'] ) ? (string) $mail['subject'] : '', $map ),
+		'message' => atf_cf7_replace_mail_tags( $body, $map ),
+	);
+
+	// CF7's sender is one string — `Name <address>` — where this plugin keeps
+	// the two halves apart.
+	$sender = isset( $mail['sender'] ) ? (string) $mail['sender'] : '';
+
+	if ( preg_match( '/^\s*(.*?)\s*<([^<>]+)>\s*$/', $sender, $parts ) ) {
+		$notification['fromName']  = atf_cf7_replace_mail_tags( $parts[1], $map );
+		$notification['fromEmail'] = atf_cf7_replace_mail_tags( $parts[2], $map );
+	} elseif ( '' !== trim( $sender ) ) {
+		$notification['fromEmail'] = atf_cf7_replace_mail_tags( trim( $sender ), $map );
+	}
+
+	$headers = isset( $mail['additional_headers'] ) ? (string) $mail['additional_headers'] : '';
+
+	if ( preg_match( '/^\s*Reply-To:\s*(.+)$/mi', $headers, $reply ) ) {
+		$notification['replyTo'] = atf_cf7_replace_mail_tags( trim( $reply[1] ), $map );
+	}
+
+	if ( ! empty( $mail['attachments'] ) ) {
+		$notification['attachFiles'] = true;
+	}
+
+	return $notification;
+}
+
+/**
+ * Rewrites CF7 mail-tags onto this plugin's merge tags.
+ *
+ * `[your-name]` becomes `{field:f1}`; the `[_site_*]` specials become their
+ * equivalents. A tag with no equivalent is left as it stands rather than
+ * silently deleted — visible in the notification editor, where the author can
+ * see what did not translate and decide what it should say.
+ *
+ * @since 0.2.0
+ *
+ * @param string $text The mail template text.
+ * @param array  $map  CF7 field name => new field id.
+ * @return string
+ */
+function atf_cf7_replace_mail_tags( $text, $map ) {
+	$specials = array(
+		'[_site_title]'       => '{site}',
+		'[_site_url]'         => '{site:url}',
+		'[_site_admin_email]' => '{admin_email}',
+		'[_date]'             => '{date}',
+		'[_time]'             => '{time}',
+		'[_remote_ip]'        => '{ip}',
+		'[_url]'              => '{referrer}',
+	);
+
+	$text = strtr( (string) $text, $specials );
+
+	return preg_replace_callback(
+		'/\[([a-zA-Z][a-zA-Z0-9_-]*)\]/',
+		static function ( $found ) use ( $map ) {
+			return isset( $map[ $found[1] ] ) ? '{field:' . $map[ $found[1] ] . '}' : $found[0];
+		},
+		$text
+	);
+}
diff --git a/includes/importers.php b/includes/importers.php
new file mode 100644
index 0000000..99efb8c
--- /dev/null
+++ b/includes/importers.php
@@ -0,0 +1,373 @@
+<?php
+/**
+ * Importers — forms brought in from other plugins.
+ *
+ * The single biggest barrier to switching form plugins is not features, it is
+ * the fifteen forms somebody already built. An importer turns each of them into
+ * an ordinary AllTerrain form: real fields, the notifications rewritten onto
+ * merge tags, the thank-you message carried over. From that moment the form is
+ * native — nothing here runs at render or submit time, and the source plugin's
+ * data is never modified or deleted.
+ *
+ * Importers read the source plugin's *data*, not its API, wherever possible.
+ * The moment somebody most wants to import is right after deactivating the old
+ * plugin — exactly when its classes are gone and its posts and tables are not.
+ *
+ * Each importer is a small array of callbacks registered on the
+ * `atf_importers` filter, so a third-party plugin can add its own source
+ * without touching this file.
+ *
+ * @package AllTerrain_Forms
+ */
+
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * The registered importers.
+ *
+ * @since 0.2.0
+ *
+ * @return array[] Importer id => {
+ *     @type string   $label     Human name of the source plugin.
+ *     @type callable $available Whether any of the source's data exists.
+ *     @type callable $forms     Source form id => title, for the picker.
+ *     @type callable $import    Imports one source form; returns the new
+ *                               form id or a WP_Error.
+ * }
+ */
+function atf_importers() {
+	/**
+	 * Filters the list of form importers.
+	 *
+	 * The built-in importers register through this same filter, exactly as a
+	 * third-party source would.
+	 *
+	 * @since 0.2.0
+	 *
+	 * @param array[] $importers Importer id => definition.
+	 */
+	$importers = apply_filters( 'atf_importers', array() );
+
+	$valid = array();
+
+	foreach ( $importers as $id => $importer ) {
+		$id = sanitize_key( $id );
+
+		if ( '' === $id || ! isset( $importer['label'], $importer['available'], $importer['forms'], $importer['import'] ) ) {
+			continue;
+		}
+
+		if ( ! is_callable( $importer['available'] ) || ! is_callable( $importer['forms'] ) || ! is_callable( $importer['import'] ) ) {
+			continue;
+		}
+
+		$valid[ $id ] = $importer;
+	}
+
+	return $valid;
+}
+
+/**
+ * The importers whose source data is actually present on this site.
+ *
+ * @since 0.2.0
+ *
+ * @return array[] Importer id => definition.
+ */
+function atf_available_importers() {
+	return array_filter(
+		atf_importers(),
+		static function ( $importer ) {
+			return (bool) call_user_func( $importer['available'] );
+		}
+	);
+}
+
+/**
+ * Imports one form from a source plugin.
+ *
+ * @since 0.2.0
+ *
+ * @param string $importer_id Which importer.
+ * @param string $source_id   The source plugin's id for the form.
+ * @return int|WP_Error The new form's id.
+ */
+function atf_import_source_form( $importer_id, $source_id ) {
+	if ( ! atf_can_edit_forms() ) {
+		return new WP_Error( 'atf_forbidden', __( 'You cannot create forms.', 'allterrain-forms' ), array( 'status' => 403 ) );
+	}
+
+	$importers   = atf_importers();
+	$importer_id = sanitize_key( $importer_id );
+
+	if ( ! isset( $importers[ $importer_id ] ) ) {
+		return new WP_Error( 'atf_unknown_importer', __( 'That importer does not exist.', 'allterrain-forms' ) );
+	}
+
+	$form_id = call_user_func( $importers[ $importer_id ]['import'], $source_id );
+
+	if ( ! is_wp_error( $form_id ) ) {
+		/**
+		 * Fires after a form is imported from another plugin.
+		 *
+		 * @since 0.2.0
+		 *
+		 * @param int    $form_id     The new form.
+		 * @param string $importer_id The importer that produced it.
+		 * @param string $source_id   The source plugin's id for the form.
+		 */
+		do_action( 'atf_form_imported', $form_id, $importer_id, (string) $source_id );
+	}
+
+	return $form_id;
+}
+
+/**
+ * Creates a form post around an imported schema.
+ *
+ * The shared tail of every importer: insert the post, normalise and save the
+ * schema, hand the id back. The schema passes through a filter first, so a
+ * site can correct a mapping this code got wrong for its data without forking
+ * the importer.
+ *
+ * @since 0.2.0
+ *
+ * @param string $title       The form's title.
+ * @param array  $schema      The converted schema, pre-normalisation.
+ * @param string $importer_id Which importer produced it.
+ * @param string $source_id   The source plugin's id for the form.
+ * @return int|WP_Error The new form's id.
+ */
+function atf_create_imported_form( $title, $schema, $importer_id, $source_id ) {
+	/**
+	 * Filters an imported schema before it is saved.
+	 *
+	 * @since 0.2.0
+	 *
+	 * @param array  $schema      The converted schema, pre-normalisation.
+	 * @param string $importer_id The importer that produced it.
+	 * @param string $source_id   The source plugin's id for the form.
+	 */
+	$schema = apply_filters( 'atf_imported_schema', $schema, $importer_id, (string) $source_id );
+
+	$form_id = wp_insert_post(
+		array(
+			'post_type'   => ATF_FORM_TYPE,
+			'post_title'  => sanitize_text_field( '' !== $title ? $title : __( 'Imported form', 'allterrain-forms' ) ),
+			'post_status' => 'publish',
+			'post_author' => get_current_user_id(),
+		),
+		true
+	);
+
+	if ( is_wp_error( $form_id ) ) {
+		return $form_id;
+	}
+
+	atf_save_form_schema( $form_id, atf_normalize_schema( $schema ) );
+
+	return $form_id;
+}
+
+/**
+ * Registers the Import page.
+ *
+ * Priority 20, after the Forms menu itself exists. With the desktop shell up
+ * the page keeps a URL but no menu entry, matching every other Forms page.
+ *
+ * @since 0.2.0
+ *
+ * @return void
+ */
+function atf_register_import_page() {
+	if ( ! atf_can_edit_forms() ) {
+		return;
+	}
+
+	if ( atf_shell_is_active() ) {
+		atf_register_hidden_page( __( 'Import forms', 'allterrain-forms' ), 'atf_edit_forms', 'allterrain-forms-import', 'atf_render_import_page' );
+
+		return;
+	}
+
+	add_submenu_page(
+		'allterrain-forms',
+		__( 'Import forms', 'allterrain-forms' ),
+		__( 'Import', 'allterrain-forms' ),
+		'atf_edit_forms',
+		'allterrain-forms-import',
+		'atf_render_import_page'
+	);
+}
+add_action( 'admin_menu', 'atf_register_import_page', 20 );
+
+/**
+ * Renders the Import page.
+ *
+ * Server-rendered on purpose. Importing is a one-time migration, not a tool
+ * anybody lives in: a plain page with real buttons asks nothing of the browser
+ * and works identically inside a shell window and out.
+ *
+ * @since 0.2.0
+ *
+ * @return void
+ */
+function atf_render_import_page() {
+	$available = atf_available_importers();
+
+	echo '<div class="wrap atf-admin">';
+	printf( '<h1 class="wp-heading-inline">%s</h1>', esc_html__( 'Import forms', 'allterrain-forms' ) );
+
+	// The outcome of the redirect that brought us here. Display only — the
+	// import itself was authorised by the nonce checked in the handler.
+	// phpcs:disable WordPress.Security.NonceVerification.Recommended
+	$imported = isset( $_GET['atf_imported'] ) ? absint( $_GET['atf_imported'] ) : 0;
+	$failed   = isset( $_GET['atf_failed'] ) ? absint( $_GET['atf_failed'] ) : 0;
+	// phpcs:enable WordPress.Security.NonceVerification.Recommended
+
+	if ( $imported || $failed ) {
+		printf(
+			'<div class="notice notice-%1$s is-dismissible"><p>%2$s%3$s</p></div>',
+			$failed ? 'warning' : 'success',
+			esc_html(
+				sprintf(
+					/* translators: %d: number of forms imported. */
+					_n( '%d form imported.', '%d forms imported.', $imported, 'allterrain-forms' ),
+					$imported
+				)
+			),
+			esc_html(
+				$failed ? ' ' . sprintf(
+					/* translators: %d: number of forms that could not be imported. */
+					_n( '%d could not be imported.', '%d could not be imported.', $failed, 'allterrain-forms' ),
+					$failed
+				) : ''
+			)
+		);
+	}
+
+	if ( ! $available ) {
+		printf(
+			'<p>%s</p></div>',
+			esc_html__( 'No importable forms were found. Importers look for data from Contact Form 7, WPForms and Gravity Forms — the data is read even when the source plugin has been deactivated.', 'allterrain-forms' )
+		);
+
+		return;
+	}
+
+	printf(
+		'<p>%s</p>',
+		esc_html__( 'Each import creates a new AllTerrain form. The original is never changed, so importing is safe to try and safe to repeat.', 'allterrain-forms' )
+	);
+
+	foreach ( $available as $id => $importer ) {
+		$forms = call_user_func( $importer['forms'] );
+
+		printf( '<h2>%s</h2>', esc_html( $importer['label'] ) );
+
+		if ( ! $forms ) {
+			printf( '<p>%s</p>', esc_html__( 'No forms found.', 'allterrain-forms' ) );
+			continue;
+		}
+
+		echo '<table class="widefat striped" style="max-width: 720px;"><tbody>';
+
+		foreach ( $forms as $source_id => $title ) {
+			printf(
+				'<tr><td>%1$s</td><td style="width: 8em; text-align: end;">
+					<form method="post" action="%2$s" style="margin: 0;">
+						<input type="hidden" name="action" value="atf_import_form" />
+						<input type="hidden" name="importer" value="%3$s" />
+						<input type="hidden" name="source" value="%4$s" />
+						%5$s
+						<button type="submit" class="button">%6$s</button>
+					</form>
+				</td></tr>',
+				esc_html( $title ),
+				esc_url( admin_url( 'admin-post.php' ) ),
+				esc_attr( $id ),
+				esc_attr( (string) $source_id ),
+				wp_nonce_field( 'atf-import', '_atf_nonce', true, false ), // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- wp_nonce_field() builds escaped markup.
+				esc_html__( 'Import', 'allterrain-forms' )
+			);
+		}
+
+		echo '</tbody></table>';
+
+		printf(
+			'<form method="post" action="%1$s" style="margin: 12px 0 24px;">
+				<input type="hidden" name="action" value="atf_import_form" />
+				<input type="hidden" name="importer" value="%2$s" />
+				<input type="hidden" name="source" value="" />
+				%3$s
+				<button type="submit" class="button button-primary">%4$s</button>
+			</form>',
+			esc_url( admin_url( 'admin-post.php' ) ),
+			esc_attr( $id ),
+			wp_nonce_field( 'atf-import', '_atf_nonce', true, false ), // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- wp_nonce_field() builds escaped markup.
+			esc_html(
+				sprintf(
+					/* translators: %s: source plugin name. */
+					__( 'Import all from %s', 'allterrain-forms' ),
+					$importer['label']
+				)
+			)
+		);
+	}
+
+	echo '</div>';
+}
+
+/**
+ * Handles the Import page's POST.
+ *
+ * An empty `source` means "all of them" — the picker's per-form buttons and
+ * its import-all button share this one handler and one nonce.
+ *
+ * @since 0.2.0
+ *
+ * @return void
+ */
+function atf_handle_import_post() {
+	if ( ! atf_can_edit_forms() ) {
+		wp_die( esc_html__( 'You cannot create forms.', 'allterrain-forms' ) );
+	}
+
+	check_admin_referer( 'atf-import', '_atf_nonce' );
+
+	$importer_id = isset( $_POST['importer'] ) ? sanitize_key( wp_unslash( $_POST['importer'] ) ) : '';
+	$source      = isset( $_POST['source'] ) ? sanitize_text_field( wp_unslash( $_POST['source'] ) ) : '';
+	$importers   = atf_importers();
+
+	$imported = 0;
+	$failed   = 0;
+
+	if ( isset( $importers[ $importer_id ] ) ) {
+		$sources = '' !== $source
+			? array( $source )
+			: array_keys( call_user_func( $importers[ $importer_id ]['forms'] ) );
+
+		foreach ( $sources as $source_id ) {
+			$result = atf_import_source_form( $importer_id, (string) $source_id );
+
+			if ( is_wp_error( $result ) ) {
+				++$failed;
+			} else {
+				++$imported;
+			}
+		}
+	}
+
+	wp_safe_redirect(
+		add_query_arg(
+			array(
+				'page'         => 'allterrain-forms-import',
+				'atf_imported' => $imported,
+				'atf_failed'   => $failed,
+			),
+			admin_url( 'admin.php' )
+		)
+	);
+	exit;
+}
+add_action( 'admin_post_atf_import_form', 'atf_handle_import_post' );
diff --git a/readme.txt b/readme.txt
index 58da6ae..e4ee3a5 100644
--- a/readme.txt
+++ b/readme.txt
@@ -89,6 +89,16 @@ they think *rounder*.
 Save it, and it is a theme you can pick on any form, export as JSON, and import
 on another site. No code, no build step.
 
+= Switching? Bring your forms with you =
+
+**Forms → Import** finds the forms other plugins left in your database — even
+after you deactivated them — and turns each one into an ordinary AllTerrain
+form: real fields, the notification emails rewritten onto your own questions,
+the thank-you message carried over. The original is never touched, so importing
+is safe to try and safe to repeat.
+
+Contact Form 7 is supported today; WPForms and Gravity Forms are next.
+
 = Anti-spam that does not charge your visitors =
 
 A honeypot, a signed time trap, a per-address rate limit, a word blocklist, and
@@ -165,6 +175,13 @@ Your data stays: forms and entries are ordinary posts, so deactivating leaves
 them in your database untouched. Uninstalling removes them, which is what
 uninstalling should do — export your entries to CSV first if you want them.
 
+= Can I import my forms from another form plugin? =
+
+Yes. **Forms → Import** lists every form it can find from Contact Form 7 —
+including forms whose plugin has already been deactivated, because the data
+outlives the plugin. Each import creates a new AllTerrain form and leaves the
+original untouched. WPForms and Gravity Forms importers are on the way.
+
 = Can I move a form to another site? =
 
 Yes. Export the form as JSON and import it on the other site. Themes export and
diff --git a/tests/phpunit/tests/importers.php b/tests/phpunit/tests/importers.php
new file mode 100644
index 0000000..1d43d9f
--- /dev/null
+++ b/tests/phpunit/tests/importers.php
@@ -0,0 +1,294 @@
+<?php
+/**
+ * The importers — other plugins' forms becoming this plugin's forms.
+ *
+ * The conversion rules are pinned against fixture data shaped exactly as the
+ * source plugin stores it, because the source plugin will not be active when
+ * the importer runs and its data is the only contract there is.
+ *
+ * @package AllTerrain_Forms
+ * @group allterrain-forms
+ */
+
+/**
+ * The importer registry and the Contact Form 7 converter.
+ *
+ * @group allterrain-forms
+ */
+class ATF_Test_Importers extends WP_UnitTestCase {
+
+	/**
+	 * A CF7 form as CF7 itself stores one: the default contact template.
+	 *
+	 * @var string
+	 */
+	const CF7_TEMPLATE = '<label> Your name
+    [text* your-name autocomplete:name] </label>
+
+<label> Your email
+    [email* your-email autocomplete:email] </label>
+
+<label> Subject
+    [text* your-subject] </label>
+
+<label> Your message (optional)
+    [textarea your-message] </label>
+
+[acceptance your-consent] I agree to the privacy policy. [/acceptance]
+
+[submit "Submit"]';
+
+	/**
+	 * Registered importers pass validation; malformed ones are dropped.
+	 *
+	 * @covers ::atf_importers
+	 */
+	public function test_registry_drops_malformed_importers() {
+		add_filter(
+			'atf_importers',
+			static function ( $importers ) {
+				$importers['no-callbacks'] = array( 'label' => 'Broken' );
+
+				return $importers;
+			}
+		);
+
+		$importers = atf_importers();
+
+		$this->assertArrayHasKey( 'contact-form-7', $importers );
+		$this->assertArrayNotHasKey( 'no-callbacks', $importers );
+	}
+
+	/**
+	 * The default CF7 contact template converts field for field.
+	 *
+	 * @covers ::atf_cf7_convert
+	 * @covers ::atf_cf7_parse_template
+	 */
+	public function test_cf7_default_template_converts() {
+		$schema = atf_normalize_schema(
+			atf_cf7_convert( self::CF7_TEMPLATE, array(), array(), array() )
+		);
+
+		$types  = wp_list_pluck( $schema['fields'], 'type' );
+		$labels = wp_list_pluck( $schema['fields'], 'label' );
+
+		$this->assertSame( array( 'text', 'email', 'text', 'textarea', 'consent' ), $types );
+		$this->assertSame( array( 'Your name', 'Your email', 'Subject', 'Your message (optional)', 'Your consent' ), $labels );
+
+		$this->assertTrue( $schema['fields'][0]['required'], 'The starred tag is required.' );
+		$this->assertFalse( $schema['fields'][3]['required'], 'The unstarred tag is optional.' );
+
+		// Acceptance is required by default and carries its content as the
+		// consent line.
+		$this->assertTrue( $schema['fields'][4]['required'] );
+		$this->assertSame( 'I agree to the privacy policy.', $schema['fields'][4]['consentText'] );
+
+		$this->assertSame( 'Submit', $schema['settings']['submitLabel'] );
+	}
+
+	/**
+	 * Choice tags carry their options across, including the pipe syntax.
+	 *
+	 * @covers ::atf_cf7_tag_to_field
+	 * @covers ::atf_cf7_choices
+	 */
+	public function test_cf7_choice_tags() {
+		$parsed = atf_cf7_parse_template(
+			'[select* your-topic "Support" "Sales|sales-team"]
+			[checkbox extras "Wrap" "Card"]
+			[checkbox one exclusive "A" "B"]
+			[radio colour "Red" "Green"]
+			[select sizes multiple "S" "M" "L"]'
+		);
+
+		$fields = $parsed['fields'];
+
+		$this->assertSame( 'select', $fields[0]['type'] );
+		$this->assertSame( 'Sales', $fields[0]['choices'][1]['label'] );
+		$this->assertSame( 'sales-team', $fields[0]['choices'][1]['value'] );
+
+		$this->assertSame( 'checkboxes', $fields[1]['type'] );
+
+		// `exclusive` means one answer only, which is a radio group.
+		$this->assertSame( 'radio', $fields[2]['type'] );
+
+		$this->assertSame( 'radio', $fields[3]['type'] );
+
+		$this->assertSame( 'multiselect', $fields[4]['type'] );
+		$this->assertCount( 3, $fields[4]['choices'] );
+	}
+
+	/**
+	 * Placeholders, defaults and bounds survive the trip.
+	 *
+	 * @covers ::atf_cf7_tag_to_field
+	 */
+	public function test_cf7_options_map_to_settings() {
+		$parsed = atf_cf7_parse_template(
+			'[text your-town placeholder "Your town"]
+			[text your-ref "ABC-1"]
+			[number your-age min:18 max:99]
+			[file your-cv filetypes:pdf|docx]'
+		);
+
+		$fields = $parsed['fields'];
+
+		$this->assertSame( 'Your town', $fields[0]['placeholder'] );
+		$this->assertArrayNotHasKey( 'default', $fields[0] );
+
+		$this->assertSame( 'ABC-1', $fields[1]['default'] );
+
+		$this->assertSame( '18', $fields[2]['min'] );
+		$this->assertSame( '99', $fields[2]['max'] );
+
+		$this->assertSame( array( 'pdf', 'docx' ), $fields[3]['filetypes'] );
+	}
+
+	/**
+	 * Anti-spam tags are dropped; unknown add-on tags become visible text
+	 * fields rather than vanishing.
+	 *
+	 * @covers ::atf_cf7_tag_to_field
+	 */
+	public function test_cf7_unmappable_tags() {
+		$parsed = atf_cf7_parse_template( '[quiz your-quiz "1+1?|2"] [captchar your-captcha] [fancy_addon your-thing]' );
+
+		$this->assertCount( 1, $parsed['fields'] );
+		$this->assertSame( 'text', $parsed['fields'][0]['type'] );
+		$this->assertSame( 'Your thing', $parsed['fields'][0]['label'] );
+	}
+
+	/**
+	 * The mail block becomes a notification with merge tags for this plugin.
+	 *
+	 * @covers ::atf_cf7_convert_mail
+	 * @covers ::atf_cf7_replace_mail_tags
+	 */
+	public function test_cf7_mail_becomes_a_notification() {
+		$schema = atf_normalize_schema(
+			atf_cf7_convert(
+				self::CF7_TEMPLATE,
+				array(
+					'recipient'          => 'you@example.com',
+					'sender'             => '[_site_title] <wordpress@example.com>',
+					'subject'            => '[_site_title] "[your-subject]"',
+					'body'               => "From: [your-name] <[your-email]>\n\n[your-message]\n\n-- \nSent from [_site_url]",
+					'additional_headers' => 'Reply-To: [your-email]',
+					'attachments'        => '',
+				),
+				array(),
+				array( 'mail_sent_ok' => 'Thank you for your message.' )
+			)
+		);
+
+		$this->assertCount( 1, $schema['notifications'] );
+
+		$mail = $schema['notifications'][0];
+
+		$this->assertSame( 'you@example.com', $mail['to'] );
+		$this->assertSame( '{site} "{field:f3}"', $mail['subject'] );
+		$this->assertSame( '{site}', $mail['fromName'] );
+		$this->assertSame( 'wordpress@example.com', $mail['fromEmail'] );
+		$this->assertSame( '{field:f2}', $mail['replyTo'] );
+		// The angle brackets survive as entities — raw `<…>` would be read as
+		// a bogus tag by the kses pass on save and the address deleted.
+		$this->assertStringContainsString( 'From: {field:f1} &lt;{field:f2}&gt;', $mail['message'] );
+		$this->assertStringContainsString( '{field:f4}', $mail['message'] );
+		$this->assertStringContainsString( '{site:url}', $mail['message'] );
+
+		$this->assertCount( 1, $schema['confirmations'] );
+		$this->assertSame( 'Thank you for your message.', $schema['confirmations'][0]['message'] );
+	}
+
+	/**
+	 * Mail (2) is only imported when CF7 had it switched on.
+	 *
+	 * @covers ::atf_cf7_convert
+	 */
+	public function test_cf7_inactive_mail_2_stays_behind() {
+		$mail_2 = array(
+			'active'    => false,
+			'recipient' => '[your-email]',
+			'body'      => 'Thanks!',
+		);
+
+		$schema = atf_cf7_convert( self::CF7_TEMPLATE, array( 'recipient' => 'a@b.c' ), $mail_2, array() );
+		$this->assertCount( 1, $schema['notifications'] );
+
+		$mail_2['active'] = true;
+
+		$schema = atf_cf7_convert( self::CF7_TEMPLATE, array( 'recipient' => 'a@b.c' ), $mail_2, array() );
+		$this->assertCount( 2, $schema['notifications'] );
+		$this->assertSame( '{field:f2}', $schema['notifications'][1]['to'] );
+	}
+
+	/**
+	 * The whole trip: a CF7 post in the database becomes a working form.
+	 *
+	 * @covers ::atf_cf7_import
+	 * @covers ::atf_import_source_form
+	 */
+	public function test_cf7_import_end_to_end() {
+		atf_add_capabilities();
+		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+
+		$source = self::factory()->post->create(
+			array(
+				'post_type'  => 'wpcf7_contact_form',
+				'post_title' => 'Contact page',
+			)
+		);
+
+		update_post_meta( $source, '_form', self::CF7_TEMPLATE );
+		update_post_meta(
+			$source,
+			'_mail',
+			array(
+				'recipient' => 'owner@example.com',
+				'body'      => '[your-message]',
+			)
+		);
+		update_post_meta( $source, '_messages', array( 'mail_sent_ok' => 'Received.' ) );
+
+		$imported_action = 0;
+		add_action(
+			'atf_form_imported',
+			static function () use ( &$imported_action ) {
+				++$imported_action;
+			}
+		);
+
+		$form_id = atf_import_source_form( 'contact-form-7', (string) $source );
+
+		$this->assertIsInt( $form_id );
+		$this->assertSame( 'Contact page', get_post( $form_id )->post_title );
+		$this->assertSame( ATF_FORM_TYPE, get_post( $form_id )->post_type );
+		$this->assertSame( 1, $imported_action );
+
+		$schema = atf_get_form_schema( $form_id );
+
+		$this->assertCount( 5, $schema['fields'] );
+		$this->assertSame( 'owner@example.com', $schema['notifications'][0]['to'] );
+		$this->assertSame( 'Received.', $schema['confirmations'][0]['message'] );
+
+		// The source is untouched — importing must never be destructive.
+		$this->assertSame( 'wpcf7_contact_form', get_post( $source )->post_type );
+		$this->assertNotEmpty( get_post_meta( $source, '_form', true ) );
+	}
+
+	/**
+	 * Importing needs the capability, and a bogus source fails cleanly.
+	 *
+	 * @covers ::atf_import_source_form
+	 */
+	public function test_import_is_gated_and_fails_cleanly() {
+		wp_set_current_user( 0 );
+		$this->assertWPError( atf_import_source_form( 'contact-form-7', '1' ) );
+
+		atf_add_capabilities();
+		wp_set_current_user( self::factory()->user->create( array( 'role' => 'administrator' ) ) );
+		$this->assertWPError( atf_import_source_form( 'no-such-importer', '1' ) );
+		$this->assertWPError( atf_import_source_form( 'contact-form-7', '999999' ) );
+	}
+}