diff --git a/examples/rich/rich.html b/examples/rich/rich.html
index d9596142e8..3d8e0e8340 100644
--- a/examples/rich/rich.html
+++ b/examples/rich/rich.html
@@ -33,12 +33,30 @@
     <script type="text/babel">
       'use strict';
 
-      const {Editor, EditorState, RichUtils} = Draft;
+      const {
+        Editor,
+        EditorState,
+        RichUtils,
+        DefaultDraftBlockRenderMap,
+        DefaultDraftInlineStyle
+      } = Draft;
 
       class RichEditorExample extends React.Component {
         constructor(props) {
           super(props);
-          this.state = {editorState: EditorState.createEmpty()};
+          this.state = {
+            editorState: EditorState.createEmpty(),
+            customBlockMap: DefaultDraftBlockRenderMap.merge(Immutable.Map({
+              'paragraph': Immutable.Map({
+                wrapper: null,
+                element: 'p'
+              }),
+              'unstyled': Immutable.Map({
+                wrapper: null,
+                element: 'p'
+              })
+            }))
+          };
 
           this.focus = () => this.refs.editor.focus();
           this.onChange = (editorState) => this.setState({editorState});
@@ -77,7 +95,7 @@
         }
 
         render() {
-          const {editorState} = this.state;
+          const {editorState, customBlockMap} = this.state;
 
           // If the user changes block type before entering any text, we can
           // either style the placeholder or hide it. Let's just hide it now.
@@ -101,6 +119,7 @@
               />
               <div className={className} onClick={this.focus}>
                 <Editor
+                  customBlockMap={customBlockMap}
                   blockStyleFn={getBlockStyle}
                   customStyleMap={styleMap}
                   editorState={editorState}
@@ -157,6 +176,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 58a50a870f..e39c80eb81 100644
--- a/src/Draft.js
+++ b/src/Draft.js
@@ -11,6 +11,8 @@
 
 'use strict';
 
+const DefaultDraftBlockRenderMap = require('DefaultDraftBlockRenderMap');
+const DefaultDraftInlineStyle = require('DefaultDraftInlineStyle');
 const BlockMapBuilder = require('BlockMapBuilder');
 const CharacterMetadata = require('CharacterMetadata');
 const CompositeDraftDecorator = require('CompositeDraftDecorator');
@@ -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 e9666e53d3..4456dfa952 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');
@@ -38,6 +39,7 @@ import type ContentBlock from 'ContentBlock';
 import type {DraftEditorModes} from 'DraftEditorModes';
 import type {DraftEditorProps} from 'DraftEditorProps';
 import type {DraftScrollPosition} from 'DraftScrollPosition';
+import type {DraftBlockRenderMap} from 'DraftBlockRenderMap';
 
 const isIE = UserAgent.isBrowser('IE');
 
@@ -58,6 +60,7 @@ const handlerMap = {
 type DefaultProps = {
   blockRendererFn?: (block: ContentBlock) => ?Object;
   blockStyleFn?: (type: number) => string,
+  customBlockMap: DraftBlockRenderMap,
   keyBindingFn?: (e: SyntheticKeyboardEvent) => ?string,
   readOnly?: boolean,
   spellCheck?: boolean,
@@ -78,6 +81,7 @@ class DraftEditor
   state: State;
 
   static defaultProps = {
+    customBlockMap: DefaultDraftBlockRenderMap,
     blockRendererFn: emptyFunction.thatReturnsNull,
     blockStyleFn: emptyFunction.thatReturns(''),
     keyBindingFn: getDefaultKeyBinding,
@@ -280,6 +284,7 @@ class DraftEditor
             <DraftEditorContents
               blockRendererFn={nullthrows(this.props.blockRendererFn)}
               blockStyleFn={nullthrows(this.props.blockStyleFn)}
+              customBlockMap={nullthrows(this.props.customBlockMap)}
               customStyleMap={
                 {...DefaultDraftInlineStyle, ...this.props.customStyleMap}
               }
diff --git a/src/component/base/DraftEditorProps.js b/src/component/base/DraftEditorProps.js
index a7af2ed3e0..e8e3a8e1d1 100644
--- a/src/component/base/DraftEditorProps.js
+++ b/src/component/base/DraftEditorProps.js
@@ -18,6 +18,7 @@ import type {DraftDragType} from 'DraftDragType';
 import type {DraftTextAlignment} from 'DraftTextAlignment';
 import type EditorState from 'EditorState';
 import type SelectionState from 'SelectionState';
+import type {DraftBlockRenderMap} from 'DraftBlockRenderMap';
 
 export type DraftEditorProps = {
   /**
@@ -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 configurable blockRenderTypes, each type then define
+  // a mapping element tag and/or a react element wrapper that is used for
+  // rendering and paste processing
+  customBlockMap: DraftBlockRenderMap,
 };
diff --git a/src/component/contents/DraftEditorContents.react.js b/src/component/contents/DraftEditorContents.react.js
index e96b7db018..6a79004101 100644
--- a/src/component/contents/DraftEditorContents.react.js
+++ b/src/component/contents/DraftEditorContents.react.js
@@ -19,8 +19,7 @@ const EditorState = require('EditorState');
 const React = require('React');
 
 const cx = require('cx');
-const getElementForBlockType = require('getElementForBlockType');
-const getWrapperTemplateForBlockType = require('getWrapperTemplateForBlockType');
+const DefaultDraftBlockRenderMap = require('DefaultDraftBlockRenderMap');
 const joinClasses = require('joinClasses');
 const nullthrows = require('nullthrows');
 
@@ -136,10 +135,17 @@ class DraftEditorContents extends React.Component {
         tree: editorState.getBlockTree(key),
       };
 
-      wrapperTemplate = getWrapperTemplateForBlockType(blockType);
+      const draftBlockRenderMap = this.props.customBlockMap;
+
+      wrapperTemplate = draftBlockRenderMap.getIn([blockType, 'wrapper']);
+
       const useNewWrapper = wrapperTemplate !== currentWrapperTemplate;
 
-      const Element = getElementForBlockType(blockType);
+      const unstyledElement = draftBlockRenderMap.getIn(['unstyled', 'element']) ||
+        DefaultDraftBlockRenderMap.getIn(['unstyled', 'element']);
+
+      const Element = draftBlockRenderMap.getIn([blockType, 'element']) || unstyledElement;
+
       const depth = block.getDepth();
       let className = this.props.blockStyleFn(block);
 
@@ -173,7 +179,7 @@ class DraftEditorContents extends React.Component {
         };
       }
 
-      // $FlowFixMe: Support DOM elements in React.createElement
+      // FlowFixMe: Support DOM elements in React.createElement
       child = React.createElement(
         Element,
         childProps,
diff --git a/src/component/handlers/edit/editOnPaste.js b/src/component/handlers/edit/editOnPaste.js
index 9e07ba4c2f..2b69d8d29a 100644
--- a/src/component/handlers/edit/editOnPaste.js
+++ b/src/component/handlers/edit/editOnPaste.js
@@ -128,7 +128,7 @@ 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.customBlockMap);
       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 25ab2e7cdd..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 'media':
-      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 9912b528b2..15a30b44b3 100644
--- a/src/model/constants/DraftBlockType.js
+++ b/src/model/constants/DraftBlockType.js
@@ -17,7 +17,6 @@
  */
 export type DraftBlockType = (
   'unstyled' |
-  'paragraph' |
   'header-one' |
   'header-two' |
   'header-three' |
@@ -27,7 +26,6 @@ export type DraftBlockType = (
   'unordered-list-item' |
   'ordered-list-item' |
   'blockquote' |
-  'pullquote' |
   'code-block' |
   'media'
 );
diff --git a/src/model/encoding/convertFromHTMLToContentBlocks.js b/src/model/encoding/convertFromHTMLToContentBlocks.js
index 5626326974..b9139c723f 100644
--- a/src/model/encoding/convertFromHTMLToContentBlocks.js
+++ b/src/model/encoding/convertFromHTMLToContentBlocks.js
@@ -25,8 +25,11 @@ const invariant = require('invariant');
 const nullthrows = require('nullthrows');
 const sanitizeDraftText = require('sanitizeDraftText');
 
+const DefaultDraftBlockRenderMap = require('DefaultDraftBlockRenderMap');
+
 import type {DraftBlockType} from 'DraftBlockType';
 import type {DraftInlineStyle} from 'DraftInlineStyle';
+import type {DraftBlockRenderMap} from 'DraftBlockRenderMap';
 
 var {
   List,
@@ -46,7 +49,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 +118,80 @@ 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') {
+    if (lastList === 'ol') {
+      return 'ordered-list-item';
+    }
+    return 'unordered-list-item';
+  }
+
+  return null;
+}
+
+function getBlockMapSupportedTags(
+  draftBlockRenderMap: DraftBlockRenderMap
+): Array<string> {
+  const unstyledElement = draftBlockRenderMap.getIn(['unstyled', 'element']) ||
+    DefaultDraftBlockRenderMap.getIn(['unstyled', 'element']);
+
+  const supportedTags = draftBlockRenderMap
+    .map((config) => config.get('element'))
+    .valueSeq()
+    .toSet()
+    .filter((tag) => tag !== unstyledElement)
+    .toArray()
+    .sort();
+
+  return supportedTags;
+}
+
+// custom element conversions
+function getMultiMatchedType(
+  tag: string,
+  lastList: ?string,
+  multiMatchExtractor: Array<Function>
+): ?DraftBlockType {
+  for (var i = 0; i < multiMatchExtractor.length; i++) {
+    const matchType = multiMatchExtractor[i](tag, lastList);
+
+    if (matchType) {
+      return matchType;
+    }
+  }
+
+  return null;
+}
+
+function getBlockTypeForTag(
+  tag: string,
+  lastList: ?string,
+  draftBlockRenderMap: DraftBlockRenderMap
+): DraftBlockType {
+  const matchedTypes = draftBlockRenderMap
+    .filter((blockType) => {
+      return blockType.get('element') === tag ||
+        blockType.get('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 +267,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 +290,7 @@ function genFragment(
   inBlock: ?string,
   blockTags: Array<string>,
   depth: number,
+  draftBlockRenderMap: DraftBlockRenderMap,
   inEntity?: string
 ): Chunk {
   var nodeName = node.nodeName.toLowerCase();
@@ -271,8 +326,11 @@ function genFragment(
   // BR tags
   if (nodeName === 'br') {
     if (
-        lastLastBlock === 'br' &&
-        (!inBlock || getBlockTypeForTag(inBlock, lastList) === 'unstyled')
+      lastLastBlock === 'br' &&
+      (
+        !inBlock ||
+        getBlockTypeForTag(inBlock, lastList, draftBlockRenderMap) === 'unstyled'
+      )
     ) {
       return getBlockDividerChunk('unstyled', depth);
     }
@@ -296,14 +354,14 @@ function genFragment(
   // Block Tags
   if (!inBlock && blockTags.indexOf(nodeName) !== -1) {
     chunk = getBlockDividerChunk(
-      getBlockTypeForTag(nodeName, lastList),
+      getBlockTypeForTag(nodeName, lastList, draftBlockRenderMap),
       depth
     );
     inBlock = nodeName;
     newBlock = true;
   } else if (lastList && inBlock === 'li' && nodeName === 'li') {
     chunk = getBlockDividerChunk(
-      getBlockTypeForTag(nodeName, lastList),
+      getBlockTypeForTag(nodeName, lastList, draftBlockRenderMap),
       depth
     );
     inBlock = nodeName;
@@ -337,6 +395,7 @@ function genFragment(
       inBlock,
       blockTags,
       depth,
+      draftBlockRenderMap,
       entityId || inEntity
     );
 
@@ -367,12 +426,18 @@ function genFragment(
   return chunk;
 }
 
-function getChunkForHTML(html: string, DOMBuilder: Function): ?Chunk {
+function getChunkForHTML(
+  html: string,
+  DOMBuilder: Function,
+  draftBlockRenderMap: DraftBlockRenderMap
+): ?Chunk {
   html = html
     .trim()
     .replace(REGEX_CR, '')
     .replace(REGEX_NBSP, SPACE);
 
+  const supportedBlockTags = getBlockMapSupportedTags(draftBlockRenderMap);
+
   var safeBody = DOMBuilder(html);
   if (!safeBody) {
     return null;
@@ -382,12 +447,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,
+    draftBlockRenderMap
+  );
+
 
   // join with previous block to prevent weirdness on paste
   if (chunk.text.indexOf('\r') === 0) {
@@ -425,12 +500,16 @@ function getChunkForHTML(html: string, DOMBuilder: Function): ?Chunk {
 function convertFromHTMLtoContentBlocks(
   html: string,
   DOMBuilder: Function = getSafeBodyFromHTML,
+  customBlockMap: ?DraftBlockRenderMap
 ): ?Array<ContentBlock> {
+  const draftBlockRenderMap = customBlockMap !== undefined ? customBlockMap : DefaultDraftBlockRenderMap;
+
   // 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, draftBlockRenderMap);
+
   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..e364bc54bd
--- /dev/null
+++ b/src/model/immutable/DefaultDraftBlockRenderMap.js
@@ -0,0 +1,74 @@
+/**
+ * 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 React = require('React');
+
+const Immutable = require('immutable');
+
+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 = Immutable.Map({
+  'header-one': Immutable.Map({
+    element: 'h1',
+    wrapper: null
+  }),
+  'header-two': Immutable.Map({
+    element: 'h2',
+    wrapper: null
+  }),
+  'header-three': Immutable.Map({
+    element: 'h3',
+    wrapper: null
+  }),
+  'header-four': Immutable.Map({
+    element: 'h4',
+    wrapper: null
+  }),
+  'header-five': Immutable.Map({
+    element: 'h5',
+    wrapper: null
+  }),
+  'header-six': Immutable.Map({
+    element: 'h6',
+    wrapper: null
+  }),
+  'unordered-list-item': Immutable.Map({
+    element: 'li',
+    wrapper: UL_WRAP
+  }),
+  'ordered-list-item': Immutable.Map({
+    element: 'li',
+    wrapper: OL_WRAP
+  }),
+  'blockquote': Immutable.Map({
+    element: 'blockquote',
+    wrapper: null
+  }),
+  'media': Immutable.Map({
+    element: 'figure',
+    wrapper: null
+  }),
+  'code-block': Immutable.Map({
+    element: 'pre',
+    wrapper: PRE_WRAP
+  }),
+  'unstyled': Immutable.Map({
+    element: 'div',
+    wrapper: null
+  })
+});
diff --git a/src/model/immutable/DraftBlockRenderConfig.js b/src/model/immutable/DraftBlockRenderConfig.js
new file mode 100644
index 0000000000..3e0d32dd92
--- /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';
+
+const React = require('React');
+
+import type Immutable from 'immutable';
+import type {DraftBlockTag} from 'DraftBlockTag';
+
+export type DraftBlockRenderConfig = Immutable.Map<DraftBlockTag, React.Element>
diff --git a/src/model/immutable/DraftBlockRenderMap.js b/src/model/immutable/DraftBlockRenderMap.js
new file mode 100644
index 0000000000..f15f481b1b
--- /dev/null
+++ b/src/model/immutable/DraftBlockRenderMap.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 DraftBlockRenderMap
+ * @flow
+ */
+
+'use strict';
+
+import type Immutable from 'immutable';
+
+import type {DraftBlockRenderConfig} from 'DraftBlockRenderConfig';
+import type {DraftBlockType} from 'DraftBlockType';
+
+export type DraftBlockRenderMap = Immutable.Map<DraftBlockType, DraftBlockRenderConfig>
diff --git a/src/model/paste/DraftPasteProcessor.js b/src/model/paste/DraftPasteProcessor.js
index b01dc87663..229cd8e4f0 100644
--- a/src/model/paste/DraftPasteProcessor.js
+++ b/src/model/paste/DraftPasteProcessor.js
@@ -22,14 +22,16 @@ const convertFromHTMLtoContentBlocks
 const generateRandomKey = require('generateRandomKey');
 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, customBlockMap: ?DraftBlockRenderMap): ?Array<ContentBlock> {
+    return convertFromHTMLtoContentBlocks(html, undefined, customBlockMap);
   },
 
   processText(
diff --git a/src/model/paste/__tests__/DraftPasteProcessor-test.js b/src/model/paste/__tests__/DraftPasteProcessor-test.js
index b9c9091e5f..b44a62713b 100644
--- a/src/model/paste/__tests__/DraftPasteProcessor-test.js
+++ b/src/model/paste/__tests__/DraftPasteProcessor-test.js
@@ -14,8 +14,47 @@
 jest.autoMockOff();
 
 var DraftEntity = require('DraftEntity');
+var Immutable = require('immutable');
 
 var DraftPasteProcessor = require('DraftPasteProcessor');
+var CUSTOM_BLOCK_MAP = Immutable.Map({
+  'header-one': Immutable.Map({
+    element: 'h1',
+    wrapper: null
+  }),
+  'header-two': Immutable.Map({
+    element: 'h2',
+    wrapper: null
+  }),
+  'header-three': Immutable.Map({
+    element: 'h3',
+    wrapper: null
+  }),
+  'unordered-list-item': Immutable.Map({
+    element: 'li',
+    wrapper: null
+  }),
+  'ordered-list-item': Immutable.Map({
+    element: 'li',
+    wrapper: null
+  }),
+  'blockquote': Immutable.Map({
+    element: 'blockquote',
+    wrapper: null
+  }),
+  'code-block': Immutable.Map({
+    element: 'pre',
+    wrapper: null
+  }),
+  'paragraph': Immutable.Map({
+    element: 'p',
+    wrapper: null
+  }),
+  'unstyled': Immutable.Map({
+    element: 'div',
+    wrapper: null
+  })
+});
 
 describe('DraftPasteProcessor', function() {
   function assertInlineStyles(block, comparison) {
@@ -50,25 +89,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 +121,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 +130,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 +142,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 +160,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 +170,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 +205,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 +235,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 +252,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 +293,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 +307,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 +330,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 +351,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',