diff --git a/examples/rich/rich.html b/examples/rich/rich.html
index d9596142e8..9f88b04106 100644
--- a/examples/rich/rich.html
+++ b/examples/rich/rich.html
@@ -33,12 +33,34 @@
     <script type="text/babel">
       'use strict';
 
-      const {Editor, EditorState, RichUtils} = Draft;
+      const {
+        Editor,
+        EditorState,
+        RichUtils,
+        DefaultDraftBlockRenderMap,
+      } = Draft;
+
+      const {Map} = immutable;
 
       class RichEditorExample extends React.Component {
         constructor(props) {
           super(props);
-          this.state = {editorState: EditorState.createEmpty()};
+
+          const customBlockRendering = Map({
+            'paragraph': {
+              element: 'p',
+            },
+            'unstyled': {
+              element: 'p',
+            },
+          });
+
+          this.state = {
+            blockRenderMap: DefaultDraftBlockRenderMap.merge(
+              customBlockRenderMap,
+            ),
+            editorState: EditorState.createEmpty(),
+          };
 
           this.focus = () => this.refs.editor.focus();
           this.onChange = (editorState) => this.setState({editorState});
@@ -101,6 +123,7 @@
               />
               <div className={className} onClick={this.focus}>
                 <Editor
+                  blockRenderMap={this.state.blockRenderMap}
                   blockStyleFn={getBlockStyle}
                   customStyleMap={styleMap}
                   editorState={editorState}
@@ -157,6 +180,7 @@
       }
 
       const BLOCK_TYPES = [
+        {label: 'P', style:  'paragraph'},
         {label: 'H1', style: 'header-one'},
         {label: 'H2', style: 'header-two'},
         {label: 'H3', style: 'header-three'},
diff --git a/src/Draft.js b/src/Draft.js
index 2bee3c6f29..dd370384b3 100644
--- a/src/Draft.js
+++ b/src/Draft.js
@@ -17,6 +17,8 @@ const CharacterMetadata = require('CharacterMetadata');
 const CompositeDraftDecorator = require('CompositeDraftDecorator');
 const ContentBlock = require('ContentBlock');
 const ContentState = require('ContentState');
+const DefaultDraftBlockRenderMap = require('DefaultDraftBlockRenderMap');
+const DefaultDraftInlineStyle = require('DefaultDraftInlineStyle');
 const DraftEditor = require('DraftEditor.react');
 const DraftEditorBlock = require('DraftEditorBlock.react');
 const DraftModifier = require('DraftModifier');
@@ -55,6 +57,9 @@ const DraftPublic = {
   Modifier: DraftModifier,
   RichUtils: RichTextEditorUtil,
 
+  DefaultDraftBlockRenderMap,
+  DefaultDraftInlineStyle,
+
   convertFromHTML: convertFromHTMLToContentBlocks,
   convertFromRaw: convertFromRawToDraftState,
   convertToRaw: convertFromDraftStateToRaw,
diff --git a/src/component/base/DraftEditor.react.js b/src/component/base/DraftEditor.react.js
index 6ed7c22a7e..6f17cb921c 100644
--- a/src/component/base/DraftEditor.react.js
+++ b/src/component/base/DraftEditor.react.js
@@ -13,6 +13,7 @@
 
 'use strict';
 
+const DefaultDraftBlockRenderMap = require('DefaultDraftBlockRenderMap');
 const DefaultDraftInlineStyle = require('DefaultDraftInlineStyle');
 const DraftEditorCompositionHandler = require('DraftEditorCompositionHandler');
 const DraftEditorContents = require('DraftEditorContents.react');
@@ -34,7 +35,6 @@ const nullthrows = require('nullthrows');
 const getScrollPosition = require('getScrollPosition');
 
 import type {BlockMap} from 'BlockMap';
-import type ContentBlock from 'ContentBlock';
 import type {DraftEditorModes} from 'DraftEditorModes';
 import type {DraftEditorProps} from 'DraftEditorProps';
 import type {DraftScrollPosition} from 'DraftScrollPosition';
@@ -55,15 +55,6 @@ const handlerMap = {
   'render': null,
 };
 
-type DefaultProps = {
-  blockRendererFn?: (block: ContentBlock) => ?Object;
-  blockStyleFn?: (type: number) => string,
-  keyBindingFn?: (e: SyntheticKeyboardEvent) => ?string,
-  readOnly?: boolean,
-  spellCheck?: boolean,
-  stripPastedStyles?: boolean,
-};
-
 type State = {
   containerKey: number,
 };
@@ -73,11 +64,12 @@ type State = {
  * div, and provides a wide variety of useful function props for managing the
  * state of the editor. See `DraftEditorProps` for details.
  */
-class DraftEditor
-  extends React.Component<DefaultProps, DraftEditorProps, State> {
+class DraftEditor extends React.Component {
+  props: DraftEditorProps;
   state: State;
 
   static defaultProps = {
+    blockRenderMap: DefaultDraftBlockRenderMap,
     blockRendererFn: emptyFunction.thatReturnsNull,
     blockStyleFn: emptyFunction.thatReturns(''),
     keyBindingFn: getDefaultKeyBinding,
@@ -216,6 +208,7 @@ class DraftEditor
         />
       );
     }
+    return null;
   }
 
   render(): React.Element {
@@ -283,8 +276,9 @@ class DraftEditor
             suppressContentEditableWarning
             tabIndex={this.props.tabIndex}>
             <DraftEditorContents
-              blockRendererFn={nullthrows(this.props.blockRendererFn)}
-              blockStyleFn={nullthrows(this.props.blockStyleFn)}
+              blockRenderMap={this.props.blockRenderMap}
+              blockRendererFn={this.props.blockRendererFn}
+              blockStyleFn={this.props.blockStyleFn}
               customStyleMap={
                 {...DefaultDraftInlineStyle, ...this.props.customStyleMap}
               }
diff --git a/src/component/base/DraftEditorProps.js b/src/component/base/DraftEditorProps.js
index a7af2ed3e0..d0a738d7aa 100644
--- a/src/component/base/DraftEditorProps.js
+++ b/src/component/base/DraftEditorProps.js
@@ -13,8 +13,9 @@
 'use strict';
 
 import type ContentBlock from 'ContentBlock';
-import type {DraftEditorCommand} from 'DraftEditorCommand';
+import type {DraftBlockRenderMap} from 'DraftBlockRenderMap';
 import type {DraftDragType} from 'DraftDragType';
+import type {DraftEditorCommand} from 'DraftEditorCommand';
 import type {DraftTextAlignment} from 'DraftTextAlignment';
 import type EditorState from 'EditorState';
 import type SelectionState from 'SelectionState';
@@ -129,4 +130,9 @@ export type DraftEditorProps = {
   // Provide a map of inline style names corresponding to CSS style objects
   // that will be rendered for matching ranges.
   customStyleMap?: Object,
+
+  // Provide a map of block rendering configurations. Each block type maps to
+  // an element tag and am optional react element wrapper. This configuration
+  // is used for both rendering and paste processing.
+  blockRenderMap: DraftBlockRenderMap,
 };
diff --git a/src/component/contents/DraftEditorContents.react.js b/src/component/contents/DraftEditorContents.react.js
index 1bc45c28e1..46b4ad41b9 100644
--- a/src/component/contents/DraftEditorContents.react.js
+++ b/src/component/contents/DraftEditorContents.react.js
@@ -19,8 +19,6 @@ const EditorState = require('EditorState');
 const React = require('React');
 
 const cx = require('cx');
-const getElementForBlockType = require('getElementForBlockType');
-const getWrapperTemplateForBlockType = require('getWrapperTemplateForBlockType');
 const joinClasses = require('joinClasses');
 const nullthrows = require('nullthrows');
 
@@ -93,7 +91,13 @@ class DraftEditorContents extends React.Component {
   }
 
   render(): React.Element {
-    const {blockRendererFn, customStyleMap, editorState} = this.props;
+    const {
+      blockRenderMap,
+      blockRendererFn,
+      customStyleMap,
+      editorState,
+    } = this.props;
+
     const content = editorState.getCurrentContent();
     const selection = editorState.getSelection();
     const forceSelection = editorState.mustForceSelection();
@@ -136,10 +140,19 @@ class DraftEditorContents extends React.Component {
         tree: editorState.getBlockTree(key),
       };
 
-      wrapperTemplate = getWrapperTemplateForBlockType(blockType);
+      // Block render map must have a configuration specified for this
+      // block type.
+      const configForType = nullthrows(blockRenderMap.get(blockType));
+
+      wrapperTemplate = configForType.wrapper;
+
       const useNewWrapper = wrapperTemplate !== currentWrapperTemplate;
 
-      const Element = getElementForBlockType(blockType);
+      const Element = (
+        blockRenderMap.get(blockType).element ||
+        blockRenderMap.get('unstyled').element
+      );
+
       const depth = block.getDepth();
       let className = this.props.blockStyleFn(block);
 
diff --git a/src/component/handlers/edit/editOnPaste.js b/src/component/handlers/edit/editOnPaste.js
index 9e07ba4c2f..ba933e9ceb 100644
--- a/src/component/handlers/edit/editOnPaste.js
+++ b/src/component/handlers/edit/editOnPaste.js
@@ -128,7 +128,10 @@ function editOnPaste(e: SyntheticClipboardEvent): void {
 
     // If there is html paste data, try to parse that.
     if (html) {
-      var htmlFragment = DraftPasteProcessor.processHTML(html);
+      var htmlFragment = DraftPasteProcessor.processHTML(
+        html,
+        this.props.blockRenderMap
+      );
       if (htmlFragment) {
         var htmlMap = BlockMapBuilder.createFromArray(htmlFragment);
         this.update(insertFragment(this.props.editorState, htmlMap));
diff --git a/src/component/utils/getElementForBlockType.js b/src/component/utils/getElementForBlockType.js
deleted file mode 100644
index bc354669ef..0000000000
--- a/src/component/utils/getElementForBlockType.js
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- *
- * @providesModule getElementForBlockType
- * @flow
- */
-
-'use strict';
-
-import type {DraftBlockType} from 'DraftBlockType';
-
-function getElementForBlockType(blockType: DraftBlockType): string {
-  switch (blockType) {
-    case 'header-one':
-      return 'h1';
-    case 'header-two':
-      return 'h2';
-    case 'header-three':
-      return 'h3';
-    case 'header-four':
-      return 'h4';
-    case 'header-five':
-      return 'h5';
-    case 'header-six':
-      return 'h6';
-    case 'unordered-list-item':
-    case 'ordered-list-item':
-      return 'li';
-    case 'blockquote':
-      return 'blockquote';
-    case 'atomic':
-      return 'figure';
-    default:
-      return 'div';
-  }
-}
-
-module.exports = getElementForBlockType;
diff --git a/src/component/utils/getWrapperTemplateForBlockType.js b/src/component/utils/getWrapperTemplateForBlockType.js
deleted file mode 100644
index aca1d68ea6..0000000000
--- a/src/component/utils/getWrapperTemplateForBlockType.js
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- *
- * @providesModule getWrapperTemplateForBlockType
- * @flow
- */
-
-'use strict';
-
-const React = require('React');
-
-const cx = require('cx');
-
-import type {DraftBlockType} from 'DraftBlockType';
-
-/**
- * Create these elements once and cache them so they're reference-equal.
- */
-const UL_WRAP = <ul className={cx('public/DraftStyleDefault/ul')} />;
-const OL_WRAP = <ol className={cx('public/DraftStyleDefault/ol')} />;
-const PRE_WRAP = <pre className={cx('public/DraftStyleDefault/pre')} />;
-
-function getWrapperTemplateForBlockType(
-  blockType: DraftBlockType
-): ?React.Element {
-  switch (blockType) {
-    case 'unordered-list-item':
-      return UL_WRAP;
-    case 'ordered-list-item':
-      return OL_WRAP;
-    case 'code-block':
-      return PRE_WRAP;
-    default:
-      return null;
-  }
-}
-
-module.exports = getWrapperTemplateForBlockType;
diff --git a/src/model/constants/DraftBlockTag.js b/src/model/constants/DraftBlockTag.js
new file mode 100644
index 0000000000..7739323e2b
--- /dev/null
+++ b/src/model/constants/DraftBlockTag.js
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule DraftBlockTag
+ * @flow
+ */
+
+'use strict';
+
+/**
+ * The list of default valid block tags.
+ */
+export type DraftBlockTag = (
+  'div' |
+  'p' |
+  'h1' |
+  'h2' |
+  'h3' |
+  'h4' |
+  'h5' |
+  'h6' |
+  'li' |
+  'blockquote' |
+  'pre' |
+  'figure'
+);
diff --git a/src/model/constants/DraftBlockType.js b/src/model/constants/DraftBlockType.js
index 123c840d66..d45e0378ac 100644
--- a/src/model/constants/DraftBlockType.js
+++ b/src/model/constants/DraftBlockType.js
@@ -27,7 +27,6 @@ export type DraftBlockType = (
   'unordered-list-item' |
   'ordered-list-item' |
   'blockquote' |
-  'pullquote' |
   'code-block' |
   'atomic'
 );
diff --git a/src/model/encoding/convertFromHTMLToContentBlocks.js b/src/model/encoding/convertFromHTMLToContentBlocks.js
index 5626326974..51b95c6e9e 100644
--- a/src/model/encoding/convertFromHTMLToContentBlocks.js
+++ b/src/model/encoding/convertFromHTMLToContentBlocks.js
@@ -15,6 +15,7 @@
 
 const CharacterMetadata = require('CharacterMetadata');
 const ContentBlock = require('ContentBlock');
+const DefaultDraftBlockRenderMap = require('DefaultDraftBlockRenderMap');
 const DraftEntity = require('DraftEntity');
 const Immutable = require('immutable');
 const URI = require('URI');
@@ -25,6 +26,7 @@ const invariant = require('invariant');
 const nullthrows = require('nullthrows');
 const sanitizeDraftText = require('sanitizeDraftText');
 
+import type {DraftBlockRenderMap} from 'DraftBlockRenderMap';
 import type {DraftBlockType} from 'DraftBlockType';
 import type {DraftInlineStyle} from 'DraftInlineStyle';
 
@@ -46,7 +48,6 @@ var REGEX_NBSP = new RegExp(NBSP, 'g');
 
 // Block tag flow is different because LIs do not have
 // a deterministic style ;_;
-var blockTags = ['p', 'h1', 'h2', 'h3', 'li', 'blockquote', 'pre'];
 var inlineTags = {
   b: 'BOLD',
   code: 'CODE',
@@ -116,31 +117,69 @@ function getBlockDividerChunk(block: DraftBlockType, depth: number): Chunk {
   };
 }
 
-function getBlockTypeForTag(tag: string, lastList: ?string): DraftBlockType {
-  switch (tag) {
-    case 'h1':
-      return 'header-one';
-    case 'h2':
-      return 'header-two';
-    case 'h3':
-      return 'header-three';
-    case 'h4':
-      return 'header-four';
-    case 'h5':
-      return 'header-five';
-    case 'h6':
-      return 'header-six';
-    case 'li':
-      if (lastList === 'ol') {
-        return 'ordered-list-item';
-      }
-      return 'unordered-list-item';
-    case 'blockquote':
-      return 'blockquote';
-    case 'pre':
-      return 'code-block';
-    default:
+function getListBlockType(
+  tag: string,
+  lastList: ?string
+): ?DraftBlockType {
+  if (tag === 'li') {
+    return lastList === 'ol' ? 'ordered-list-item' : 'unordered-list-item';
+  }
+  return null;
+}
+
+function getBlockMapSupportedTags(
+  blockRenderMap: DraftBlockRenderMap
+): Array<string> {
+  const unstyledElement = blockRenderMap.get('unstyled').element;
+  return blockRenderMap
+    .map((config) => config.element)
+    .valueSeq()
+    .toSet()
+    .filter((tag) => tag !== unstyledElement)
+    .toArray()
+    .sort();
+}
+
+// custom element conversions
+function getMultiMatchedType(
+  tag: string,
+  lastList: ?string,
+  multiMatchExtractor: Array<Function>
+): ?DraftBlockType {
+  for (let ii = 0; ii < multiMatchExtractor.length; ii++) {
+    const matchType = multiMatchExtractor[ii](tag, lastList);
+    if (matchType) {
+      return matchType;
+    }
+  }
+  return null;
+}
+
+function getBlockTypeForTag(
+  tag: string,
+  lastList: ?string,
+  blockRenderMap: DraftBlockRenderMap
+): DraftBlockType {
+  const matchedTypes = blockRenderMap
+    .filter((config) => config.element === tag || config.wrapper === tag)
+    .keySeq()
+    .toSet()
+    .toArray()
+    .sort();
+
+  // if we dont have any matched type, return unstyled
+  // if we have one matched type return it
+  // if we have multi matched types use the multi-match function to gather type
+  switch (matchedTypes.length) {
+    case 0:
       return 'unstyled';
+    case 1:
+      return matchedTypes[0];
+    default:
+      return (
+        getMultiMatchedType(tag, lastList, [getListBlockType]) ||
+        'unstyled'
+      );
   }
 }
 
@@ -216,7 +255,10 @@ function joinChunks(A: Chunk, B: Chunk): Chunk {
  * block tags from. If we do, we can use those and ignore <div> tags. If we
  * don't, we can treat <div> tags as meaningful (unstyled) blocks.
  */
-function containsSemanticBlockMarkup(html: string): boolean {
+function containsSemanticBlockMarkup(
+  html: string,
+  blockTags: Array<string>
+): boolean {
   return blockTags.some(tag => html.indexOf('<' + tag) !== -1);
 }
 
@@ -236,6 +278,7 @@ function genFragment(
   inBlock: ?string,
   blockTags: Array<string>,
   depth: number,
+  blockRenderMap: DraftBlockRenderMap,
   inEntity?: string
 ): Chunk {
   var nodeName = node.nodeName.toLowerCase();
@@ -271,8 +314,11 @@ function genFragment(
   // BR tags
   if (nodeName === 'br') {
     if (
-        lastLastBlock === 'br' &&
-        (!inBlock || getBlockTypeForTag(inBlock, lastList) === 'unstyled')
+      lastLastBlock === 'br' &&
+      (
+        !inBlock ||
+        getBlockTypeForTag(inBlock, lastList, blockRenderMap) === 'unstyled'
+      )
     ) {
       return getBlockDividerChunk('unstyled', depth);
     }
@@ -296,14 +342,14 @@ function genFragment(
   // Block Tags
   if (!inBlock && blockTags.indexOf(nodeName) !== -1) {
     chunk = getBlockDividerChunk(
-      getBlockTypeForTag(nodeName, lastList),
+      getBlockTypeForTag(nodeName, lastList, blockRenderMap),
       depth
     );
     inBlock = nodeName;
     newBlock = true;
   } else if (lastList && inBlock === 'li' && nodeName === 'li') {
     chunk = getBlockDividerChunk(
-      getBlockTypeForTag(nodeName, lastList),
+      getBlockTypeForTag(nodeName, lastList, blockRenderMap),
       depth
     );
     inBlock = nodeName;
@@ -337,6 +383,7 @@ function genFragment(
       inBlock,
       blockTags,
       depth,
+      blockRenderMap,
       entityId || inEntity
     );
 
@@ -367,12 +414,18 @@ function genFragment(
   return chunk;
 }
 
-function getChunkForHTML(html: string, DOMBuilder: Function): ?Chunk {
+function getChunkForHTML(
+  html: string,
+  DOMBuilder: Function,
+  blockRenderMap: DraftBlockRenderMap
+): ?Chunk {
   html = html
     .trim()
     .replace(REGEX_CR, '')
     .replace(REGEX_NBSP, SPACE);
 
+  const supportedBlockTags = getBlockMapSupportedTags(blockRenderMap);
+
   var safeBody = DOMBuilder(html);
   if (!safeBody) {
     return null;
@@ -382,12 +435,22 @@ function getChunkForHTML(html: string, DOMBuilder: Function): ?Chunk {
   // Sometimes we aren't dealing with content that contains nice semantic
   // tags. In this case, use divs to separate everything out into paragraphs
   // and hope for the best.
-  var workingBlocks = containsSemanticBlockMarkup(html) ? blockTags : ['div'];
+  var workingBlocks = containsSemanticBlockMarkup(html, supportedBlockTags) ?
+    supportedBlockTags :
+    ['div'];
 
   // Start with -1 block depth to offset the fact that we are passing in a fake
   // UL block to start with.
-  var chunk =
-    genFragment(safeBody, OrderedSet(), 'ul', null, workingBlocks, -1);
+  var chunk = genFragment(
+    safeBody,
+    OrderedSet(),
+    'ul',
+    null,
+    workingBlocks,
+    -1,
+    blockRenderMap
+  );
+
 
   // join with previous block to prevent weirdness on paste
   if (chunk.text.indexOf('\r') === 0) {
@@ -425,12 +488,14 @@ function getChunkForHTML(html: string, DOMBuilder: Function): ?Chunk {
 function convertFromHTMLtoContentBlocks(
   html: string,
   DOMBuilder: Function = getSafeBodyFromHTML,
+  blockRenderMap?: DraftBlockRenderMap = DefaultDraftBlockRenderMap,
 ): ?Array<ContentBlock> {
   // Be ABSOLUTELY SURE that the dom builder you pass hare won't execute
   // arbitrary code in whatever environment you're running this in. For an
   // example of how we try to do this in-browser, see getSafeBodyFromHTML.
 
-  var chunk = getChunkForHTML(html, DOMBuilder);
+  var chunk = getChunkForHTML(html, DOMBuilder, blockRenderMap);
+
   if (chunk == null) {
     return null;
   }
diff --git a/src/model/immutable/DefaultDraftBlockRenderMap.js b/src/model/immutable/DefaultDraftBlockRenderMap.js
new file mode 100644
index 0000000000..25de00eaac
--- /dev/null
+++ b/src/model/immutable/DefaultDraftBlockRenderMap.js
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule DefaultDraftBlockRenderMap
+ * @flow
+ */
+
+'use strict';
+
+const {Map} = require('immutable');
+const React = require('React');
+
+const cx = require('cx');
+
+const UL_WRAP = <ul className={cx('public/DraftStyleDefault/ul')} />;
+const OL_WRAP = <ol className={cx('public/DraftStyleDefault/ol')} />;
+const PRE_WRAP = <pre className={cx('public/DraftStyleDefault/pre')} />;
+
+module.exports = Map({
+  'header-one': {
+    element: 'h1',
+  },
+  'header-two': {
+    element: 'h2',
+  },
+  'header-three': {
+    element: 'h3',
+  },
+  'header-four': {
+    element: 'h4',
+  },
+  'header-five': {
+    element: 'h5',
+  },
+  'header-six': {
+    element: 'h6',
+  },
+  'unordered-list-item': {
+    element: 'li',
+    wrapper: UL_WRAP,
+  },
+  'ordered-list-item': {
+    element: 'li',
+    wrapper: OL_WRAP,
+  },
+  'blockquote': {
+    element: 'blockquote',
+  },
+  'atomic': {
+    element: 'figure',
+  },
+  'code-block': {
+    element: 'pre',
+    wrapper: PRE_WRAP,
+  },
+  'unstyled': {
+    element: 'div',
+  },
+});
diff --git a/src/model/immutable/DraftBlockRenderConfig.js b/src/model/immutable/DraftBlockRenderConfig.js
new file mode 100644
index 0000000000..d7515ded1c
--- /dev/null
+++ b/src/model/immutable/DraftBlockRenderConfig.js
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule DraftBlockRenderConfig
+ * @flow
+ */
+
+'use strict';
+
+import type React from 'react';
+
+export type DraftBlockRenderConfig = {
+  element: string;
+  wrapper?: React.Element;
+};
diff --git a/src/model/immutable/DraftBlockRenderMap.js b/src/model/immutable/DraftBlockRenderMap.js
new file mode 100644
index 0000000000..d27cf44511
--- /dev/null
+++ b/src/model/immutable/DraftBlockRenderMap.js
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule DraftBlockRenderMap
+ * @flow
+ */
+
+'use strict';
+
+import type {DraftBlockRenderConfig} from 'DraftBlockRenderConfig';
+import type {DraftBlockType} from 'DraftBlockType';
+import type {Map} from 'immutable';
+
+export type DraftBlockRenderMap = Map<DraftBlockType, DraftBlockRenderConfig>;
diff --git a/src/model/paste/DraftPasteProcessor.js b/src/model/paste/DraftPasteProcessor.js
index b01dc87663..4b3e4eddaa 100644
--- a/src/model/paste/DraftPasteProcessor.js
+++ b/src/model/paste/DraftPasteProcessor.js
@@ -20,16 +20,26 @@ const Immutable = require('immutable');
 const convertFromHTMLtoContentBlocks
   = require('convertFromHTMLToContentBlocks');
 const generateRandomKey = require('generateRandomKey');
+const getSafeBodyFromHTML = require('getSafeBodyFromHTML');
 const sanitizeDraftText = require('sanitizeDraftText');
 
+import type {DraftBlockRenderMap} from 'DraftBlockRenderMap';
+
 const {
   List,
   Repeat,
 } = Immutable;
 
 const DraftPasteProcessor = {
-  processHTML(html: string): ?Array<ContentBlock> {
-    return convertFromHTMLtoContentBlocks(html);
+  processHTML(
+    html: string,
+    blockRenderMap?: DraftBlockRenderMap
+  ): ?Array<ContentBlock> {
+    return convertFromHTMLtoContentBlocks(
+      html,
+      getSafeBodyFromHTML,
+      blockRenderMap
+    );
   },
 
   processText(
diff --git a/src/model/paste/__tests__/DraftPasteProcessor-test.js b/src/model/paste/__tests__/DraftPasteProcessor-test.js
index 3eeb042518..cf577835de 100644
--- a/src/model/paste/__tests__/DraftPasteProcessor-test.js
+++ b/src/model/paste/__tests__/DraftPasteProcessor-test.js
@@ -14,8 +14,38 @@
 jest.disableAutomock();
 
 var DraftEntity = require('DraftEntity');
+var Immutable = require('immutable');
 
 var DraftPasteProcessor = require('DraftPasteProcessor');
+var CUSTOM_BLOCK_MAP = Immutable.Map({
+  'header-one': {
+    element: 'h1',
+  },
+  'header-two': {
+    element: 'h2',
+  },
+  'header-three': {
+    element: 'h3',
+  },
+  'unordered-list-item': {
+    element: 'li',
+  },
+  'ordered-list-item': {
+    element: 'li',
+  },
+  'blockquote': {
+    element: 'blockquote',
+  },
+  'code-block': {
+    element: 'pre',
+  },
+  'paragraph': {
+    element: 'p',
+  },
+  'unstyled': {
+    element: 'div',
+  },
+});
 
 describe('DraftPasteProcessor', function() {
   function assertInlineStyles(block, comparison) {
@@ -50,25 +80,25 @@ describe('DraftPasteProcessor', function() {
 
   it('must identify italics text', function() {
     var html = '<i>hello</i> hi';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     var block = output[0];
     expect(block.getType()).toBe('unstyled');
     assertInlineStyles(block, [
-      ['ITALIC'],
-      ['ITALIC'],
-      ['ITALIC'],
-      ['ITALIC'],
-      ['ITALIC'],
-      [],
-      [],
-      [],
+    ['ITALIC'],
+    ['ITALIC'],
+    ['ITALIC'],
+    ['ITALIC'],
+    ['ITALIC'],
+    [],
+    [],
+    [],
     ]);
     expect(block.getText()).toBe('hello hi');
   });
 
   it('must identify overlapping inline styles', function() {
     var html = '<i><b>he</b>hi</i>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     var block = output[0];
     expect(block.getType()).toBe('unstyled');
     assertInlineStyles(block, [
@@ -82,7 +112,7 @@ describe('DraftPasteProcessor', function() {
 
   it('must identify block styles', function() {
     var html = '<ol><li>hi</li><li>there</li></ol>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'ordered-list-item',
       'ordered-list-item',
@@ -91,7 +121,7 @@ describe('DraftPasteProcessor', function() {
 
   it('must collapse nested blocks to the topmost level', function() {
     var html = '<ul><li><h2>what</h2></li></ul>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'unordered-list-item',
     ]);
@@ -103,16 +133,16 @@ describe('DraftPasteProcessor', function() {
    *
    * it('must suppress blocks nested inside other blocks', function() {
    *   var html = '<p><h2>Some text here</h2> more text here </p>';
-   *   var output = DraftPasteProcessor.processHTML(html);
+   *   var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
    *   assertBlockTypes(output, [
-   *     'unstyled',
+   *   'unstyled',
    *   ]);
    * });
    */
 
   it('must detect two touching blocks', function() {
-    var html = '<h1>hi</h1>        <h2>hi</h2>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var html = '<h1>hi</h1>    <h2>hi</h2>';
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'header-one',
       'header-two',
@@ -121,7 +151,7 @@ describe('DraftPasteProcessor', function() {
 
   it('must insert a block when needed', function() {
     var html = ' <h1> hi </h1><h1> </h1><span> whatever </span> <h2>hi </h2> ';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'header-one',
       'unstyled',
@@ -131,33 +161,33 @@ describe('DraftPasteProcessor', function() {
 
   it('must not generate fake blocks on heavy nesting', function() {
     var html = '<p><span><span><span>Word</span></span></span>' +
-      '<span><span>,</span></span></p>';
-    var output = DraftPasteProcessor.processHTML(html);
-    assertBlockTypes(output, ['unstyled']);
+    '<span><span>,</span></span></p>';
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
+    assertBlockTypes(output, ['paragraph']);
   });
 
   it('must preserve spaces', function() {
     var html, output;
 
     html = '<span>hello</span> <span>hi</span>';
-    output = DraftPasteProcessor.processHTML(html);
+    output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output.length).toEqual(1);
     assertBlockTypes(output, ['unstyled']);
     var block = output[0];
     expect(block.getText()).toBe('hello hi');
 
     html = '<span>hello </span><span>hi</span>';
-    output = DraftPasteProcessor.processHTML(html);
+    output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output[0].getText()).toBe('hello hi');
 
     html = '<span>hello</span><span> hi</span>';
-    output = DraftPasteProcessor.processHTML(html);
+    output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output[0].getText()).toEqual('hello hi');
   });
 
   it('must treat divs as Ps when we do not have semantic markup', function() {
     var html = '<div>hi</div><div>hello</div>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'unstyled',
       'unstyled',
@@ -166,28 +196,28 @@ describe('DraftPasteProcessor', function() {
 
   it('must NOT treat divs as Ps when we pave Ps', function() {
     var html = '<div><p>hi</p><p>hello</p></div>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
-      'unstyled',
-      'unstyled',
+      'paragraph',
+      'paragraph',
     ]);
   });
 
   it('must replace br tags with soft newlines', function() {
     var html = 'hi<br>hello';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output[0].getText()).toBe('hi\nhello');
   });
 
   it('must split unstyled blocks on two br tags', function() {
     var html = 'hi<br><br>hello';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'unstyled',
       'unstyled',
     ]);
-    html = '<p>hi<br><br>hello</p>';
-    output = DraftPasteProcessor.processHTML(html);
+    html = '<div>hi<br><br>hello</div>';
+    output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'unstyled',
       'unstyled',
@@ -196,13 +226,13 @@ describe('DraftPasteProcessor', function() {
 
   it('must NOT split unstyled blocks inside a styled block', function() {
     var html = '<pre>hi<br><br>hello</pre>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, ['code-block']);
   });
 
   it('must split unstyled blocks on two br tags', function() {
     var html = 'hi<br><br>hello';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output[0].getText().length).toBe(3);
     expect(output[1].getText()).toBe('hello');
     assertBlockTypes(output, [
@@ -213,27 +243,27 @@ describe('DraftPasteProcessor', function() {
 
   it('must replace newlines in regular tags', function() {
     var html = '<div>hello\nthere</div>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output[0].getText()).toBe('hello there');
   });
 
   it('must preserve newlines in pre tags', function() {
     var html = '<pre>hello\nthere</pre>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output[0].getText()).toBe('hello\nthere');
   });
 
   it('must preserve newlines in whitespace in pre tags', function() {
     var html = '<pre><span>hello</span>\n<span>there</span></pre>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output[0].getText()).toBe('hello\nthere');
     assertBlockTypes(output, ['code-block']);
   });
 
   it('must parse based on style attribute', function() {
     var html = '<span style="font-weight: bold;">Bold '
-      + '<span style="font-style: italic;">Italic</span></span>.';
-    var output = DraftPasteProcessor.processHTML(html);
+    + '<span style="font-style: italic;">Italic</span></span>.';
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, ['unstyled']);
     assertInlineStyles(output[0], [
       ['BOLD'],
@@ -254,11 +284,11 @@ describe('DraftPasteProcessor', function() {
 
   it('must detect links in pasted content', function() {
     var html = 'This is a <a href="http://www.facebook.com">link</a>, yep.';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, ['unstyled']);
     assertEntities(
-      output[0],
-      Array(10).fill(false).concat(Array(4).fill(true), Array(6).fill(false))
+    output[0],
+    Array(10).fill(false).concat(Array(4).fill(true), Array(6).fill(false))
     );
     expect(output[0].getText()).toBe('This is a link, yep.');
     var entityId = output[0].getCharacterList().get(12).getEntity();
@@ -268,22 +298,22 @@ describe('DraftPasteProcessor', function() {
 
   it('must preserve styles inside links in a good way', function() {
     var html = 'A <a href="http://www.facebook.com"><i>cool</i> link</a>, yep.';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, ['unstyled']);
     assertInlineStyles(
-      output[0],
-      Array(2).fill([]).concat(Array(4).fill(['ITALIC']), Array(11).fill([]))
+    output[0],
+    Array(2).fill([]).concat(Array(4).fill(['ITALIC']), Array(11).fill([]))
     );
     assertEntities(
-      output[0],
-      Array(2).fill(false).concat(Array(9).fill(true), Array(6).fill(false))
+    output[0],
+    Array(2).fill(false).concat(Array(9).fill(true), Array(6).fill(false))
     );
     expect(output[0].getText()).toBe('A cool link, yep.');
   });
 
   it('must ignore links that do not actually link anywhere', function() {
     var html = 'This is a <a>link</a>, yep.';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, ['unstyled']);
     assertEntities(output[0], Array(20).fill(false));
     expect(output[0].getText()).toBe('This is a link, yep.');
@@ -291,20 +321,20 @@ describe('DraftPasteProcessor', function() {
 
   it('Tolerate doule BR tags separated by whitespace', function() {
     var html = 'hi<br>  <br>hello';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'unstyled',
       'unstyled',
     ]);
-    html = '<p>hi<br> <br>hello</p>';
-    output = DraftPasteProcessor.processHTML(html);
+    html = '<div>hi<br> <br>hello</div>';
+    output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'unstyled',
       'unstyled',
     ]);
 
-    html = '<p>hi<br> good stuff here <br>hello</p>';
-    output = DraftPasteProcessor.processHTML(html);
+    html = '<div>hi<br> good stuff here <br>hello</div>';
+    output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'unstyled',
     ]);
@@ -312,26 +342,26 @@ describe('DraftPasteProcessor', function() {
 
   it('Strip whitespace after block dividers', function() {
     var html = '<p>hello</p> <p> what</p>';
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     expect(output[1].getText()).toBe('what');
   });
 
   it('must preserve list formatting', function() {
     var html = `
-      what
-      <ul>
-          <li>what</li>
-          <li>
-              what
-              <ol>
-                  <li>one</li>
-                  <li>two</li>
-              </ol>
-          </li>
-          <li>what</li>
-      </ul>
+    what
+    <ul>
+      <li>what</li>
+      <li>
+        what
+        <ol>
+          <li>one</li>
+          <li>two</li>
+        </ol>
+      </li>
+      <li>what</li>
+    </ul>
     `;
-    var output = DraftPasteProcessor.processHTML(html);
+    var output = DraftPasteProcessor.processHTML(html, CUSTOM_BLOCK_MAP);
     assertBlockTypes(output, [
       'unstyled',
       'unordered-list-item',