Announcing: Observable for Teams

Folks, thanks for all the feedback, assistance, and friendly collaboration you’ve provided on the forums. It’s been very gratifying to see this community (still in its infancy!) be so incredibly supportive and helpful to one another.

Today, we’re pleased to announce that Observable for Teams is now available to everyone. As you may have noticed, we’ve been dogfooding them for a while, under the @observablehq account.

Teams include unlimited private and published team notebooks, live multiplayer editing (although of course you’re free to send team suggestions as well), live comments, and shared secrets, so that you can safely connect to internal APIs from your private team notebooks. We also have a long list of exciting future team features that we’re looking forward to getting started on, now that this initial version is out the door.

Check them out at:

And of course, let us know what you think, right here on the forums.


@jashkenas Excellent idea. How would this work for sharing private team notebooks with clients? I wouldn’t want to force them to subscribe, but I would like them to be able to try the notebook and give inline comments with minimal hassle.

I suppose we could embed private notebooks with a key + our own authentication (e.x. Basic Authentication), but it would also be nice to have some clients interact directly with a notebook.

Currently, the way it would work with private team notebooks is like this:

Your team creates a private notebook, gets it into a rough draft state, then uses “Share link” to make the notebook accessible to anyone with the secret URL.

You email the client the notebook URL, and they can try it out. Because they don’t belong to your team, they can’t comment on it directly, but they can mark the notebook up with a set of comments as a fork, and send it back to you as a suggestion.

On that suggestion, your team and the clients can live comment back and forth, and you can merge or reject the changes as you see fit.

I hope that helps…

Thanks, yes that clarifies how it would work. Unfortunately, that wouldn’t work in our context. A shared link could potentially expose private data and work.

We’d be looking for a way for a client (or non-dev colleague) to securely connect and provide feedback. I’m thinking this might mean they’d need to be a ‘guest’ member of the team so that they could not make changes to code (and thus wouldn’t have full access to the features that a subscribed team member would have) but the data and notebook would remain secure.

That’s an excellent feature request (and something we’ve discussed in the past). We’ll put it back on top of the pile.


@jashkenas We’d likely subscribe to this service once the security/privacy features have been added and a client/guest feedback mechanism is available.

The other feature that would make me even more interested is if pricing was set according to usage – like Slack’s pricing model. You subscribe your whole team, but if they never sign in for a while then billing is reduced accordingly. This prevents unnecessary decisions about who should (re)subscribe and gives us a feeling that we’re paying for what we use.


Can one of my ‘team’ members be a program? Specifically, can a credentialed program publish (via an API) to a notebook?

I have a use case for automated generation of notebook content.

As far as I know there is not an API for creating/editing notebooks. But if there were, it could be used in many ways (though could also maybe be abused in many ways). I for one would be interested to use such an API for integrating observable with native-app text editors.

Using Observable’s internal REST API to perform authenticated actions requires two things:

  • faking the origin by adding an origin header that contains “
  • (for logins via GitHub) obtaining and using Observable’s GitHub clientId

Both actions actively work around restrictions and may violate Observable’s TOS. If you still want to go down that road, you could start here:

  • observable-client, a library to perform both authenticated and unauthenticated requests against Observable’s API (currently only supports GitHub and GitHub 2FA),
  • observable-local (written by @meetamit), a project that supposedly provides local editing (haven’t tested it myself yet),
  • a list of the authenticated routes (just an unminified excerpt from the application bundle js).

There’s also a transparent proxy, but so far it has only been tested with unauthenticated requests.


@jrus and @mootari covered the question pretty well, but to reiterate in an Official Response™ tone of voice:

There is no public API (yet) for programmatically creating, editing and publishing notebooks. It is possible to use our internal API to do these things, but we don’t recommend it, because it may change at any time and break your code … and because in order to access it, you effectively have to steal your own login token — which means that you’re trusting the code to which you’re passing it to not steal your notebooks, corrupt them, or impersonate you on the site.

So it’s very much Swim At Your Own Risk.