# react-frame-component

> React component to wrap your application or component in an iFrame for encapsulation purposes

Latest version **5.3.2** (published 2026-03-29) · MIT license · 0 weekly downloads

## Install

```sh
npm install react-frame-component
pnpm add react-frame-component
yarn add react-frame-component
bun add react-frame-component
```

## Health

**Score 70/100 (B)** — status: stable.

Positive: has types; esm support; no vulnerabilities; has provenance; high maintenance score; high quality score.

Warnings: low downloads.

## Facts

| | |
|---|---|
| Version | 5.3.2 |
| Published | 2026-03-29 |
| First published | 2014-05-17 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | ESM + CommonJS |
| Dependencies | 0 |
| Unpacked size | 38.6 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Provenance | attested (GitHub Actions) |
| GitHub stars | 1812 |
| Author | Ryan Seddon |
| Maintainers | ryanseddon |
| Keywords | React, component, iFrame, browser |

## Links

- npm: https://www.npmjs.com/package/react-frame-component
- Repository: https://github.com/ryanseddon/react-frame-component
- Issues: https://github.com/ryanseddon/react-frame-component/issues
- npm.io page: https://npm.io/package/react-frame-component

## Alternatives

- [mobx-react](https://npm.io/package/mobx-react.md) — 2.8M weekly downloads
- [rc-tree](https://npm.io/package/rc-tree.md) — 2.6M weekly downloads
- [@react-oauth/google](https://npm.io/package/@react-oauth/google.md) — 1.3M weekly downloads
- [@wagmi/connectors](https://npm.io/package/@wagmi/connectors.md) — 877.0K weekly downloads
- [vee-validate](https://npm.io/package/vee-validate.md) — 836.4K weekly downloads

## Recent versions

- 5.3.2 (latest) — 2026-03-29
- 0.0.0-canary-20260323223911 (canary) — 2026-03-23
- 5.2.3-alpha.0 (alpha) — 2022-07-06
- 5.3.1 — 2026-03-24
- 5.3.0 — 2026-03-22
- 5.2.7 — 2024-05-30
- 5.2.6 — 2023-01-15
- 5.2.5 — 2022-12-31
- 5.2.4 — 2022-12-19
- 5.2.3 — 2022-05-24
- 5.2.2 — 2022-05-16
- 5.2.2-alpha.1 — 2022-02-01
- 5.2.2-alpha.0 — 2022-01-11
- 5.2.1 — 2021-12-08
- 5.2.0 — 2021-12-02
- … 45 more at https://npm.io/package/react-frame-component/versions

## README

# React <Frame /> component

[![NPM version][npm-image]][npm-url] [![Build Status][travis-image]][travis-url] [![Dependency Status][depstat-image]][depstat-url]

This component allows you to encapsulate your entire React application or per component in an iFrame.

```bash
npm install --save react-frame-component
```

## How to use:

```js
import Frame from 'react-frame-component';
```

Go check out the [demo][demo-url].

```html
const Header = ({ children }) => (
  <Frame>
    <h1>{children}</h1>
  </Frame>
);

ReactDOM.render(<Header>Hello</Header>, document.body);
```

Or you can wrap it at the `render` call.

```html
ReactDOM.render(
  <Frame>
    <Header>Hello</Header>
  </Frame>,
  document.body
);
```

##### Props:

###### head
`head:  PropTypes.node`

The `head` prop is a dom node that gets inserted before the children of the frame. Note that this is injected into the body of frame (see the blog post for why). This has the benefit of being able to update and works for stylesheets.

###### initialContent
`initialContent:  PropTypes.string`

Defaults to `'<!DOCTYPE html><html><head></head><body><div></div></body></html>'`

The `initialContent` props is the initial html injected into frame. It is only injected once, but allows you to insert any html into the frame (e.g. a head tag, script tags, etc). Note that it does *not* update if you change the prop. Also at least one div is required in the body of the html, which we use to render the react dom into.

###### mountTarget
`mountTarget:  PropTypes.string`

The `mountTarget` props is a css selector (#target/.target) that specifies where in the `initialContent` of the iframe, children will be mounted.

```html
<Frame
  initialContent='<!DOCTYPE html><html><head></head><body><h1>i wont be changed</h1><div id="mountHere"></div></body></html>'
  mountTarget='#mountHere'
  >
</Frame>
```

###### dangerouslyUseDocWrite
`dangerouslyUseDocWrite: PropTypes.bool`

Defaults to `false`

The frame's initial content, as defined by the `initialContent` prop, is populated via the frame's `srcdoc` attribute by default. However, this can cause issues with some libraries such as Recaptcha and Google Maps that depend on the frame's location/origin. In these cases, setting this flag will cause `Frame` to use `document.write()` to populate the initial content. This is **unperformant and unrecommended**, but allows these libraries to be used inside a `Frame` instance.

###### contentDidMount and contentDidUpdate
`contentDidMount:  PropTypes.func`
`contentDidUpdate:  PropTypes.func`

`contentDidMount` and `contentDidUpdate` are conceptually equivalent to
`componentDidMount` and `componentDidUpdate`, respectively. The reason these are
needed is because internally we call `ReactDOM.render` which starts a new set of
lifecycle calls. This set of lifecycle calls are sometimes triggered after the
lifecycle of the parent component, so these callbacks provide a hook to know
when the frame contents are mounted and updated.

###### ref
`ref: PropTypes.oneOfType([ PropTypes.func, PropTypes.shape({ current: PropTypes.instanceOf(Element) }) ])`

The `ref` prop provides a way to access inner iframe DOM node. To utilitize this prop use, for example, one of the React's built-in methods to create a ref: [`React.createRef()`](https://reactjs.org/docs/refs-and-the-dom.html#creating-refs) or [`React.useRef()`](https://reactjs.org/docs/hooks-reference.html#useref).

```js
const MyComponent = (props) => {
  const iframeRef = React.useRef();

  React.useEffect(() => {
    // Use iframeRef for:
    // - focus managing
    // - triggering imperative animations
    // - integrating with third-party DOM libraries
    iframeRef.current.focus()
  }, [])

  return (
    <Frame ref={iframeRef}>
      <InnerComponent />
    </Frame>
  );
}
```

##### Accessing the iframe's window and document
The iframe's `window` and `document` may be accessed via the `FrameContextConsumer` or the `useFrame` hook.

The example with `FrameContextConsumer`:

```js
import Frame, { FrameContextConsumer } from 'react-frame-component'

const MyComponent = (props, context) => (
  <Frame>
    <FrameContextConsumer>
      {
        // Callback is invoked with iframe's window and document instances
        ({document, window}) => {
          // Render Children
        }
      }
    </FrameContextConsumer>
  </Frame>
);

```

The example with `useFrame` hook:

```js
import Frame, { useFrame } from 'react-frame-component';

const InnerComponent = () => {
  // Hook returns iframe's window and document instances from Frame context
  const { document, window } = useFrame();

  return null;
};

const OuterComponent = () => (
  <Frame>
    <InnerComponent />
  </Frame>
);
```

## More info

I wrote a [blog post][blog-url] about building this component.

## License

Copyright 2014, Ryan Seddon.
This content is released under the MIT license http://ryanseddon.mit-license.org

[npm-url]: https://npmjs.org/package/react-frame-component
[npm-image]: https://badge.fury.io/js/react-frame-component.png

[travis-url]: http://travis-ci.org/ryanseddon/react-frame-component
[travis-image]: https://secure.travis-ci.org/ryanseddon/react-frame-component.png?branch=master

[depstat-url]: https://david-dm.org/ryanseddon/react-frame-component
[depstat-image]: https://david-dm.org/ryanseddon/react-frame-component.png

[demo-url]: http://ryanseddon.github.io/react-frame-component/
[blog-url]: https://medium.com/@ryanseddon/rendering-to-iframes-in-react-d1cb92274f86

---
_Source: https://npm.io/package/react-frame-component · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._